Erste Schritte mit der Formularerkennung

Artikel
03/20/2023

Dieser Artikel gilt für:Formularerkennung v3.0. Ältere Version:Formularerkennung v2.1

Führen Sie erste Schritte mit der neuesten Version der Azure-Formularerkennung aus. Die Azure-Formularerkennung ist eine cloudbasierte Instanz von Azure Applied AI Services, die Machine Learning verwendet, um Schlüssel-Wert-Paare, Text, Tabellen und Schlüsseldaten aus Ihren Dokumenten zu extrahieren. Sie können Formularerkennungsmodelle einfach in Ihre Workflows und Anwendungen integrieren, indem Sie ein SDK in der Programmiersprache Ihrer Wahl verwenden oder die REST-API aufrufen. Für diesen Schnellstart sollten Sie den kostenlosen Dienst nutzen, wenn Sie die Technologie erlernen. Bedenken Sie, dass die Anzahl der kostenlosen Seiten auf 500 pro Monat beschränkt ist.

Weitere Informationen zu Funktionen der Formularerkennung und zu Entwicklungsoptionen finden Sie auf unserer Übersichtsseite.

SDK-Referenz|API-Referenz | Paket (NuGet) | Beispiele | Unterstützte REST-API-Versionen

In dieser Schnellstartanleitung verwenden Sie die folgenden Features, um Daten und Werte aus Formularen und Dokumenten zu analysieren und zu extrahieren:

Allgemeines Dokumentenmodell: Analysieren und Extrahieren von Text, Tabellen, Strukturen, Schlüssel-Wert-Paaren
Layout-Modell – Analysieren und Extrahieren von Tabellen, Zeilen, Wörtern und Auswahlmarkierungen wie Optionsfelder und Kontrollkästchen in Dokumenten, ohne dass ein Modell trainiert werden muss.
Vordefiniertes Modell – Analysieren und Extrahieren von gemeinsamen Feldern aus bestimmten Dokumenttypen mithilfe eines vordefinierten Modells.

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Aktuelle Version der Visual Studio-IDE
Eine Cognitive Services- oder Formularerkennungsressource. Sobald Sie Ihr Azure-Abonnement haben, erstellen Sie im Azure-Portal eine Ressource für einen einzelnen Dienst oder für mehrere Dienste, um Ihren Schlüssel und Endpunkt zu erhalten.
Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.

Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Es ist ein Problem mit den Voraussetzungen aufgetreten.

Einrichten

Starten Sie Visual Studio.
Wählen Sie auf der Startseite Neues Projekt erstellen aus.
Geben Sie auf der Seite Neues Projekt erstellen im Suchfeld den Suchbegriff Konsole ein. Wählen Sie die Vorlage Konsolenanwendung und dann Weiter aus.
Geben Sie im Dialogfeld Neues Projekt konfigurieren im Feld für den Projektnamen den Namen formRecognizer_quickstart ein. Wählen Sie anschließend „Weiter“ aus.
Wählen Sie im Dialogfenster Zusätzliche Informationen die Option .NET 6.0 (Langzeitunterstützung), und wählen Sie dann Erstellen.

Beim Setup ist ein Problem aufgetreten.

Installieren der Clientbibliothek mit NuGet

Klicken Sie mit der rechten Maustaste auf das Projekt formRecognizer_quickstart, und wählen Sie die Option NuGet-Pakete verwalten... aus.
Wählen Sie die Registerkarte „Durchsuchen“ aus, und geben Sie „Azure.AI.FormRecognizer“ ein.
Wählen Sie im Dropdownmenü Version 4.0.0 aus, und installieren Sie das Paket in Ihrem Projekt.

Bei der Installation des NuGet-Pakets ist ein Problem aufgetreten.

Erstellen Ihrer Anwendung

Für die Interaktion mit dem Dienst „Formularerkennung“ müssen Sie eine Instanz der DocumentAnalysisClient-Klasse erstellen. Hierzu erstellen Sie ein AzureKeyCredential-Element mit Ihrem key-Element im Azure-Portal sowie eine DocumentAnalysisClient-Instanz mit AzureKeyCredential und dem Endpunkt (endpoint) der Formularerkennung.

Hinweis

Ab .NET 6 erzeugen neue Projekte, die die Vorlage console verwenden, einen neuen Programmstil, der sich von früheren Versionen unterscheidet.
Die neue Ausgabe verwendet aktuelle C#-Funktionen, die den zu schreibenden Code vereinfachen.
Wenn Sie die neuere Version verwenden, müssen Sie nur den Text der Main-Methode schreiben. Sie müssen keine Top-Level-Anweisungen, globale Nutzungsanweisungen oder indirekte Nutzungsanweisungen einfügen.
Weitere Informationen finden Sie unter sieheNeue C#-Schablonen erzeugen Top-Level-Anweisungen.

Öffnen Sie die Datei Program.cs.
Löschen Sie den bereits vorhandenen Code, einschließlich der Zeile Console.Writeline("Hello World!"), und wählen Sie eins der folgenden Codebeispiele aus, um es zu kopieren und in die Datei „Program.cs“ Ihrer Anwendung zu kopieren:

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie unter Sicherheit von Cognitive Services.

Allgemeines Dokument-Modell

Analysieren und Extrahieren von Text, Tabellen, Strukturen, Schlüssel-Wert-Paaren

Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Verwenden Sie zum Analysieren einer bestimmten Datei unter einem URI die StartAnalyzeDocumentFromUri-Methode, und übergeben Sie prebuilt-document als Modell-ID. Der zurückgegebene Wert ist ein AnalyzeResult-Objekt mit Daten zum übermittelten Dokument.
Wir haben den URI-Wert der Datei in die Variable Uri fileUri am Anfang des Skripts eingefügt.

Fügen Sie das folgende Codebeispiel in die Datei „Program.cs“ ein. Stellen Sie sicher, dass Sie die Schlüssel- und Endpunktvariablen mit Werten aus Ihrer Formularerkennungsinstanz im Azure-Portal aktualisieren:

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentAnalysisClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);


//sample form document
Uri fileUri = new Uri("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed,"prebuilt-document", fileUri);

AnalyzeResult result = operation.Value;

Console.WriteLine("Detected key-value pairs:");

foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
    if (kvp.Value == null)
    {
        Console.WriteLine($"  Found key with no value: '{kvp.Key.Content}'");
    }
    else
    {
        Console.WriteLine($"  Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
    }
}

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingPolygon[0].X}, Y= {line.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingPolygon[1].X}, Y= {line.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingPolygon[2].X}, Y= {line.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingPolygon[3].X}, Y= {line.BoundingPolygon[3].Y}");
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingPolygon[0].X}, Y= {selectionMark.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingPolygon[1].X}, Y= {selectionMark.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingPolygon[2].X}, Y= {selectionMark.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingPolygon[3].X}, Y= {selectionMark.BoundingPolygon[3].Y}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, wählen Sie die grüne Schaltfläche Start neben „formRecognizer_quickstart“ aus, um Ihre Programm zu erstellen und auszuführen, oder drücken Sie F5.

Screenshot: Ausführen Ihres Visual Studio-Programms

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des allgemeinen Dokumentmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  Detected key-value pairs:
  Found key with no value: '?'
  Found key-value pair: 'QUARTERLY REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' and ':selected:'
  Found key-value pair: 'For the Quarterly Period Ended March 31, 2020' and 'OR'
  Found key with no value: '?'
  Found key-value pair: 'TRANSITION REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' and ':unselected:'
  Found key with no value: 'For the Transition Period From'
  Found key-value pair: 'to Commission File Number' and '001-37845'

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des allgemeinen Dokumentmodells anzuzeigen.

Layoutmodell

Extrahieren von Text, Auswahlmarkierungen, Textstilen, Tabellenstrukturen und Koordinaten von Begrenzungsbereichen aus Dokumenten.

Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Wir haben den URI-Wert der Datei in die Variable Uri fileUri am Anfang des Skripts eingefügt.
Verwenden Sie zum Extrahieren des Layouts aus einer bestimmten Datei unter einem URI die StartAnalyzeDocumentFromUri-Methode, und übergeben Sie prebuilt-layout als Modell-ID. Der zurückgegebene Wert ist ein AnalyzeResult-Objekt mit Daten aus dem übermittelten Dokument.

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentAnalysisClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

//sample document
Uri fileUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-layout", fileUri);

AnalyzeResult result = operation.Value;

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingPolygon[0].X}, Y= {line.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingPolygon[1].X}, Y= {line.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingPolygon[2].X}, Y= {line.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingPolygon[3].X}, Y= {line.BoundingPolygon[3].Y}");
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingPolygon[0].X}, Y= {selectionMark.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingPolygon[1].X}, Y= {selectionMark.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingPolygon[2].X}, Y= {selectionMark.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingPolygon[3].X}, Y= {selectionMark.BoundingPolygon[3].Y}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

Ausführen der Anwendung

Screenshot: Ausführen Ihres Visual Studio-Programms

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des Layoutmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  Document Page 1 has 69 line(s), 425 word(s), and 15 selection mark(s).
  Line 0 has content: 'UNITED STATES'.
    Its bounding box is:
      Upper left => X: 3.4915, Y= 0.6828
      Upper right => X: 5.0116, Y= 0.6828
      Lower right => X: 5.0116, Y= 0.8265
      Lower left => X: 3.4915, Y= 0.8265
  Line 1 has content: 'SECURITIES AND EXCHANGE COMMISSION'.
    Its bounding box is:
      Upper left => X: 2.1937, Y= 0.9061
      Upper right => X: 6.297, Y= 0.9061
      Lower right => X: 6.297, Y= 1.0498
      Lower left => X: 2.1937, Y= 1.0498

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Layoutmodells anzuzeigen.

Vordefiniertes Modell

Analysieren und Extrahieren von gemeinsamen Feldern aus bestimmten Dokumenttypen mithilfe eines vordefinierten Modells. In diesem Beispiel analysieren Sie eine Rechnung mithilfe des vordefinierten Rechnungsmodells (prebuilt-invoice).

Tipp

Sie sind hierbei nicht auf Rechnungen beschränkt, sondern können zwischen mehreren vordefinierten Modellen wählen, von denen jedes über eine Gruppe unterstützter Felder verfügt. Welches Modell für den Analysevorgang verwendet wird, hängt vom Typ des zu analysierenden Dokuments ab. Weitere Informationen finden Sie unter Extrahieren von Modelldaten.

Analysieren einer Rechnung mithilfe des vordefinierten Rechnungsmodells (prebuilt-invoice). Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Wir haben den Datei-URI-Wert zur Variable Uri invoiceUri am Anfang der Datei Program.cs hinzugefügt.
Verwenden Sie zum Analysieren einer bestimmten Datei unter einem URI die StartAnalyzeDocumentFromUri-Methode, und übergeben Sie prebuilt-invoice als Modell-ID. Der zurückgegebene Wert ist ein AnalyzeResult-Objekt mit Daten aus dem übermittelten Dokument.
Der Einfachheit halber werden hier nicht alle Schlüssel-Wert-Paare angezeigt, die der Dienst zurückgibt. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.

Fügen Sie das folgende Codebeispiel in Ihre Datei „Program.cs“ ein. Stellen Sie sicher, dass Sie die Schlüssel- und Endpunktvariablen mit Werten aus Ihrer Formularerkennungsinstanz im Azure-Portal aktualisieren:



using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentAnalysisClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

//sample invoice document

Uri invoiceUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);

AnalyzeResult result = operation.Value;

for (int i = 0; i < result.Documents.Count; i++)
{
    Console.WriteLine($"Document {i}:");

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
    {
        if (vendorNameField.FieldType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.Value.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("CustomerName", out DocumentField customerNameField))
    {
        if (customerNameField.FieldType == DocumentFieldType.String)
        {
            string customerName = customerNameField.Value.AsString();
            Console.WriteLine($"Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField))
    {
        if (itemsField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField itemField in itemsField.Value.AsList())
            {
                Console.WriteLine("Item:");

                if (itemField.FieldType == DocumentFieldType.Dictionary)
                {
                    IReadOnlyDictionary<string, DocumentField> itemFields = itemField.Value.AsDictionary();

                    if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField))
                    {
                        if (itemDescriptionField.FieldType == DocumentFieldType.String)
                        {
                            string itemDescription = itemDescriptionField.Value.AsString();

                            Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                        }
                    }

                    if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
                    {
                        if (itemAmountField.FieldType == DocumentFieldType.Currency)
                        {
                            CurrencyValue itemAmount = itemAmountField.Value.AsCurrency();

                            Console.WriteLine($"  Amount: '{itemAmount.Symbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                        }
                    }
                }
            }
        }
    }

    if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField))
    {
        if (subTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue subTotal = subTotalField.Value.AsCurrency();
            Console.WriteLine($"Sub Total: '{subTotal.Symbol}{subTotal.Amount}', with confidence {subTotalField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField))
    {
        if (totalTaxField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue totalTax = totalTaxField.Value.AsCurrency();
            Console.WriteLine($"Total Tax: '{totalTax.Symbol}{totalTax.Amount}', with confidence {totalTaxField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField))
    {
        if (invoiceTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue invoiceTotal = invoiceTotalField.Value.AsCurrency();
            Console.WriteLine($"Invoice Total: '{invoiceTotal.Symbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
        }
    }
}

Ausführen der Anwendung

Screenshot: Ausführen Ihres Visual Studio-Programms

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des vordefinierten Modells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  Document 0:
  Vendor Name: 'CONTOSO LTD.', with confidence 0.962
  Customer Name: 'MICROSOFT CORPORATION', with confidence 0.951
  Item:
    Description: 'Test for 23 fields', with confidence 0.899
    Amount: '100', with confidence 0.902
  Sub Total: '100', with confidence 0.979

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des vordefinierten Rechnungsmodells anzuzeigen.

SDK-Referenz | API-Referenz | Paket (Maven) | Beispiele| Unterstützte REST-API-Versionen

In dieser Schnellstartanleitung verwenden Sie die folgenden Features, um Daten und Werte aus Formularen und Dokumenten zu analysieren und zu extrahieren:

Allgemeines Dokument: Analysieren und Extrahieren von Text, Tabellen, Strukturen, Schlüssel-Wert-Paaren
Layout – Analysieren und Extrahieren von Tabellen, Zeilen, Wörtern und Auswahlmarkierungen, z. B. Optionsfelder und Kontrollkästchen in Dokumenten, ohne ein Modell trainieren zu müssen.
Vorgefertigte Rechnung – Analysieren und Extrahieren gemeinsamer Felder aus bestimmten Dokumenttypen mithilfe eines vorab trainierten Modells.

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Die aktuelle Version von Visual Studio Code oder Ihrer bevorzugten IDE Verwenden in Visual Studio Code.
Tipp
- Visual Studio Code bietet ein Coding Pack für Java für Windows und macOS. Das Coding Pack ist ein Paket aus VS Code, dem Java Development Kit (JDK) und einer Sammlung vorgeschlagener Erweiterungen von Microsoft. Das Coding Pack kann auch verwendet werden, um eine vorhandene Entwicklungsumgebung zu korrigieren.
- Wenn Sie VS Code Code Pack für Java verwenden, installieren Sie die Erweiterung Gradle für Java.
Wenn Sie nicht Visual Studio Code verwenden, stellen Sie sicher, dass Folgendes in Ihrer Entwicklungsumgebung installiert ist:
- Java Development Kit (JDK), Version 8 oder höher. Weitere Informationen finden Sie unterMicrosoft Build of OpenJDK.
- Az Version 6.8 oder höher.
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Zu einem späteren Zeitpunkt fügen Sie Ihren Schlüssel und den Endpunkt in den Code ein:

Es ist ein Problem mit den Voraussetzungen aufgetreten.

Einrichten

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App mit dem Namen form-recognizer-app, und navigieren Sie zu diesem Verzeichnis.
```
mkdir form-recognizer-app && form-recognizer-app
```
```
mkdir translator-text-app; cd translator-text-app
```
Führen Sie den Befehl gradle init in Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle erstellt, u. a. die Datei build.gradle.kts. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.
```
gradle init --type basic
```
Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.
Akzeptieren Sie den Standardprojektnamen (form-recognizer-app) durch Betätigen der RETURN- oder EINGABETASTE.

Beim Setup ist ein Problem aufgetreten.

Installieren der Clientbibliothek

In dieser Schnellstartanleitung wird der Gradle-Abhängigkeits-Manager verwendet. Die Clientbibliothek und Informationen zu anderen Abhängigkeits-Managern finden Sie im zentralen Maven-Repository.

Öffnen Sie die Datei build.gradle.kts des Projekts in Ihrer IDE. Fügen Sie in die Datei implementationbuild.gradle.kts Ihres Projekts die Clientbibliothek als -Anweisung sowie die erforderlichen Plug-Ins und Einstellungen ein.

plugins {
    java
    application
}
application {
    mainClass.set("FormRecognizer")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-formrecognizer", version = "4.0.0")
}

Bei der Installation der Clientbibliothek ist ein Problem aufgetreten.

Erstellen einer Java-Anwendung

Führen Sie im Verzeichnis form-recognizer-app den folgenden Befehl aus:
```
mkdir -p src/main/java
```
Sie erstellen die folgende Verzeichnisstruktur:
Navigieren Sie zum java-Verzeichnis, und erstellen Sie eine Datei namens FormRecognizer.java.
Tipp
- Sie können eine neue Datei mithilfe von PowerShell erstellen.
- Öffnen Sie ein PowerShell-Fenster in Ihrem Projektverzeichnis, indem Sie die UMSCHALTTASTE gedrückt halten und mit der rechten Maustaste auf den Ordner klicken.
- Geben Sie in Ihrem Terminal den folgenden Befehl ein:
Öffnen Sie die Datei FormRecognizer.java, und wählen Sie eins der folgenden Codebeispiele aus, um es zu kopieren und in Ihre Anwendung einzufügen:

Wichtig

Allgemeines Dokument-Modell

Extrahieren von Text, Tabellen, Strukturen und Schlüssel-Wert-Paaren aus Dokumenten

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Um eine bestimmte Datei an einem URI zu analysieren, verwenden Sie die beginAnalyzeDocumentFromUrl-Methode und übergeben prebuilt-document als Modell-ID. Der Rückgabewert ist ein AnalyzeResult-Objekt, das Daten zum übermittelten Dokument enthält.
Wir haben den Datei-URI-Wert der Variablen documentUrl in der main-Methode hinzugefügt.

Fügen Sie der Datei FormRecognizer.java das folgende Codebeispiel hinzu. Stellen Sie sicher, dass Sie die Schlüssel- und Endpunktvariablen mit Werten aus Ihrer Formularerkennungsinstanz im Azure-Portal aktualisieren.


import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(String[] args) {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String documentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
    String modelId = "prebuilt-document";
    SyncPoller < OperationResult, AnalyzeResult > analyzeDocumentPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

    // pages
    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 polygon %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 pairs
    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());

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

Erstellen und Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, navigieren Sie zurück zu Ihrem Hauptprojektverzeichnis: form-recognizer-app.

Erstellen Sie Ihre Anwendung mit dem Befehl build:
```
gradle build
```
Führen Sie Ihre Anwendung mit dem Befehl run aus:
```
gradle run
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des allgemeinen Dokumentmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Key content: For the Transition Period From
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@14c053c6]
Key content: to Commission File Number
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@6c2d4cc6]
Value content: 001-37845
Value content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@30865a90]
Key content: (I.R.S. ID)
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@6134ac4a]
Value content: 91-1144442
Value content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@777c9dc9]
Key content: Securities registered pursuant to Section 12(g) of the Act:
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@71b1a49c]
Value content: NONE

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des allgemeinen Dokumentmodells anzuzeigen.

Layoutmodell

Extrahieren von Text, Auswahlmarkierungen, Textstilen, Tabellenstrukturen und Koordinaten von Begrenzungsbereichen aus Dokumenten.

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Um eine bestimmte Datei an einem URI zu analysieren, verwenden Sie die beginAnalyzeDocumentFromUrl-Methode und übergeben prebuilt-layout als Modell-ID. Der Rückgabewert ist ein AnalyzeResult-Objekt, das Daten zum übermittelten Dokument enthält.
Wir haben den Datei-URI-Wert der Variablen documentUrl in der main-Methode hinzugefügt.


import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(String[] args) {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String documentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
    String modelId = "prebuilt-layout";

    SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    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 polygon %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()));

      // selection marks
      documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is %s and is within a bounding polygon %s with confidence %.2f.%n",
          documentSelectionMark.getState().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();
    }
  }
  // Utility function to get the bounding polygon coordinates
  private static String getBoundingCoordinates(List < Point > boundingPolygon) {
    return boundingPolygon.stream().map(point -> String.format("[%.2f, %.2f]", point.getX(),
      point.getY())).collect(Collectors.joining(", "));
  }
}

Erstellen und Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, navigieren Sie zurück zu Ihrem Hauptprojektverzeichnis: form-recognizer-app.

Erstellen Sie Ihre Anwendung mit dem Befehl build:
```
gradle build
```
Führen Sie Ihre Anwendung mit dem Befehl run aus:
```
gradle run
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des Layoutmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  Table 0 has 5 rows and 3 columns.
  Cell 'Title of each class', has row index 0 and column index 0.
  Cell 'Trading Symbol', has row index 0 and column index 1.
  Cell 'Name of exchange on which registered', has row index 0 and column index 2.
  Cell 'Common stock, $0.00000625 par value per share', has row index 1 and column index 0.
  Cell 'MSFT', has row index 1 and column index 1.
  Cell 'NASDAQ', has row index 1 and column index 2.
  Cell '2.125% Notes due 2021', has row index 2 and column index 0.
  Cell 'MSFT', has row index 2 and column index 1.
  Cell 'NASDAQ', has row index 2 and column index 2.
  Cell '3.125% Notes due 2028', has row index 3 and column index 0.
  Cell 'MSFT', has row index 3 and column index 1.
  Cell 'NASDAQ', has row index 3 and column index 2.
  Cell '2.625% Notes due 2033', has row index 4 and column index 0.
  Cell 'MSFT', has row index 4 and column index 1.
  Cell 'NASDAQ', has row index 4 and column index 2.

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Layoutmodells anzuzeigen.

Vordefiniertes Modell

Tipp

Analysieren einer Rechnung mithilfe des vordefinierten Rechnungsmodells (prebuilt-invoice). Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Der Wert der Datei-URL wurde der Variable invoiceUrl oben in der Datei hinzugefügt.
Um eine bestimmte Datei an einem URI zu analysieren, verwenden Sie die beginAnalyzeDocuments-Methode und übergeben PrebuiltModels.Invoice als Modell-ID. Der Rückgabewert ist ein result-Objekt, das Daten zum übermittelten Dokument enthält.
Der Einfachheit halber werden hier nicht alle Schlüssel-Wert-Paare angezeigt, die der Dienst zurückgibt. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.


import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(final String[] args) throws IOException {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String modelId = "prebuilt-invoice";
    String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

    SyncPoller < OperationResult, AnalyzeResult > analyzeInvoicePoller = client.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);

    AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.getFinalResult();

    for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
      AnalyzedDocument analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
      Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
      System.out.printf("----------- Analyzing invoice  %d -----------%n", i);
      DocumentField vendorNameField = invoiceFields.get("VendorName");
      if (vendorNameField != null) {
        if (DocumentFieldType.STRING == vendorNameField.getType()) {
          String merchantName = vendorNameField.getValueAsString();
          System.out.printf("Vendor Name: %s, confidence: %.2f%n",
            merchantName, vendorNameField.getConfidence());
        }
      }

      DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
      if (vendorAddressField != null) {
        if (DocumentFieldType.STRING == vendorAddressField.getType()) {
          String merchantAddress = vendorAddressField.getValueAsString();
          System.out.printf("Vendor address: %s, confidence: %.2f%n",
            merchantAddress, vendorAddressField.getConfidence());
        }
      }

      DocumentField customerNameField = invoiceFields.get("CustomerName");
      if (customerNameField != null) {
        if (DocumentFieldType.STRING == customerNameField.getType()) {
          String merchantAddress = customerNameField.getValueAsString();
          System.out.printf("Customer Name: %s, confidence: %.2f%n",
            merchantAddress, customerNameField.getConfidence());
        }
      }

      DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
          String customerAddr = customerAddressRecipientField.getValueAsString();
          System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
            customerAddr, customerAddressRecipientField.getConfidence());
        }
      }

      DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
      if (invoiceIdField != null) {
        if (DocumentFieldType.STRING == invoiceIdField.getType()) {
          String invoiceId = invoiceIdField.getValueAsString();
          System.out.printf("Invoice ID: %s, confidence: %.2f%n",
            invoiceId, invoiceIdField.getConfidence());
        }
      }

      DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
      if (customerNameField != null) {
        if (DocumentFieldType.DATE == invoiceDateField.getType()) {
          LocalDate invoiceDate = invoiceDateField.getValueAsDate();
          System.out.printf("Invoice Date: %s, confidence: %.2f%n",
            invoiceDate, invoiceDateField.getConfidence());
        }
      }

      DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
          Double invoiceTotal = invoiceTotalField.getValueAsDouble();
          System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
            invoiceTotal, invoiceTotalField.getConfidence());
        }
      }

      DocumentField invoiceItemsField = invoiceFields.get("Items");
      if (invoiceItemsField != null) {
        System.out.printf("Invoice Items: %n");
        if (DocumentFieldType.LIST == invoiceItemsField.getType()) {
          List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
          invoiceItems.stream()
            .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
            .map(documentField -> documentField.getValueAsMap())
            .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
              // See a full list of fields found on an invoice here:
              // https://aka.ms/formrecognizer/invoicefields
              if ("Description".equals(key)) {
                if (DocumentFieldType.STRING == documentField.getType()) {
                  String name = documentField.getValueAsString();
                  System.out.printf("Description: %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());
                }
              }
              if ("UnitPrice".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double unitPrice = documentField.getValueAsDouble();
                  System.out.printf("Unit Price: %f, confidence: %.2f%n",
                    unitPrice, documentField.getConfidence());
                }
              }
              if ("ProductCode".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double productCode = documentField.getValueAsDouble();
                  System.out.printf("Product Code: %f, confidence: %.2f%n",
                    productCode, documentField.getConfidence());
                }
              }
            }));
        }
      }
    }
  }
}

Erstellen und Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, navigieren Sie zurück zu Ihrem Hauptprojektverzeichnis: form-recognizer-app.

Erstellen Sie Ihre Anwendung mit dem Befehl build:
```
gradle build
```
Führen Sie Ihre Anwendung mit dem Befehl run aus:
```
gradle run
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des vordefinierten Modells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  ----------- Analyzing invoice  0 -----------
  Analyzed document has doc type invoice with confidence : 1.00
  Vendor Name: CONTOSO LTD., confidence: 0.92
  Vendor address: 123 456th St New York, NY, 10001, confidence: 0.91
  Customer Name: MICROSOFT CORPORATION, confidence: 0.84
  Customer Address Recipient: Microsoft Corp, confidence: 0.92
  Invoice ID: INV-100, confidence: 0.97
  Invoice Date: 2019-11-15, confidence: 0.97

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des vordefinierten Rechnungsmodells anzuzeigen.

SDK-Referenz | API-Referenz | Paket (npm) | Beispiele |Unterstützte REST-API-Versionen

In dieser Schnellstartanleitung verwenden Sie die folgenden Features, um Daten und Werte aus Formularen und Dokumenten zu analysieren und zu extrahieren:

Allgemeines Dokument: Analysieren und Extrahieren von Schlüssel-Wert-Paaren und Auswahlmarkierungen aus Dokumenten
Layout: Analysieren und Extrahieren von Tabellen, Zeilen, Wörtern und Auswahlmarkierungen, z. B. Optionsfelder und Kontrollkästchen in Dokumenten, ohne ein Modell trainieren zu müssen.
Vorgefertigte Rechnung – Analysieren und Extrahieren gemeinsamer Felder aus bestimmten Dokumenttypen mithilfe eines vortrainierten Rechnungsmodells.

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Die aktuelle Version von Visual Studio Code oder Ihrer bevorzugten IDE Weitere Informationen finden Sie in der Visual Studio Code-Dokumentation.
Die aktuelle LTS-Version von Node.js
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Es ist ein Problem mit den Voraussetzungen aufgetreten.

Einrichten

Erstellen einer neuen Node.js Express-Anwendung: Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App namens form-recognizer-app, und wechseln Sie in dieses Verzeichnis.
```
mkdir form-recognizer-app && cd form-recognizer-app
```
Führen Sie den npm init Befehl aus, um die Anwendung zu initialisieren und ihr Projekt zu gerüsten.
```
npm init
```
Geben Sie die Attribute Ihres Projekts an, indem Sie die im Terminal angezeigten Eingabeaufforderungen verwenden.
- Die wichtigsten Attribute sind Name, Versionsnummer und Einstiegspunkt.
- Es wird empfohlen, index.js den Namen des Einstiegspunkts zu behalten. Beschreibung, Testbefehl, GitHub-Repository, Schlüsselwörter, Autor und Lizenzinformationen sind optionale Attribute, die Sie für dieses Projekt überspringen können.
- Akzeptieren Sie die Vorschläge in Klammern, indem Sie Zurückgeben oder eingebenauswählen.
- Nachdem Sie die Eingabeaufforderungen abgeschlossen haben, package.json wird in Ihrem Formularerkennungs-app-Verzeichnis eine Datei erstellt.
Installieren Sie das npm-Paket der Clientbibliothek ai-form-recognizer:azure/identity
```
npm i @azure/ai-form-recognizer @azure/identity
```
- Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert.
Erstellen Sie eine Datei index.jsmit der Bezeichnung Web.config im Anwendungsverzeichnis.
Tipp
- Sie können eine neue Datei mithilfe von PowerShell erstellen.
- Öffnen Sie ein PowerShell-Fenster in Ihrem Projektverzeichnis, indem Sie die UMSCHALTTASTE gedrückt halten und mit der rechten Maustaste auf den Ordner klicken.
- Geben Sie in Ihrem Terminal den folgenden Befehl ein:

Beim Setup ist ein Problem aufgetreten.

Erstellen Ihrer Anwendung

Öffnen Sie die Datei index.js in Visual Studio Code oder Ihrer bevorzugten IDE, und wählen Sie eins der folgenden Codebeispiele aus, um es zu kopieren und in Ihre Anwendung einzufügen:

Wichtig

Allgemeines Dokument-Modell

Extrahieren von Text, Tabellen, Strukturen und Schlüssel-Wert-Paaren aus Dokumenten

Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einer URL. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Verwenden Sie zum Analysieren einer bestimmten Datei unter einem URI die beginAnalyzeDocuments-Methode, und übergeben Sie prebuilt-document als Modell-ID.
Sie haben den Datei-URI-Wert der Variable formUrl im oberen Bereich der Datei hinzugefügt.

Fügen Sie der Datei index.js das folgende Codebeispiel hinzu. Stellen Sie sicher, dass Sie die Schlüssel- und Endpunktvariablen mit Werten aus Ihrer Formularerkennungsinstanz im Azure-Portal aktualisieren:


  const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

  // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
  const key = "<your-key>";
  const endpoint = "<your-endpoint>";

  // sample document
  const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

  async function main() {
    const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-document", formUrl);

    const {keyValuePairs} = await poller.pollUntilDone();

    if (!keyValuePairs || keyValuePairs.length <= 0) {
        console.log("No key-value pairs were extracted from the document.");
    } else {
        console.log("Key-Value Pairs:");
        for (const {key, value, confidence} of keyValuePairs) {
            console.log("- Key  :", `"${key.content}"`);
            console.log("  Value:", `"${(value && value.content) || "<undefined>"}" (${confidence})`);
        }
    }

}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, führen Sie Ihr Programm aus:

Navigieren Sie zu dem Ordner, in dem Ihre Formularerkennungsanwendung (form-recognizer-app) installiert ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:
```
node index.js
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des allgemeinen Dokumentmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Key-Value Pairs:
- Key  : "For the Quarterly Period Ended"
  Value: "March 31, 2020" (0.35)
- Key  : "From"
  Value: "1934" (0.119)
- Key  : "to"
  Value: "<undefined>" (0.317)
- Key  : "Commission File Number"
  Value: "001-37845" (0.87)
- Key  : "(I.R.S. ID)"
  Value: "91-1144442" (0.87)
- Key  : "Class"
  Value: "Common Stock, $0.00000625 par value per share" (0.748)
- Key  : "Outstanding as of April 24, 2020"
  Value: "7,583,440,247 shares" (0.838)

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des allgemeinen Dokumentmodells anzuzeigen.

Layoutmodell

Extrahieren von Text, Auswahlmarkierungen, Textstilen, Tabellenstrukturen und Koordinaten von Begrenzungsbereichen aus Dokumenten.

Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einer URL. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Sie haben den Datei-URI-Wert der Variable formUrl im oberen Bereich der Datei hinzugefügt.
Verwenden Sie zum Analysieren einer bestimmten Datei unter einem URI die beginAnalyzeDocuments-Methode, und übergeben Sie prebuilt-layout als Modell-ID.


 const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

    // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
    const key = "<your-key>";
    const endpoint = "<your-endpoint>";

    // sample document
  const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

  async function main() {
    const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-layout", formUrl);

    const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, führen Sie Ihr Programm aus:

Navigieren Sie zu dem Ordner, in dem Ihre Formularerkennungsanwendung (form-recognizer-app) installiert ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:
```
node index.js
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des Layoutmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Pages:
- Page 1 (unit: inch)
  8.5x11, angle: 0
  69 lines, 425 words
Tables:
- Extracted table: 3 columns, 5 rows (15 cells)

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Layoutmodells anzuzeigen.

Vordefiniertes Modell

In diesem Beispiel analysieren Sie eine Rechnung mithilfe des vordefinierten Rechnungsmodells (prebuilt-invoice).

Tipp

Analysieren einer Rechnung mithilfe des vordefinierten Rechnungsmodells (prebuilt-invoice). Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Der Wert der Datei-URL wurde der Variable invoiceUrl oben in der Datei hinzugefügt.
Um eine bestimmte Datei an einem URI zu analysieren, verwenden Sie die beginAnalyzeDocuments-Methode und übergeben PrebuiltModels.Invoice als Modell-ID. Der Rückgabewert ist ein result-Objekt, das Daten zum übermittelten Dokument enthält.
Der Einfachheit halber werden hier nicht alle Schlüssel-Wert-Paare angezeigt, die der Dienst zurückgibt. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.


 const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

  // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
      const key = "<your-key>";
      const endpoint = "<your-endpoint>";
// sample document
    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

async function main() {
    const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-invoice", invoiceUrl);

    const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, führen Sie Ihr Programm aus:

Navigieren Sie zu dem Ordner, in dem Ihre Formularerkennungsanwendung (form-recognizer-app) installiert ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:
```
node index.js
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des vordefinierten Modells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  Vendor Name: CONTOSO LTD.
  Customer Name: MICROSOFT CORPORATION
  Invoice Date: 2019-11-15T00:00:00.000Z
  Due Date: 2019-12-15T00:00:00.000Z
  Items:
  - <no product code>
    Description: Test for 23 fields
    Quantity: 1
    Date: undefined
    Unit: undefined
    Unit Price: 1
    Tax: undefined
    Amount: 100

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des vordefinierten Rechnungsmodells anzuzeigen.

SDK-Referenz | API-Referenz | Paket (PyPi) | Beispiele | Unterstützte REST-API-Versionen

In dieser Schnellstartanleitung verwenden Sie die folgenden Features, um Daten und Werte aus Formularen und Dokumenten zu analysieren und zu extrahieren:

Allgemeines Dokument: Analysieren und Extrahieren von Text, Tabellen, Strukturen und Schlüssel-Wert-Paaren
Layout – Analysieren und Extrahieren von Tabellen, Zeilen, Wörtern und Auswahlmarkierungen, z. B. Optionsfelder und Kontrollkästchen in Dokumenten, ohne ein Modell trainieren zu müssen.
Vorgefertigte Rechnung – Analysieren und Extrahieren gemeinsamer Felder aus bestimmten Dokumenttypen mithilfe eines vorab trainierten Modells.

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Python 3.7 oder höher
- Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version in der Befehlszeile ausführen. Installieren Sie die aktuelle Python-Version, um pip zu erhalten.
Die aktuelle Version von Visual Studio Code oder Ihrer bevorzugten IDE Weitere Informationen finden Sie unterErste Schritte mit Python in Visual Studio Code.
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Es ist ein Problem mit den Voraussetzungen aufgetreten.

Einrichten

Öffnen Sie in Ihrer lokalen Umgebung ein Terminalfenster, und installieren Sie die Azure-Formularerkennung-Clientbibliothek für Python mit pip:

pip install azure-ai-formrecognizer==3.2.0

Beim Setup ist ein Problem aufgetreten.

Erstellen Ihrer Python-Anwendung

Erstellen Sie eine neue Python-Datei namens form_recognizer_quickstart.py in Ihrem bevorzugten Editor oder IDE.
Öffnen Sie die Datei form_recognizer_quickstart.py, und wählen Sie eins der folgenden Codebeispiele aus, um es zu kopieren und in Ihre Anwendung einzufügen:

Wichtig

Allgemeines Dokument-Modell

Extrahieren von Text, Tabellen, Strukturen und Schlüssel-Wert-Paaren aus Dokumenten

Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einer URL. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Um eine bestimmte Datei unter einer URL zu analysieren, verwenden Sie die Methode begin_analyze_document_from_url und geben prebuilt-document als Modell-ID an. Der Rückgabewert ist ein result Objekt, das Daten über das übermittelte Dokument enthält.
Wir haben den Wert der Datei-URL zur Variable docUrl in der Funktion analyze_general_documents hinzugefügt.

Fügen Sie Ihrer Anwendung „form_recognizer_quickstart.py“ das folgende Codebeispiel hinzu. Stellen Sie sicher, dass Sie die Schlüssel- und Endpunktvariablen mit Werten aus Ihrer Formularerkennungsinstanz im Azure-Portal aktualisieren.


# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"

def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join("Page #{}: {}".format(region.page_number, format_polygon(region.polygon)) for region in bounding_regions)

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


def analyze_general_documents():
    # sample document
    docUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

    # create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    document_analysis_client = DocumentAnalysisClient(endpoint=endpoint, credential=AzureKeyCredential(key))

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-document", docUrl)
    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,
                        format_bounding_region(kv_pair.key.bounding_regions),
                    )
                )
        if kv_pair.value:
            print(
                    "Value '{}' found within '{}' bounding regions\n".format(
                        kv_pair.value.content,
                        format_bounding_region(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):
            print(
                "...Line # {} has text content '{}' within bounding box '{}'".format(
                    line_idx,
                    line.content,
                    format_polygon(line.polygon),
                )
            )

        for word in page.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 box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(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,
                    format_polygon(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 box '{}'\n".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )
    print("----------------------------------------")


if __name__ == "__main__":
    analyze_general_documents()

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, erstellen Sie Ihr Programm und führen es aus:

Navigieren Sie zu dem Ordner, in dem Ihre Datei form_recognizer_quickstart.py enthalten ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:
```
python form_recognizer_quickstart.py
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des allgemeinen Dokumentmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  ----Key-value pairs found in document----
  Key '☒' found within 'Page #1: [0.6694, 1.7746], [0.7764, 1.7746], [0.7764, 1.8833], [0.6694, 1.8833]' bounding regions
  Key 'QUARTERLY REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' found within 'Page #1: [0.996, 1.7804], [7.8449, 1.7804], [7.8449, 2.0559], [0.996, 2.0559]' bounding regions
  Value ':selected:' found within 'Page #1: [0.6694, 1.7746], [0.7764, 1.7746], [0.7764, 1.8833], [0.6694, 1.8833]' bounding regions

  Key 'For the Quarterly Period Ended March 31, 2020' found within 'Page #1: [0.9982, 2.1626], [3.4543, 2.1626], [3.4543, 2.2665], [0.9982, 2.2665]' bounding regions
  Value 'OR' found within 'Page #1: [4.1471, 2.2972], [4.3587, 2.2972], [4.3587, 2.4049], [4.1471, 2.4049]' bounding regions

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des allgemeinen Dokumentmodells anzuzeigen.

Layoutmodell

Extrahieren von Text, Auswahlmarkierungen, Textstilen, Tabellenstrukturen und Koordinaten von Begrenzungsbereichen aus Dokumenten.

Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einer URL. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Wir haben den Wert der Datei-URL zur Variable formUrl in der Funktion analyze_layout hinzugefügt.
Um eine bestimmte Datei unter einer URL zu analysieren, verwenden Sie die Methode begin_analyze_document_from_url und geben prebuilt-layout als Modell-ID an. Der Rückgabewert ist ein result Objekt, das Daten über das übermittelte Dokument enthält.


# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])

def analyze_layout():
    # sample form document
    formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-layout", formUrl)
    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 box '{}'".format(
                    line_idx,
                    len(words),
                    line.content,
                    format_polygon(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 box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(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,
                    format_polygon(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 box '{}'".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )

    print("----------------------------------------")


if __name__ == "__main__":
    analyze_layout()

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, erstellen Sie Ihr Programm und führen es aus:

Navigieren Sie zu dem Ordner, in dem Ihre Datei form_recognizer_quickstart.py enthalten ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:
```
python form_recognizer_quickstart.py
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des Layoutmodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  ----Analyzing layout from page #1----
  Page has width: 8.5 and height: 11.0, measured with unit: inch
  ...Line # 0 has word count 2 and text 'UNITED STATES' within bounding box '[3.4915, 0.6828], [5.0116, 0.6828], [5.0116, 0.8265], [3.4915, 0.8265]'
  ......Word 'UNITED' has a confidence of 1.0
  ......Word 'STATES' has a confidence of 1.0
  ...Line # 1 has word count 4 and text 'SECURITIES AND EXCHANGE COMMISSION' within bounding box '[2.1937, 0.9061], [6.297, 0.9061], [6.297, 1.0498], [2.1937, 1.0498]'
  ......Word 'SECURITIES' has a confidence of 1.0
  ......Word 'AND' has a confidence of 1.0
  ......Word 'EXCHANGE' has a confidence of 1.0
  ......Word 'COMMISSION' has a confidence of 1.0
  ...Line # 2 has word count 3 and text 'Washington, D.C. 20549' within bounding box '[3.4629, 1.1179], [5.031, 1.1179], [5.031, 1.2483], [3.4629, 1.2483]'
  ......Word 'Washington,' has a confidence of 1.0
  ......Word 'D.C.' has a confidence of 1.0

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Layoutmodells anzuzeigen.

Vordefiniertes Modell

Tipp

Analysieren einer Rechnung mithilfe des vordefinierten Rechnungsmodells (prebuilt-invoice). Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Der Wert der Datei-URL wurde der Variable invoiceUrl oben in der Datei hinzugefügt.
Um eine bestimmte Datei an einem URI zu analysieren, verwenden Sie die begin_analyze_document_from_url-Methode und übergeben prebuilt-invoice als Modell-ID. Der Rückgabewert ist ein result-Objekt, das Daten zum übermittelten Dokument enthält.
Der Einfachheit halber werden hier nicht alle Schlüssel-Wert-Paare angezeigt, die der Dienst zurückgibt. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.

# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"

def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join("Page #{}: {}".format(region.page_number, format_polygon(region.polygon)) for region in bounding_regions)

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


def analyze_invoice():

    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-invoice", invoiceUrl)
    invoices = poller.result()

    for idx, invoice in enumerate(invoices.documents):
        print("--------Recognizing invoice #{}--------".format(idx + 1))
        vendor_name = invoice.fields.get("VendorName")
        if vendor_name:
            print(
                "Vendor Name: {} has confidence: {}".format(
                    vendor_name.value, vendor_name.confidence
                )
            )
        vendor_address = invoice.fields.get("VendorAddress")
        if vendor_address:
            print(
                "Vendor Address: {} has confidence: {}".format(
                    vendor_address.value, vendor_address.confidence
                )
            )
        vendor_address_recipient = invoice.fields.get("VendorAddressRecipient")
        if vendor_address_recipient:
            print(
                "Vendor Address Recipient: {} has confidence: {}".format(
                    vendor_address_recipient.value, vendor_address_recipient.confidence
                )
            )
        customer_name = invoice.fields.get("CustomerName")
        if customer_name:
            print(
                "Customer Name: {} has confidence: {}".format(
                    customer_name.value, customer_name.confidence
                )
            )
        customer_id = invoice.fields.get("CustomerId")
        if customer_id:
            print(
                "Customer Id: {} has confidence: {}".format(
                    customer_id.value, customer_id.confidence
                )
            )
        customer_address = invoice.fields.get("CustomerAddress")
        if customer_address:
            print(
                "Customer Address: {} has confidence: {}".format(
                    customer_address.value, customer_address.confidence
                )
            )
        customer_address_recipient = invoice.fields.get("CustomerAddressRecipient")
        if customer_address_recipient:
            print(
                "Customer Address Recipient: {} has confidence: {}".format(
                    customer_address_recipient.value,
                    customer_address_recipient.confidence,
                )
            )
        invoice_id = invoice.fields.get("InvoiceId")
        if invoice_id:
            print(
                "Invoice Id: {} has confidence: {}".format(
                    invoice_id.value, invoice_id.confidence
                )
            )
        invoice_date = invoice.fields.get("InvoiceDate")
        if invoice_date:
            print(
                "Invoice Date: {} has confidence: {}".format(
                    invoice_date.value, invoice_date.confidence
                )
            )
        invoice_total = invoice.fields.get("InvoiceTotal")
        if invoice_total:
            print(
                "Invoice Total: {} has confidence: {}".format(
                    invoice_total.value, invoice_total.confidence
                )
            )
        due_date = invoice.fields.get("DueDate")
        if due_date:
            print(
                "Due Date: {} has confidence: {}".format(
                    due_date.value, due_date.confidence
                )
            )
        purchase_order = invoice.fields.get("PurchaseOrder")
        if purchase_order:
            print(
                "Purchase Order: {} has confidence: {}".format(
                    purchase_order.value, purchase_order.confidence
                )
            )
        billing_address = invoice.fields.get("BillingAddress")
        if billing_address:
            print(
                "Billing Address: {} has confidence: {}".format(
                    billing_address.value, billing_address.confidence
                )
            )
        billing_address_recipient = invoice.fields.get("BillingAddressRecipient")
        if billing_address_recipient:
            print(
                "Billing Address Recipient: {} has confidence: {}".format(
                    billing_address_recipient.value,
                    billing_address_recipient.confidence,
                )
            )
        shipping_address = invoice.fields.get("ShippingAddress")
        if shipping_address:
            print(
                "Shipping Address: {} has confidence: {}".format(
                    shipping_address.value, shipping_address.confidence
                )
            )
        shipping_address_recipient = invoice.fields.get("ShippingAddressRecipient")
        if shipping_address_recipient:
            print(
                "Shipping Address Recipient: {} has confidence: {}".format(
                    shipping_address_recipient.value,
                    shipping_address_recipient.confidence,
                )
            )
        print("Invoice items:")
        for idx, item in enumerate(invoice.fields.get("Items").value):
            print("...Item #{}".format(idx + 1))
            item_description = item.value.get("Description")
            if item_description:
                print(
                    "......Description: {} has confidence: {}".format(
                        item_description.value, item_description.confidence
                    )
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    "......Quantity: {} has confidence: {}".format(
                        item_quantity.value, item_quantity.confidence
                    )
                )
            unit = item.value.get("Unit")
            if unit:
                print(
                    "......Unit: {} has confidence: {}".format(
                        unit.value, unit.confidence
                    )
                )
            unit_price = item.value.get("UnitPrice")
            if unit_price:
                print(
                    "......Unit Price: {} has confidence: {}".format(
                        unit_price.value, unit_price.confidence
                    )
                )
            product_code = item.value.get("ProductCode")
            if product_code:
                print(
                    "......Product Code: {} has confidence: {}".format(
                        product_code.value, product_code.confidence
                    )
                )
            item_date = item.value.get("Date")
            if item_date:
                print(
                    "......Date: {} has confidence: {}".format(
                        item_date.value, item_date.confidence
                    )
                )
            tax = item.value.get("Tax")
            if tax:
                print(
                    "......Tax: {} has confidence: {}".format(tax.value, tax.confidence)
                )
            amount = item.value.get("Amount")
            if amount:
                print(
                    "......Amount: {} has confidence: {}".format(
                        amount.value, amount.confidence
                    )
                )
        subtotal = invoice.fields.get("SubTotal")
        if subtotal:
            print(
                "Subtotal: {} has confidence: {}".format(
                    subtotal.value, subtotal.confidence
                )
            )
        total_tax = invoice.fields.get("TotalTax")
        if total_tax:
            print(
                "Total Tax: {} has confidence: {}".format(
                    total_tax.value, total_tax.confidence
                )
            )
        previous_unpaid_balance = invoice.fields.get("PreviousUnpaidBalance")
        if previous_unpaid_balance:
            print(
                "Previous Unpaid Balance: {} has confidence: {}".format(
                    previous_unpaid_balance.value, previous_unpaid_balance.confidence
                )
            )
        amount_due = invoice.fields.get("AmountDue")
        if amount_due:
            print(
                "Amount Due: {} has confidence: {}".format(
                    amount_due.value, amount_due.confidence
                )
            )
        service_start_date = invoice.fields.get("ServiceStartDate")
        if service_start_date:
            print(
                "Service Start Date: {} has confidence: {}".format(
                    service_start_date.value, service_start_date.confidence
                )
            )
        service_end_date = invoice.fields.get("ServiceEndDate")
        if service_end_date:
            print(
                "Service End Date: {} has confidence: {}".format(
                    service_end_date.value, service_end_date.confidence
                )
            )
        service_address = invoice.fields.get("ServiceAddress")
        if service_address:
            print(
                "Service Address: {} has confidence: {}".format(
                    service_address.value, service_address.confidence
                )
            )
        service_address_recipient = invoice.fields.get("ServiceAddressRecipient")
        if service_address_recipient:
            print(
                "Service Address Recipient: {} has confidence: {}".format(
                    service_address_recipient.value,
                    service_address_recipient.confidence,
                )
            )
        remittance_address = invoice.fields.get("RemittanceAddress")
        if remittance_address:
            print(
                "Remittance Address: {} has confidence: {}".format(
                    remittance_address.value, remittance_address.confidence
                )
            )
        remittance_address_recipient = invoice.fields.get("RemittanceAddressRecipient")
        if remittance_address_recipient:
            print(
                "Remittance Address Recipient: {} has confidence: {}".format(
                    remittance_address_recipient.value,
                    remittance_address_recipient.confidence,
                )
            )

if __name__ == "__main__":
    analyze_invoice()

    print("----------------------------------------")

Ausführen der Anwendung

Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, erstellen Sie Ihr Programm und führen es aus:

Navigieren Sie zu dem Ordner, in dem Ihre Datei form_recognizer_quickstart.py enthalten ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:
```
python form_recognizer_quickstart.py
```

Beim Ausführen der Anwendung ist ein Problem aufgetreten.

Ausgabe des vordefinierten Modells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

  --------Recognizing invoice #1--------
  Vendor Name: CONTOSO LTD. has confidence: 0.919
  Vendor Address: 123 456th St New York, NY, 10001 has confidence: 0.907
  Vendor Address Recipient: Contoso Headquarters has confidence: 0.919
  Customer Name: MICROSOFT CORPORATION has confidence: 0.84
  Customer Id: CID-12345 has confidence: 0.956
  Customer Address: 123 Other St, Redmond WA, 98052 has confidence: 0.909
  Customer Address Recipient: Microsoft Corp has confidence: 0.917
  Invoice Id: INV-100 has confidence: 0.972
  Invoice Date: 2019-11-15 has confidence: 0.971
  Invoice Total: CurrencyValue(amount=110.0, symbol=$) has confidence: 0.97
  Due Date: 2019-12-15 has confidence: 0.973

Um die gesamte Ausgabe anzuzeigen, besuchen Sie das Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des vordefinierten Rechnungsmodells anzuzeigen.

| REST-API für die Formularerkennung | Azure-SDKs | Unterstützte SDKs

In dieser Schnellstartanleitung verwenden Sie die Formularerkennungs-REST-API, um Daten und Werte aus Formularen und Dokumenten zu analysieren und zu extrahieren:

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Curl-Befehlszeilentool installiert.
- Windows
- Mac oder Linux
PowerShell ab Version 7.* (oder eine ähnliche Befehlszeilenanwendung):
- Windows
- macOS
- Linux
Geben Sie den folgenden Befehl entsprechend Ihres Betriebssystems ein, um Ihre PowerShell-Version zu überprüfen:
- Windows: Get-Host | Select-Object Version
- macOS oder Linux: $PSVersionTable
Eine Formularerkennung (Single-Service) oder Cognitive Services (Multi-Service)-Ressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Es ist ein Problem mit den Voraussetzungen aufgetreten.

Analysieren von Dokumenten und Erhalten von Ergebnissen

Eine POST-Anforderung wird verwendet, um Dokumente mit einem vordefinierten oder benutzerdefinierten Modell zu analysieren. Eine GET-Anforderung wird verwendet, um das Ergebnis eines Dokumentanalyseaufrufs abzurufen. modelId wird mit POST- und resultId mit GET-Vorgängen verwendet.

Analysieren eines Dokuments (POST-Anforderung)

Nehmen Sie vor dem Ausführen des cURL-Befehls die folgenden Änderungen an der POST-Anforderung vor:

Ersetzen Sie {endpoint} durch den Endpunktwert aus Ihrer Formularerkennung-Instanz im Azure-Portal.
Ersetzen Sie {key} durch den Schlüssel aus Ihrer Formularerkennung-Instanz im Azure-Portal.
Ersetzen Sie {modelID} und {your-document-url} anhand der nachstehenden Tabelle durch die gewünschten Werte.

Sie benötigen eine Dokumentdatei unter einer URL. Für diese Schnellstartanleitung können Sie für jedes Feature die in der folgenden Tabelle angegebenen Beispielformulare verwenden.

Beispieldokumente

Feature	{modelID}	{your-document-url}
Allgemeines Dokument	prebuilt-document	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf`
Lesen	prebuilt-read	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png`
Layout	prebuilt-layout	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png`
🆕 Krankenversicherungskarte	healthInsuranceCard.us	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png`
W-2	prebuilt-tax.us.w2	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png`
Rechnung	Vordefinierte Rechnung	`https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf`
Rechnung	prebuilt-receipt	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png`
Ausweisdokument	prebuilt-idDocument	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png`
Visitenkarte	prebuilt-businessCard	`https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg`

Bei der POST-Anforderung ist ein Problem aufgetreten.

Wichtig

POST-Anforderung

curl -v -i POST "{endpoint}/formrecognizer/documentModels/{modelID}:analyze?api-version=2022-08-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

POST-Antwort

Sie erhalten die Antwort 202 (Success) mit einem Operation-location-Header. Der Wert dieses Headers enthält eine resultID, die abgefragt werden kann, um den Status des asynchronen Vorgangs abzurufen:

{alt-text}

Abrufen von Analyseergebnissen (GET-Anforderung)

Rufen Sie nach dem Aufrufen der Analyze Document-API die Get Analyze Result-API auf, um den Status des Vorgangs und die extrahierten Daten abzurufen. Nehmen Sie die folgenden Änderungen vor, bevor Sie den Befehl ausführen:

Ersetzen Sie den Operation-Location-Header {POST response} aus der POST-Antwort.
Ersetzen Sie {key} durch den Schlüsselwert Ihrer Formularerkennung-Instanz im Azure-Portal.

GET-Anforderung

curl -v -X GET "{POST response}" -H "Ocp-Apim-Subscription-Key: {key}"

Untersuchen der Antwort

Sie erhalten die Antwort 200 (Success) mit einer JSON-Ausgabe. Das erste Feld, "status", gibt den Status des Vorgangs an. Wenn der Vorgang nicht abgeschlossen ist, wird für "status" der Wert "running" oder "notStarted" angezeigt, und Sie sollten die API entweder manuell oder über ein Skript erneut aufrufen. Ein Intervall von mindestens einer Sekunde zwischen den Aufrufen wird empfohlen.

Bei der GET-Anforderung ist ein Problem aufgetreten.

Beispielantwort für „prebuilt-invoice“

{
    "status": "succeeded",
    "createdDateTime": "2022-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2022-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2022-08-31",
        "modelId": "prebuilt-invoice",
        "stringIndexType": "textElements"...
    ..."pages": [
            {
                "pageNumber": 1,
                "angle": 0,
                "width": 8.5,
                "height": 11,
                "unit": "inch",
                "words": [
                    {
                        "content": "CONTOSO",
                        "boundingBox": [
                            0.5911,
                            0.6857,
                            1.7451,
                            0.6857,
                            1.7451,
                            0.8664,
                            0.5911,
                            0.8664
                        ],
                        "confidence": 1,
                        "span": {
                            "offset": 0,
                            "length": 7
                        }
                    },
}

Unterstützte Dokumentfelder

Die vordefinierten Modelle extrahieren vordefinierte Sätze von Dokumentfeldern. Informationen zu extrahierten Feldnamen, Typen, Beschreibungen und Beispielen finden Sie unter Extraktion von Modelldaten.

Das war's, herzlichen Glückwunsch!

In dieser Schnellstartanleitung haben Sie ein Formularerkennungsmodell verwendet, um verschiedene Formulare und Dokumente zu analysieren. Lesen Sie als Nächstes die Referenzdokumentation für das Formularerkennungsstudio, um ausführliche Informationen zur API für die Formularerkennung zu erhalten.

Nächste Schritte

Ausprobieren von Formularerkennung Studio

Lesen Sie unsere Dokumentation, um mehr über Modelle für die Formularerkennung zu erfahren

Dieser Artikel gilt für:Formularerkennung v2.1. Höhere Version:Formularerkennung v3.0

Verwenden Sie die Programmiersprache Ihrer Wahl oder die REST-API, um die Arbeit mit der Azure-Formularerkennung zu beginnen. Die Azure-Formularerkennung ist eine cloudbasierte Instanz von Azure Applied AI Services, die Machine Learning verwendet, um Schlüssel-Wert-Paare, Text und Tabellen aus Ihren Dokumenten zu extrahieren. Sie können Formularerkennungsmodelle leicht aufrufen, indem Sie unsere Clientbibliothek-SDKs in Ihre Workflows und Anwendungen integrieren. Sie sollten den kostenlosen Dienst nutzen, wenn Sie die Technologie erlernen. Bedenken Sie, dass die Anzahl der kostenlosen Seiten auf 500 pro Monat beschränkt ist.

Weitere Informationen zu Funktionen der Formularerkennung und zu Entwicklungsoptionen finden Sie auf unserer Übersichtsseite.

Referenzdokumentation | Quellcode der Bibliothek | Paket (NuGet) | Beispiele

In dieser Schnellstartanleitung verwenden Sie die folgenden APIs zum Extrahieren strukturierter Daten aus Formularen und Dokumenten:

Layout
Rechnung

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Aktuelle Version der Visual Studio-IDE
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Einrichten

Starten Sie Visual Studio 2019.
Wählen Sie auf der Startseite Neues Projekt erstellen aus.
Geben Sie auf der Seite Neues Projekt erstellen im Suchfeld den Suchbegriff Konsole ein. Wählen Sie die Vorlage Konsolenanwendung und dann Weiter aus.
Geben Sie im Dialogfeld Neues Projekt konfigurieren im Feld für den Projektnamen den Namen formRecognizer_quickstart ein. Wählen Sie anschließend „Weiter“ aus.
Wählen Sie im Dialogfeld Weitere Informationen die Option .NET 5.0 (aktuell) und dann Erstellen aus.

Installieren der Clientbibliothek mit NuGet

Klicken Sie mit der rechten Maustaste auf das Projekt formRecognizer_quickstart, und wählen Sie die Option NuGet-Pakete verwalten... aus.
Wählen Sie die Registerkarte „Durchsuchen“ aus, und geben Sie „Azure.AI.FormRecognizer“ ein.
Wählen Sie im Dropdownmenü die Version 3.1.1 und anschließend die Option Installieren aus.

Erstellen Ihrer Anwendung

Für die Interaktion mit dem Dienst „Formularerkennung“ müssen Sie eine Instanz der FormRecognizerClient-Klasse erstellen. Erstellen Sie hierfür ein AzureKeyCredential-Element mit Ihrem Schlüssel und eine FormRecognizerClient-Instanz mit dem AzureKeyCredential-Element und dem Endpunkt (endpoint) der Formularerkennung.

Hinweis

Ab .NET 6 erzeugen neue Projekte, die die Vorlage console verwenden, einen neuen Programmstil, der sich von früheren Versionen unterscheidet.
Die neue Ausgabe verwendet aktuelle C#-Funktionen, die den zu schreibenden Code vereinfachen.
Wenn Sie die neuere Version verwenden, müssen Sie nur den Text der Main-Methode schreiben. Sie müssen keine Top-Level-Anweisungen, globale Nutzungsanweisungen oder indirekte Nutzungsanweisungen einfügen.
Weitere Informationen finden Sie unter sieheNeue C#-Schablonen erzeugen Top-Level-Anweisungen.

Öffnen Sie die Datei Program.cs.
Fügen Sie die folgenden using-Direktiven ein:

using Azure;
using Azure.AI.FormRecognizer;
using Azure.AI.FormRecognizer.Models;
using System.Threading.Tasks;

Legen Sie Ihre Umgebungsvariablen endpoint und key fest, und erstellen Sie Ihre Instanzen von AzureKeyCredential und FormRecognizerClient:

private static readonly string endpoint = "your-form-recognizer-endpoint";
private static readonly string key = "your-api-key";
private static readonly AzureKeyCredential credential = new AzureKeyCredential(key);

Löschen Sie die Zeile Console.Writeline("Hello World!");, und fügen Sie die Codebeispiele für Try It (Ausprobieren) der Datei Program.cs hinzu:
Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in die Main-Methode Ihrer Anwendung aus:
- Layout
- Vordefinierte Rechnung

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wieAzure Key Vault. Weitere Informationen finden Sie im Artikel zur Sicherheit von Cognitive Services.

Try it (Ausprobieren): Layoutmodell

Dient zum Extrahieren von Text, Auswahlmarkierungen, Textformaten und Tabellenstrukturen sowie der zugehörigen Begrenzungsbereichskoordinaten aus Dokumenten.

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Wir haben den Datei-URI-Wert der Variablen formUri hinzugefügt.
Verwenden Sie zum Extrahieren des Layouts aus einer bestimmten Datei unter einem URI die StartRecognizeContentFromUriAsync-Methode.

Fügen Sie der Datei „Program.cs“ für Ihre Layoutanwendung den folgenden Code hinzu:


FormRecognizerClient recognizerClient = AuthenticateClient();

Task recognizeContent = RecognizeContent(recognizerClient);
Task.WaitAll(recognizeContent);

private static FormRecognizerClient AuthenticateClient()
            {
                var credential = new AzureKeyCredential(key);
                var client = new FormRecognizerClient(new Uri(endpoint), credential);
                return client;
            }

            private static async Task RecognizeContent(FormRecognizerClient recognizerClient)
        {
            string formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
            FormPageCollection formPages = await recognizerClient
        .StartRecognizeContentFromUri(new Uri(formUrl))
        .WaitForCompletionAsync();

            foreach (FormPage page in formPages)
            {
                Console.WriteLine($"Form Page {page.PageNumber} has {page.Lines.Count} lines.");

                for (int i = 0; i < page.Lines.Count; i++)
                {
                    FormLine line = page.Lines[i];
                    Console.WriteLine($"    Line {i} has {line.Words.Count} word{(line.Words.Count > 1 ? "s" : "")}, and text: '{line.Text}'.");
                }

                for (int i = 0; i < page.Tables.Count; i++)
                {
                    FormTable table = page.Tables[i];
                    Console.WriteLine($"Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
                    foreach (FormTableCell cell in table.Cells)
                    {
                        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) contains text: '{cell.Text}'.");
                    }
                }
            }
        }
    }
}

Probieren Sie es aus: Vordefiniertes Modell

In diesem Beispiel analysieren Sie ein Rechnungsdokument mithilfe eines vordefinierten Modells. Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Sie haben den Datei-URI-Wert oben in der Main-Methode der Variable invoiceUri hinzugefügt.
Verwenden Sie für die Analyse einer bestimmten Datei unter einem URI die StartRecognizeInvoicesFromUriAsync-Methode.
Der Einfachheit halber werden hier nicht alle Felder angezeigt, die vom Dienst zurückgegeben werden. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.

Auswählen eines vordefinierten Modells

Sie sind hierbei nicht auf Rechnungen beschränkt, sondern können zwischen mehreren vordefinierten Modellen wählen, von denen jedes über eine Gruppe unterstützter Felder verfügt. Welches Modell für den Analysevorgang verwendet wird, hängt vom Typ des zu analysierenden Dokuments ab. Dies sind die vordefinierten Modelle, die vom Formularerkennungsdienst derzeit unterstützt werden:

Rechnung: Extrahieren von Text, Auswahlmarkierungen, Tabellen, Feldern und wichtigen Informationen aus Rechnungen
Beleg: Extrahieren von Text und wichtigen Informationen aus Belegen
Ausweisdokument: Extrahieren von Text und wichtigen Informationen aus Führerscheinen und Reisepässen
Visitenkarte: Extrahieren von Text und wichtigen Informationen aus Visitenkarten

Fügen Sie den folgenden Code zu Ihrer vordefinierten Methode für die Rechnungsanwendung der Datei „Program.cs“ hinzu.

FormRecognizerClient recognizerClient = AuthenticateClient();

  Task analyzeinvoice = AnalyzeInvoice(recognizerClient, invoiceUrl);
  Task.WaitAll(analyzeinvoice);

   private static FormRecognizerClient AuthenticateClient() {
     var credential = new AzureKeyCredential(key);
     var client = new FormRecognizerClient(new Uri(endpoint), credential);
     return client;
   }

   static string invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

   private static async Task AnalyzeInvoice(FormRecognizerClient recognizerClient, string invoiceUrl) {
     var options = new RecognizeInvoicesOptions() {
       Locale = "en-US"
     };
     RecognizedFormCollection invoices = await recognizerClient.StartRecognizeInvoicesFromUriAsync(new Uri(invoiceUrl), options).WaitForCompletionAsync();

     RecognizedForm invoice = invoices[0];

     FormField invoiceIdField;
     if (invoice.Fields.TryGetValue("InvoiceId", out invoiceIdField)) {
       if (invoiceIdField.Value.ValueType == FieldValueType.String) {
         string invoiceId = invoiceIdField.Value.AsString();
         Console.WriteLine($"    Invoice Id: '{invoiceId}', with confidence {invoiceIdField.Confidence}");
       }
     }

     FormField invoiceDateField;
     if (invoice.Fields.TryGetValue("InvoiceDate", out invoiceDateField)) {
       if (invoiceDateField.Value.ValueType == FieldValueType.Date) {
         DateTime invoiceDate = invoiceDateField.Value.AsDate();
         Console.WriteLine($"    Invoice Date: '{invoiceDate}', with confidence {invoiceDateField.Confidence}");
       }
     }

     FormField dueDateField;
     if (invoice.Fields.TryGetValue("DueDate", out dueDateField)) {
       if (dueDateField.Value.ValueType == FieldValueType.Date) {
         DateTime dueDate = dueDateField.Value.AsDate();
         Console.WriteLine($"    Due Date: '{dueDate}', with confidence {dueDateField.Confidence}");
       }
     }

     FormField vendorNameField;
     if (invoice.Fields.TryGetValue("VendorName", out vendorNameField)) {
       if (vendorNameField.Value.ValueType == FieldValueType.String) {
         string vendorName = vendorNameField.Value.AsString();
         Console.WriteLine($"    Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
       }
     }

     FormField vendorAddressField;
     if (invoice.Fields.TryGetValue("VendorAddress", out vendorAddressField)) {
       if (vendorAddressField.Value.ValueType == FieldValueType.String) {
         string vendorAddress = vendorAddressField.Value.AsString();
         Console.WriteLine($"    Vendor Address: '{vendorAddress}', with confidence {vendorAddressField.Confidence}");
       }
     }

     FormField customerNameField;
     if (invoice.Fields.TryGetValue("CustomerName", out customerNameField)) {
       if (customerNameField.Value.ValueType == FieldValueType.String) {
         string customerName = customerNameField.Value.AsString();
         Console.WriteLine($"    Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
       }
     }

     FormField customerAddressField;
     if (invoice.Fields.TryGetValue("CustomerAddress", out customerAddressField)) {
       if (customerAddressField.Value.ValueType == FieldValueType.String) {
         string customerAddress = customerAddressField.Value.AsString();
         Console.WriteLine($"    Customer Address: '{customerAddress}', with confidence {customerAddressField.Confidence}");
       }
     }

     FormField customerAddressRecipientField;
     if (invoice.Fields.TryGetValue("CustomerAddressRecipient", out customerAddressRecipientField)) {
       if (customerAddressRecipientField.Value.ValueType == FieldValueType.String) {
         string customerAddressRecipient = customerAddressRecipientField.Value.AsString();
         Console.WriteLine($"    Customer address recipient: '{customerAddressRecipient}', with confidence {customerAddressRecipientField.Confidence}");
       }
     }

     FormField invoiceTotalField;
     if (invoice.Fields.TryGetValue("InvoiceTotal", out invoiceTotalField)) {
       if (invoiceTotalField.Value.ValueType == FieldValueType.Float) {
         float invoiceTotal = invoiceTotalField.Value.AsFloat();
         Console.WriteLine($"    Invoice Total: '{invoiceTotal}', with confidence {invoiceTotalField.Confidence}");
       }
     }
   }
 }
}

Ausführen der Anwendung

Wählen Sie die grüne Schaltfläche Starten neben „formRecognizer_quickstart“ aus, um Ihr Programm zu kompilieren und auszuführen, oder drücken Sie F5.

Screenshot: Ausführen Ihres Visual Studio-Programms

Referenzdokumentation | Quellcode der Bibliothek | Paket (Maven) | Beispiele

In dieser Schnellstartanleitung verwenden Sie die folgenden APIs zum Extrahieren strukturierter Daten aus Formularen und Dokumenten:

Layout
Rechnung

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Java Development Kit (JDK), Version 8 oder höher. Weitere Informationen finden Sie unterUnterstützte Java-Versionen und Zeitplan für Updates.
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Einrichten

Erstellen eines neuen Gradle-Projekts

Erstellen Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App mit dem Namen form-recognizer-app, und navigieren Sie zu diesem Verzeichnis.

mkdir form-recognizer-app && form-recognizer-app

Führen Sie den Befehl gradle init in Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle erstellt, u. a. die Datei build.gradle.kts. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.
```
gradle init --type basic
```
Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.
Übernehmen Sie den Standardprojektnamen (form-recognizer-app).

Installieren der Clientbibliothek

In dieser Schnellstartanleitung wird der Gradle-Abhängigkeits-Manager verwendet. Die Clientbibliothek und Informationen zu anderen Abhängigkeits-Managern finden Sie im zentralen Maven-Repository.

Fügen Sie in die Datei build.gradle.kts Ihres Projekts die Clientbibliothek als als implementation-Anweisung sowie die erforderlichen Plug-Ins und Einstellungen ein.

plugins {
    java
    application
}
application {
    mainClass.set("FormRecognizer")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-formrecognizer", version = "3.1.1")
}

Erstellen einer Java-Datei

Führen Sie in Ihrem Arbeitsverzeichnis den folgenden Befehl aus:

mkdir -p src/main/java

Sie erstellen die folgende Verzeichnisstruktur:

Screenshot: Die Struktur des Java-Verzeichnisses der Anwendung

Navigieren Sie zum Java-Verzeichnis, und erstellen Sie eine Datei mit dem Namen FormRecognizer.java. Öffnen Sie sie in Ihrem bevorzugten Editor bzw. Ihrer bevorzugten IDE, und fügen Sie die folgende Paketdeklaration und die folgenden import-Anweisungen hinzu:

import com.azure.ai.formrecognizer.*;
import com.azure.ai.formrecognizer.models.*;

import java.util.concurrent.atomic.AtomicReference;
import java.util.List;
import java.util.Map;
import java.time.LocalDate;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.util.Context;
import com.azure.core.util.polling.SyncPoller;

Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in die main-Methode Ihrer Anwendung aus:

Layout
Vordefinierte Rechnung

Wichtig

Try it (Ausprobieren): Layoutmodell

Dient zum Extrahieren von Text, Auswahlmarkierungen, Textformaten und Tabellenstrukturen sowie der zugehörigen Begrenzungsbereichskoordinaten aus Dokumenten.

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Für die Analyse einer bestimmten Datei unter einem URI verwenden Sie die beginRecognizeContentFromUrl-Methode.
Wir haben den Datei-URI-Wert der Variablen formUrl in der main-Methode hinzugefügt.

Aktualisieren Sie die FormRecognizer-Klasse Ihrer Anwendung mit dem folgenden Code (mit Aktualisierung der Schlüssel- und Endpunktvariablen mit Werten aus Ihrer Instanz der Formularerkennung im Azure-Portal):


static final String key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
static final String endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

public static void main(String[] args) {FormRecognizerClient recognizerClient = new FormRecognizerClientBuilder()
                .credential(new AzureKeyCredential(key)).endpoint(endpoint).buildClient();

    String formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";

    System.out.println("Get form content...");
        GetContent(recognizerClient, formUrl);
  }
    private static void GetContent(FormRecognizerClient recognizerClient, String invoiceUri) {
        String analyzeFilePath = invoiceUri;
        SyncPoller<FormRecognizerOperationResult, List<FormPage>> recognizeContentPoller = recognizerClient
                .beginRecognizeContentFromUrl(analyzeFilePath);

        List<FormPage> contentResult = recognizeContentPoller.getFinalResult();
        // </snippet_getcontent_call>
        // <snippet_getcontent_print>
        contentResult.forEach(formPage -> {
            // Table information
            System.out.println("----Recognizing content ----");
            System.out.printf("Has width: %f and height: %f, measured with unit: %s.%n", formPage.getWidth(),
                    formPage.getHeight(), formPage.getUnit());
            formPage.getTables().forEach(formTable -> {
                System.out.printf("Table has %d rows and %d columns.%n", formTable.getRowCount(),
                        formTable.getColumnCount());
                formTable.getCells().forEach(formTableCell -> {
                    System.out.printf("Cell has text %s.%n", formTableCell.getText());
                });
                System.out.println();
            });
        });
    }

Probieren Sie es aus: Vordefiniertes Modell

In diesem Beispiel analysieren Sie ein Rechnungsdokument mithilfe eines vordefinierten Modells. Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Für die Analyse einer bestimmten Datei unter einem URI verwenden Sie beginRecognizeInvoicesFromUrl.
Wir haben den Datei-URI-Wert der Variablen invoiceUrl in der main-Methode hinzugefügt.
Der Einfachheit halber werden hier nicht alle Felder angezeigt, die vom Dienst zurückgegeben werden. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.

Auswählen eines vordefinierten Modells

Sie sind hierbei nicht auf Rechnungen beschränkt, sondern können zwischen mehreren vordefinierten Modellen wählen, von denen jedes über eine Gruppe unterstützter Felder verfügt. Welches Modell für den Analysevorgang verwendet wird, hängt vom Typ des zu analysierenden Dokuments ab. Dies sind die vordefinierten Modelle, die vom Formularerkennungsdienst derzeit unterstützt werden:

Rechnung: Extrahieren von Text, Auswahlmarkierungen, Tabellen, Feldern und wichtigen Informationen aus Rechnungen
Beleg: Extrahieren von Text und wichtigen Informationen aus Belegen
Ausweisdokument: Extrahieren von Text und wichtigen Informationen aus Führerscheinen und Reisepässen
Visitenkarte: Extrahieren von Text und wichtigen Informationen aus Visitenkarten


static final String key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
static final String endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

public static void main(String[] args) {
    FormRecognizerClient recognizerClient = new FormRecognizerClientBuilder().credential(new AzureKeyCredential(key)).endpoint(endpoint).buildClient();

    String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

    System.out.println("Analyze invoice...");
        AnalyzeInvoice(recognizerClient, invoiceUrl);
  }
    private static void AnalyzeInvoice(FormRecognizerClient recognizerClient, String invoiceUrl) {
      SyncPoller < FormRecognizerOperationResult,
        List < RecognizedForm >> recognizeInvoicesPoller = recognizerClient.beginRecognizeInvoicesFromUrl(invoiceUrl);
      List < RecognizedForm > recognizedInvoices = recognizeInvoicesPoller.getFinalResult();

      for (int i = 0; i < recognizedInvoices.size(); i++) {
        RecognizedForm recognizedInvoice = recognizedInvoices.get(i);
        Map < String,
        FormField > recognizedFields = recognizedInvoice.getFields();
        System.out.printf("----------- Recognized invoice info for page %d -----------%n", i);
        FormField vendorNameField = recognizedFields.get("VendorName");
        if (vendorNameField != null) {
            if (FieldValueType.STRING == vendorNameField.getValue().getValueType()) {
                String merchantName = vendorNameField.getValue().asString();
                System.out.printf("Vendor Name: %s, confidence: %.2f%n", merchantName, vendorNameField.getConfidence());
            }
        }

        FormField vendorAddressField = recognizedFields.get("VendorAddress");
        if (vendorAddressField != null) {
            if (FieldValueType.STRING == vendorAddressField.getValue().getValueType()) {
                String merchantAddress = vendorAddressField.getValue().asString();
                System.out.printf("Vendor address: %s, confidence: %.2f%n", merchantAddress, vendorAddressField.getConfidence());
            }
        }

        FormField customerNameField = recognizedFields.get("CustomerName");
        if (customerNameField != null) {
            if (FieldValueType.STRING == customerNameField.getValue().getValueType()) {
                String merchantAddress = customerNameField.getValue().asString();
                System.out.printf("Customer Name: %s, confidence: %.2f%n", merchantAddress, customerNameField.getConfidence());
            }
        }

        FormField customerAddressRecipientField = recognizedFields.get("CustomerAddressRecipient");
        if (customerAddressRecipientField != null) {
            if (FieldValueType.STRING == customerAddressRecipientField.getValue().getValueType()) {
                String customerAddr = customerAddressRecipientField.getValue().asString();
                System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n", customerAddr, customerAddressRecipientField.getConfidence());
            }
        }

        FormField invoiceIdField = recognizedFields.get("InvoiceId");
        if (invoiceIdField != null) {
            if (FieldValueType.STRING == invoiceIdField.getValue().getValueType()) {
                String invoiceId = invoiceIdField.getValue().asString();
                System.out.printf("Invoice Id: %s, confidence: %.2f%n", invoiceId, invoiceIdField.getConfidence());
            }
        }

        FormField invoiceDateField = recognizedFields.get("InvoiceDate");
        if (customerNameField != null) {
            if (FieldValueType.DATE == invoiceDateField.getValue().getValueType()) {
                LocalDate invoiceDate = invoiceDateField.getValue().asDate();
                System.out.printf("Invoice Date: %s, confidence: %.2f%n", invoiceDate, invoiceDateField.getConfidence());
            }
        }

        FormField invoiceTotalField = recognizedFields.get("InvoiceTotal");
        if (customerAddressRecipientField != null) {
            if (FieldValueType.FLOAT == invoiceTotalField.getValue().getValueType()) {
                Float invoiceTotal = invoiceTotalField.getValue().asFloat();
                System.out.printf("Invoice Total: %.2f, confidence: %.2f%n", invoiceTotal, invoiceTotalField.getConfidence());
            }
        }
    }
}

Erstellen und Ausführen der Anwendung

Navigieren Sie zurück zum Hauptverzeichnis (form-recognizer-app) Ihres Projekts.

Erstellen Sie Ihre Anwendung mit dem Befehl build:

gradle build

Führen Sie Ihre Anwendung mit dem Befehl run aus:

gradle run

Referenzdokumentation | Quellcode der Bibliothek | Paket (npm) | Beispiele

In dieser Schnellstartanleitung verwenden Sie die folgenden APIs zum Extrahieren strukturierter Daten aus Formularen und Dokumenten:

Layout
Rechnung

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Die aktuelle Version von Visual Studio Code oder Ihrer bevorzugten IDE
Die aktuelle LTS-Version von Node.js
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Einrichten

Erstellen Sie eine neue Node.js-Anwendung. Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.
```
mkdir form-recognizer-app && cd form-recognizer-app
```
Führen Sie den Befehl npm init aus, um eine Knotenanwendung mit der Datei package.json zu erstellen.
```
npm init
```
Installieren Sie das npm-Paket der Clientbibliothek ai-form-recognizer:
```
npm install @azure/ai-form-recognizer
```
Die Datei package.json Ihrer App wird mit den Abhängigkeiten aktualisiert.
Erstellen Sie eine Datei mit dem Namen index.js, öffnen Sie sie, und importieren Sie die folgenden Bibliotheken:
```
const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");
```

Erstellen Sie Variablen für den Azure-Endpunkt und -Schlüssel Ihrer Ressource:

const key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
const endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

An diesem Punkt sollte Ihre JavaScript-Anwendung die folgenden Codezeilen enthalten:


const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");

const endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";
const key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";

Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in Ihre Anwendung aus:

Layout
Vordefinierte Rechnung

Wichtig

Try it (Ausprobieren): Layoutmodell

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Sie haben den Datei-URI-Wert der Variable formUrl im oberen Bereich der Datei hinzugefügt.
Für die Analyse einer bestimmten Datei unter einem URI verwenden Sie die beginRecognizeContent-Methode.

Fügen Sie Ihrer Layoutanwendung in der Zeile unterhalb der Variablen `key` den folgenden Code hinzu:

const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

async function recognizeContent() {
    const client = new FormRecognizerClient(endpoint, new AzureKeyCredential(key));
    const poller = await client.beginRecognizeContentFromUrl(formUrl);
    const pages = await poller.pollUntilDone();

    if (!pages || pages.length === 0) {
        throw new Error("Expecting non-empty list of pages!");
    }

    for (const page of pages) {
        console.log(
            `Page ${page.pageNumber}: width ${page.width} and height ${page.height} with unit ${page.unit}`
        );
        for (const table of page.tables) {
            for (const cell of table.cells) {
                console.log(`cell [${cell.rowIndex},${cell.columnIndex}] has text ${cell.text}`);
            }
        }
    }
}

recognizeContent().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Probieren Sie es aus: Vordefiniertes Modell

In diesem Beispiel wird veranschaulicht, wie Sie Daten aus bestimmten Arten von häufig verwendeten Dokumenten mit vortrainierten Modellen analysieren, indem eine Rechnung als Beispiel verwendet wird. Eine vollständige Liste mit Rechnungsfeldernfinden Sie auf unserer Seite mit den vordefinierten Konzepten.

In diesem Beispiel analysieren Sie ein Rechnungsdokument mithilfe eines vordefinierten Modells. Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Sie haben den Datei-URI-Wert der Variable invoiceUrl im oben in der Datei hinzugefügt.
Für die Analyse einer bestimmten Datei unter einem URI verwenden Sie die beginRecognizeInvoices-Methode.
Der Einfachheit halber werden hier nicht alle Felder angezeigt, die vom Dienst zurückgegeben werden. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.

Auswählen eines vordefinierten Modells

Sie sind hierbei nicht auf Rechnungen beschränkt, sondern können zwischen mehreren vordefinierten Modellen wählen, von denen jedes über eine Gruppe unterstützter Felder verfügt. Welches Modell für den Analysevorgang verwendet wird, hängt vom Typ des zu analysierenden Dokuments ab. Dies sind die vordefinierten Modelle, die vom Formularerkennungsdienst derzeit unterstützt werden:

Rechnung: Extrahieren von Text, Auswahlmarkierungen, Tabellen, Feldern und wichtigen Informationen aus Rechnungen
Beleg: Extrahieren von Text und wichtigen Informationen aus Belegen
Ausweisdokument: Extrahieren von Text und wichtigen Informationen aus Führerscheinen und Reisepässen
Visitenkarte: Extrahieren von Text und wichtigen Informationen aus Visitenkarten

Fügen Sie Ihrer vordefinierten Rechnungsanwendung unterhalb der Variablen `key` den folgenden Code hinzu:


const invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

async function recognizeInvoices() {

    const client = new FormRecognizerClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginRecognizeInvoicesFromUrl(invoiceUrl);
    const [invoice] = await poller.pollUntilDone();

    if (invoice === undefined) {
        throw new Error("Failed to extract data from at least one invoice.");
    }

    /**
     * This is a helper function for printing a simple field with an elemental type.
     */
    function fieldToString(field) {
        const {
            name,
            valueType,
            value,
            confidence
        } = field;
        return `${name} (${valueType}): '${value}' with confidence ${confidence}'`;
    }

    console.log("Invoice fields:");

    /**
     * Invoices contain a lot of optional fields, but they are all of elemental types
     * such as strings, numbers, and dates, so we will just enumerate them all.
     */
    for (const [name, field] of Object.entries(invoice.fields)) {
        if (field.valueType !== "array" && field.valueType !== "object") {
            console.log(`- ${name} ${fieldToString(field)}`);
        }
    }

    // Invoices also support nested line items, so we can iterate over them.
    let idx = 0;

    console.log("- Items:");

    const items = invoice.fields["Items"]?.value;
    for (const item of items ?? []) {
        const value = item.value;

        // Each item has several subfields that are nested within the item. We'll
        // map over this list of the subfields and filter out any fields that
        // weren't found. Not all fields will be returned every time, only those
        // that the service identified for the particular document in question.

        const subFields = [
                "Description",
                "Quantity",
                "Unit",
                "UnitPrice",
                "ProductCode",
                "Date",
                "Tax",
                "Amount"
            ]
            .map((fieldName) => value[fieldName])
            .filter((field) => field !== undefined);

        console.log(
            [
                `  - Item #${idx}`,
                // Now we will convert those fields into strings to display
                ...subFields.map((field) => `    - ${fieldToString(field)}`)
            ].join("\n")
        );
    }
}

recognizeInvoices().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Referenzdokumentation | Quellcode der Bibliothek | Paket (PyPi) | Beispiele

In dieser Schnellstartanleitung verwenden Sie die folgenden APIs zum Extrahieren strukturierter Daten aus Formularen und Dokumenten:

Layout
Rechnung

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Python 3.x
- Ihre Python-Installation sollte pip enthalten. Sie können überprüfen, ob pip installiert ist, indem Sie pip --version in der Befehlszeile ausführen. Installieren Sie die aktuelle Python-Version, um pip zu erhalten.
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Einrichten

Öffnen Sie in Ihrer lokalen Umgebung ein Terminalfenster, und installieren Sie die Azure-Formularerkennung-Clientbibliothek für Python mit pip:

pip install azure-ai-formrecognizer

Erstellen einer neuen Python-Anwendung

Erstellen Sie mit Ihrem bevorzugten Editor bzw. Ihrer IDE eine neue Python-Anwendung mit dem Namen form_recognizer_quickstart.py. Importieren Sie anschließend die folgenden Bibliotheken:

import os
from azure.ai.formrecognizer import FormRecognizerClient
from azure.core.credentials import AzureKeyCredential

Erstellen von Variablen für den Endpunkt und Schlüssel Ihrer Azure-Ressource

endpoint = "YOUR_FORM_RECOGNIZER_ENDPOINT"
key = "YOUR_FORM_RECOGNIZER_KEY"

An diesem Punkt sollte Ihre Python-Anwendung die folgenden Codezeilen enthalten:

import os
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

endpoint = "YOUR_FORM_RECOGNIZER_ENDPOINT"
key = "YOUR_FORM_RECOGNIZER_KEY"

Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in Ihre Anwendung aus:

Layout
Vordefinierte Rechnung

Wichtig

Try it (Ausprobieren): Layoutmodell

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
Sie haben den Datei-URI-Wert der Variable formUrl im oberen Bereich der Datei hinzugefügt.
Für die Analyse einer bestimmten Datei unter einem URI verwenden Sie die begin_recognize_content_from_url-Methode.

Fügen Sie Ihrer Layoutanwendung in der Zeile unterhalb der Variablen `key` den folgenden Code hinzu:


  def format_bounding_box(bounding_box):
    if not bounding_box:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in bounding_box])

 def recognize_content():
    # sample form document
    formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

    form_recognizer_client = FormRecognizerClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = form_recognizer_client.begin_recognize_content_from_url(formUrl)
    form_pages = poller.result()

    for idx, content in enumerate(form_pages):
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                content.width, content.height, content.unit
            )
        )
        for table_idx, table in enumerate(content.tables):
            print(
                "Table # {} has {} rows and {} columns".format(
                    table_idx, table.row_count, table.column_count
                )
            )
            print(
                "Table # {} location on page: {}".format(
                    table_idx, format_bounding_box(table.bounding_box)
                )
            )
            for cell in table.cells:
                print(
                    "...Cell[{}][{}] has text '{}' within bounding box '{}'".format(
                        cell.row_index,
                        cell.column_index,
                        cell.text,
                        format_bounding_box(cell.bounding_box),
                    )
                )

        for line_idx, line in enumerate(content.lines):
            print(
                "Line # {} has word count '{}' and text '{}' within bounding box '{}'".format(
                    line_idx,
                    len(line.words),
                    line.text,
                    format_bounding_box(line.bounding_box),
                )
            )
            if line.appearance:
                if (
                    line.appearance.style_name == "handwriting"
                    and line.appearance.style_confidence > 0.8
                ):
                    print(
                        "Text line '{}' is handwritten and might be a signature.".format(
                            line.text
                        )
                    )
            for word in line.words:
                print(
                    "...Word '{}' has a confidence of {}".format(
                        word.text, word.confidence
                    )
                )

        for selection_mark in content.selection_marks:
            print(
                "Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_bounding_box(selection_mark.bounding_box),
                    selection_mark.confidence,
                )
            )
        print("----------------------------------------")


if __name__ == "__main__":
    recognize_content()

Probieren Sie es aus: Vordefiniertes Modell

In diesem Beispiel analysieren Sie ein Rechnungsdokument mithilfe eines vordefinierten Modells. Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.
Wir haben den Datei-URI-Wert der Variablen „formUrl“ oben in der Datei hinzugefügt.
Sie verwenden die Methode „begin_recognize_invoices_from_url“, um eine bestimmte Datei unter einem URI zu analysieren.
Der Einfachheit halber werden hier nicht alle Felder angezeigt, die vom Dienst zurückgegeben werden. Eine Liste aller unterstützten Felder mit den entsprechenden Typen finden Sie auf der Konzeptseite Rechnung.

Auswählen eines vordefinierten Modells

Sie sind hierbei nicht auf Rechnungen beschränkt, sondern können zwischen mehreren vordefinierten Modellen wählen, von denen jedes über eine Gruppe unterstützter Felder verfügt. Welches Modell für den Analysevorgang verwendet wird, hängt vom Typ des zu analysierenden Dokuments ab. Dies sind die vordefinierten Modelle, die vom Formularerkennungsdienst derzeit unterstützt werden:

Rechnung: Extrahieren von Text, Auswahlmarkierungen, Tabellen, Feldern und wichtigen Informationen aus Rechnungen
Beleg: Extrahieren von Text und wichtigen Informationen aus Belegen
Ausweisdokument: Extrahieren von Text und wichtigen Informationen aus Führerscheinen und Reisepässen
Visitenkarte: Extrahieren von Text und wichtigen Informationen aus Visitenkarten

Fügen Sie Ihrer vordefinierten Rechnungsanwendung unterhalb der Variablen `key` den folgenden Code hinzu:


def recognize_invoice():

    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

    form_recognizer_client = FormRecognizerClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = form_recognizer_client.begin_recognize_invoices_from_url(
        invoiceUrl, locale="en-US"
    )
    invoices = poller.result()

    for idx, invoice in enumerate(invoices):
        vendor_name = invoice.fields.get("VendorName")
        if vendor_name:
            print(
                "Vendor Name: {} has confidence: {}".format(
                    vendor_name.value, vendor_name.confidence
                )
            )
        vendor_address = invoice.fields.get("VendorAddress")
        if vendor_address:
            print(
                "Vendor Address: {} has confidence: {}".format(
                    vendor_address.value, vendor_address.confidence
                )
            )
        vendor_address_recipient = invoice.fields.get("VendorAddressRecipient")
        if vendor_address_recipient:
            print(
                "Vendor Address Recipient: {} has confidence: {}".format(
                    vendor_address_recipient.value, vendor_address_recipient.confidence
                )
            )
        customer_name = invoice.fields.get("CustomerName")
        if customer_name:
            print(
                "Customer Name: {} has confidence: {}".format(
                    customer_name.value, customer_name.confidence
                )
            )
        customer_id = invoice.fields.get("CustomerId")
        if customer_id:
            print(
                "Customer Id: {} has confidence: {}".format(
                    customer_id.value, customer_id.confidence
                )
            )
        customer_address = invoice.fields.get("CustomerAddress")
        if customer_address:
            print(
                "Customer Address: {} has confidence: {}".format(
                    customer_address.value, customer_address.confidence
                )
            )
        customer_address_recipient = invoice.fields.get("CustomerAddressRecipient")
        if customer_address_recipient:
            print(
                "Customer Address Recipient: {} has confidence: {}".format(
                    customer_address_recipient.value,
                    customer_address_recipient.confidence,
                )
            )
        invoice_id = invoice.fields.get("InvoiceId")
        if invoice_id:
            print(
                "Invoice Id: {} has confidence: {}".format(
                    invoice_id.value, invoice_id.confidence
                )
            )
        invoice_date = invoice.fields.get("InvoiceDate")
        if invoice_date:
            print(
                "Invoice Date: {} has confidence: {}".format(
                    invoice_date.value, invoice_date.confidence
                )
            )
        invoice_total = invoice.fields.get("InvoiceTotal")
        if invoice_total:
            print(
                "Invoice Total: {} has confidence: {}".format(
                    invoice_total.value, invoice_total.confidence
                )
            )
        due_date = invoice.fields.get("DueDate")
        if due_date:
            print(
                "Due Date: {} has confidence: {}".format(
                    due_date.value, due_date.confidence
                )
            )
        purchase_order = invoice.fields.get("PurchaseOrder")
        if purchase_order:
            print(
                "Purchase Order: {} has confidence: {}".format(
                    purchase_order.value, purchase_order.confidence
                )
            )
        billing_address = invoice.fields.get("BillingAddress")
        if billing_address:
            print(
                "Billing Address: {} has confidence: {}".format(
                    billing_address.value, billing_address.confidence
                )
            )
        billing_address_recipient = invoice.fields.get("BillingAddressRecipient")
        if billing_address_recipient:
            print(
                "Billing Address Recipient: {} has confidence: {}".format(
                    billing_address_recipient.value,
                    billing_address_recipient.confidence,
                )
            )
        shipping_address = invoice.fields.get("ShippingAddress")
        if shipping_address:
            print(
                "Shipping Address: {} has confidence: {}".format(
                    shipping_address.value, shipping_address.confidence
                )
            )
        shipping_address_recipient = invoice.fields.get("ShippingAddressRecipient")
        if shipping_address_recipient:
            print(
                "Shipping Address Recipient: {} has confidence: {}".format(
                    shipping_address_recipient.value,
                    shipping_address_recipient.confidence,
                )
            )
        print("Invoice items:")
        for idx, item in enumerate(invoice.fields.get("Items").value):
            item_description = item.value.get("Description")
            if item_description:
                print(
                    "......Description: {} has confidence: {}".format(
                        item_description.value, item_description.confidence
                    )
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    "......Quantity: {} has confidence: {}".format(
                        item_quantity.value, item_quantity.confidence
                    )
                )
            unit = item.value.get("Unit")
            if unit:
                print(
                    "......Unit: {} has confidence: {}".format(
                        unit.value, unit.confidence
                    )
                )
            unit_price = item.value.get("UnitPrice")
            if unit_price:
                print(
                    "......Unit Price: {} has confidence: {}".format(
                        unit_price.value, unit_price.confidence
                    )
                )
            product_code = item.value.get("ProductCode")
            if product_code:
                print(
                    "......Product Code: {} has confidence: {}".format(
                        product_code.value, product_code.confidence
                    )
                )
            item_date = item.value.get("Date")
            if item_date:
                print(
                    "......Date: {} has confidence: {}".format(
                        item_date.value, item_date.confidence
                    )
                )
            tax = item.value.get("Tax")
            if tax:
                print(
                    "......Tax: {} has confidence: {}".format(tax.value, tax.confidence)
                )
            amount = item.value.get("Amount")
            if amount:
                print(
                    "......Amount: {} has confidence: {}".format(
                        amount.value, amount.confidence
                    )
                )
        subtotal = invoice.fields.get("SubTotal")
        if subtotal:
            print(
                "Subtotal: {} has confidence: {}".format(
                    subtotal.value, subtotal.confidence
                )
            )
        total_tax = invoice.fields.get("TotalTax")
        if total_tax:
            print(
                "Total Tax: {} has confidence: {}".format(
                    total_tax.value, total_tax.confidence
                )
            )
        previous_unpaid_balance = invoice.fields.get("PreviousUnpaidBalance")
        if previous_unpaid_balance:
            print(
                "Previous Unpaid Balance: {} has confidence: {}".format(
                    previous_unpaid_balance.value, previous_unpaid_balance.confidence
                )
            )
        amount_due = invoice.fields.get("AmountDue")
        if amount_due:
            print(
                "Amount Due: {} has confidence: {}".format(
                    amount_due.value, amount_due.confidence
                )
            )
        service_start_date = invoice.fields.get("ServiceStartDate")
        if service_start_date:
            print(
                "Service Start Date: {} has confidence: {}".format(
                    service_start_date.value, service_start_date.confidence
                )
            )
        service_end_date = invoice.fields.get("ServiceEndDate")
        if service_end_date:
            print(
                "Service End Date: {} has confidence: {}".format(
                    service_end_date.value, service_end_date.confidence
                )
            )
        service_address = invoice.fields.get("ServiceAddress")
        if service_address:
            print(
                "Service Address: {} has confidence: {}".format(
                    service_address.value, service_address.confidence
                )
            )
        service_address_recipient = invoice.fields.get("ServiceAddressRecipient")
        if service_address_recipient:
            print(
                "Service Address Recipient: {} has confidence: {}".format(
                    service_address_recipient.value,
                    service_address_recipient.confidence,
                )
            )
        remittance_address = invoice.fields.get("RemittanceAddress")
        if remittance_address:
            print(
                "Remittance Address: {} has confidence: {}".format(
                    remittance_address.value, remittance_address.confidence
                )
            )
        remittance_address_recipient = invoice.fields.get("RemittanceAddressRecipient")
        if remittance_address_recipient:
            print(
                "Remittance Address Recipient: {} has confidence: {}".format(
                    remittance_address_recipient.value,
                    remittance_address_recipient.confidence,
                )
            )


if __name__ == "__main__":
    recognize_invoice()

Ausführen der Anwendung

Navigieren Sie zu dem Ordner, in dem Ihre Datei form_recognizer_quickstart.py enthalten ist.
Geben Sie in Ihrem Terminal den folgenden Befehl ein:

python form_recognizer_quickstart.py

| Formularerkennungs-REST-API | Formularerkennungs-REST-API |

In dieser Schnellstartanleitung verwenden Sie die folgenden APIs zum Extrahieren strukturierter Daten aus Formularen und Dokumenten:

Layout
Rechnung

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
cURL muss installiert sein.
PowerShell-Version 6.0 oder höher oder eine ähnliche Befehlszeilenanwendung
Eine Cognitive Services- oder Formularerkennungsressource. Wenn Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Formularerkennungsressource mit einem Dienst oder mehreren Diensten erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Tipp

Erstellen Sie eine Cognitive Services-Ressource, wenn Sie planen, über einen einzelnen Endpunkt bzw. Schlüssel auf mehrere Cognitive Services-Instanzen zuzugreifen. Erstellen Sie eine Formularerkennungsressource, falls nur auf die Formularerkennung zugegriffen werden soll. Beachten Sie hierbei, dass Sie eine Ressource mit einem einzelnen Dienst benötigen, falls Sie die Azure Active Directory-Authentifizierung nutzen möchten.
Wählen Sie nach der Bereitstellung der Ressource Zu Ressource wechseln aus. Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Formularerkennungs-API zu verbinden. Der Schlüssel und der Endpunkt werden später in der Schnellstartanleitung in den Code eingefügt.

Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in Ihre Anwendung aus:

Layout
Vordefinierte Rechnung

Wichtig

Try it (Ausprobieren): Layoutmodell

Für dieses Beispiel benötigen Sie eine Formulardokumentdatei unter einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.

Ersetzen Sie {endpoint} durch den Endpunkt, den Sie mit Ihrem Abonnement für die Formularerkennung erhalten haben.
Ersetzen Sie {key} durch den Schlüssel, den Sie im vorherigen Schritt kopiert haben.
Ersetzen Sie \"{your-document-url} durch die URL eines Beispieldokuments:

https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf

Anforderung

curl -v -i POST "https://{endpoint}/formrecognizer/v2.1/layout/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Operation-Location

Sie erhalten die Antwort 202 (Success) mit einem Operation-Location-Header. Der Wert dieses Headers enthält eine Ergebnis-ID, mit der Sie den Status des asynchronen Vorgangs abfragen und die Ergebnisse abrufen können:

https://cognitiveservice/formrecognizer/v2.1/layout/analyzeResults/ {resultId} .

Im folgenden Beispiel als Teil der URL ist die Zeichenfolge nach analyzeResults/ die Ergebnis-ID.

https://cognitiveservice/formrecognizer/v2/layout/analyzeResults/54f0b076-4e38-43e5-81bd-b85b8835fdfb

Abrufen von Layoutergebnissen

Nachdem Sie die Analyze Layout -API aufgerufen haben, rufen Sie die Get Analyze Layout Result -API auf, um den Status des Vorgangs und die extrahierten Daten abzurufen. Nehmen Sie die folgenden Änderungen vor, bevor Sie den Befehl ausführen:

Ersetzen Sie {endpoint} durch den Endpunkt, den Sie mit Ihrem Abonnement für die Formularerkennung erhalten haben.
Ersetzen Sie {key} durch den Schlüssel, den Sie im vorherigen Schritt kopiert haben.
Ersetzen Sie {resultId} durch die Ergebnis-ID aus dem vorherigen Schritt.

Anforderung

curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/layout/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"

Untersuchen der Ergebnisse

Sie erhalten die Antwort 200 (success) mit dem JSON-Inhalt.

Vergleichen Sie das folgende Bild einer Rechnung mit der entsprechenden JSON-Ausgabe.

Der Knoten "readResults" enthält jede Textzeile mit der Platzierung des zugehörigen Begrenzungsrahmens auf der Seite.
Der Knoten selectionMarks zeigt jede Auswahlmarkierung (Kontrollkästchen, Optionsfeld) und ihren Status („ausgewählt“ oder „nicht ausgewählt“).
Der Abschnitt "pageResults" enthält die extrahierten Tabellen. Für jede Tabelle werden der Text-, Zeilen- und Spaltenindex, die Zeilen- und Spaltenaufteilung, der Begrenzungsrahmen und mehr extrahiert.

Contoso-Projektangabedokument mit einer Tabelle

Antworttext

Sie können die vollständige Beispielausgabe auf GitHub anzeigen.

Probieren Sie es aus: Vordefiniertes Modell

In diesem Beispiel analysieren Sie ein Rechnungsdokument mithilfe eines vordefinierten Modells. Für diese Schnellstartanleitung können Sie unser Beispiel für ein Rechnungsdokument verwenden.

Auswählen eines vordefinierten Modells

Sie sind hierbei nicht auf Rechnungen beschränkt, sondern können zwischen mehreren vordefinierten Modellen wählen, von denen jedes über eine Gruppe unterstützter Felder verfügt. Welches Modell für den Analysevorgang verwendet wird, hängt vom Typ des zu analysierenden Dokuments ab. Dies sind die vordefinierten Modelle, die vom Formularerkennungsdienst derzeit unterstützt werden:

Rechnung: Extrahieren von Text, Auswahlmarkierungen, Tabellen, Feldern und wichtigen Informationen aus Rechnungen
Beleg: Extrahieren von Text und wichtigen Informationen aus Belegen
Ausweisdokument: Extrahieren von Text und wichtigen Informationen aus Führerscheinen und Reisepässen
Visitenkarte: Extrahieren von Text und wichtigen Informationen aus Visitenkarten

Nehmen Sie die folgenden Änderungen vor, bevor Sie den Befehl ausführen:

Ersetzen Sie {endpoint} durch den Endpunkt, den Sie mit Ihrem Abonnement für die Formularerkennung erhalten haben.
Ersetzen Sie {key} durch den Schlüssel, den Sie im vorherigen Schritt kopiert haben.

Ersetzen Sie \"{your-document-url} durch eine URL für ein Rechnungsbeispiel:

https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf

Anforderung

curl -v -i POST https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key:  {key}" --data-ascii "{'urlSource': '{your invoice URL}'}"

Operation-Location

https://cognitiveservice/formrecognizer/v2.1/prebuilt/receipt/analyzeResults/ {resultId}

Im folgenden Beispiel als Teil der URL ist die Zeichenfolge nach analyzeResults/ die Ergebnis-ID:

https://cognitiveservice/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/54f0b076-4e38-43e5-81bd-b85b8835fdfb

Abrufen von Rechnungsergebnissen

Nachdem Sie die Analyze Invoice-API aufgerufen haben, rufen Sie die Get Analyze Invoice Result -API auf, um den Status des Vorgangs und die extrahierten Daten abzurufen. Nehmen Sie die folgenden Änderungen vor, bevor Sie den Befehl ausführen:

Ersetzen Sie {endpoint} durch den Endpunkt, den Sie mit Ihrem Formularerkennungsschlüssel erhalten haben. Sie finden ihn auf der Registerkarte Übersicht der Formularerkennungsressource.
Ersetzen Sie {resultId} durch die Ergebnis-ID aus dem vorherigen Schritt.
Ersetzen Sie {key} durch Ihren Schlüssel.

Anforderung

curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"

Untersuchen der Antwort

Sie erhalten die Antwort 200 (Success) mit einer JSON-Ausgabe.

Das "readResults"-Feld enthält alle Textzeilen, die aus der Rechnung extrahiert wurden.
"pageResults" beinhaltet die Tabellen und Informationen zu den Auswahlkästchen, die aus der Rechnung extrahiert wurden.
Das "documentResults"-Feld enthält die Schlüssel-/Wertinformationen für die relevantesten Teile der Rechnung.

Weitere Informationen finden Sie im Dokument mit der Beispielrechnung.

Antworttext

Auf GitHub finden Sie die vollständige Beispielausgabe.

Das war's, herzlichen Glückwunsch! In diesem Schnellstart haben Sie Modelle für die Formularerkennung verwendet, um verschiedene Formulare auf unterschiedliche Weise zu analysieren.

Nächste Schritte

Testen Sie die Formularerkennung v3.0 Studio für eine verbesserte Benutzerfreundlichkeit und erweiterte Modellqualität.
v3.0 Studio unterstützt jedes Modell, das mit in v2.1 gekennzeichneten Daten trainiert wurde.
Ausführliche Informationen zum Migrieren von v2.1 zu v3.0 finden Sie im API-Migrationshandbuch.
Sehen Sie sich unsere SDK-Schnellstarts zur REST-API oder zu C#, Java, JavaScript oder Python an, um mit der Arbeit mit der Version v3.0 zu beginnen.

Erste Schritte mit der Formularerkennung

Voraussetzungen

Einrichten

Installieren der Clientbibliothek mit NuGet

Erstellen Ihrer Anwendung

Allgemeines Dokument-Modell

Ausgabe des allgemeinen Dokumentmodells

Layoutmodell

Ausgabe des Layoutmodells

Vordefiniertes Modell

Ausgabe des vordefinierten Modells

Voraussetzungen

Einrichten

Erstellen eines neuen Gradle-Projekts

Installieren der Clientbibliothek

Erstellen einer Java-Anwendung

Allgemeines Dokument-Modell

Ausgabe des allgemeinen Dokumentmodells

Layoutmodell

Ausgabe des Layoutmodells

Vordefiniertes Modell

Ausgabe des vordefinierten Modells

Voraussetzungen

Einrichten

Erstellen Ihrer Anwendung

Allgemeines Dokument-Modell

Ausgabe des allgemeinen Dokumentmodells

Layoutmodell

Ausgabe des Layoutmodells

Vordefiniertes Modell

Ausgabe des vordefinierten Modells

Voraussetzungen

Einrichten

Erstellen Ihrer Python-Anwendung

Allgemeines Dokument-Modell

Ausgabe des allgemeinen Dokumentmodells

Layoutmodell

Ausgabe des Layoutmodells

Vordefiniertes Modell

Ausgabe des vordefinierten Modells

Voraussetzungen

Analysieren von Dokumenten und Erhalten von Ergebnissen

Analysieren eines Dokuments (POST-Anforderung)

POST-Anforderung

POST-Antwort

Abrufen von Analyseergebnissen (GET-Anforderung)

GET-Anforderung

Untersuchen der Antwort

Beispielantwort für „prebuilt-invoice“

Unterstützte Dokumentfelder

Nächste Schritte

Voraussetzungen

Einrichten

Installieren der Clientbibliothek mit NuGet

Erstellen Ihrer Anwendung

Try it (Ausprobieren): Layoutmodell

Fügen Sie der Datei „Program.cs“ für Ihre Layoutanwendung den folgenden Code hinzu:

Probieren Sie es aus: Vordefiniertes Modell

Auswählen eines vordefinierten Modells

Fügen Sie den folgenden Code zu Ihrer vordefinierten Methode für die Rechnungsanwendung der Datei „Program.cs“ hinzu.

Ausführen der Anwendung

Voraussetzungen

Einrichten

Erstellen eines neuen Gradle-Projekts

Installieren der Clientbibliothek

Erstellen einer Java-Datei

Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in die main-Methode Ihrer Anwendung aus:

Try it (Ausprobieren): Layoutmodell

Probieren Sie es aus: Vordefiniertes Modell

Auswählen eines vordefinierten Modells

Erstellen und Ausführen der Anwendung

Voraussetzungen

Einrichten

Wählen Sie ein Codebeispiel zum Kopieren und Einfügen in Ihre Anwendung aus:

Try it (Ausprobieren): Layoutmodell

Fügen Sie Ihrer Layoutanwendung in der Zeile unterhalb der Variablen key den folgenden Code hinzu:

Probieren Sie es aus: Vordefiniertes Modell

Auswählen eines vordefinierten Modells

Fügen Sie Ihrer vordefinierten Rechnungsanwendung unterhalb der Variablen key den folgenden Code hinzu:

Voraussetzungen

Fügen Sie Ihrer Layoutanwendung in der Zeile unterhalb der Variablen `key` den folgenden Code hinzu:

Fügen Sie Ihrer vordefinierten Rechnungsanwendung unterhalb der Variablen `key` den folgenden Code hinzu:

Fügen Sie Ihrer Layoutanwendung in der Zeile unterhalb der Variablen `key` den folgenden Code hinzu:

Fügen Sie Ihrer vordefinierten Rechnungsanwendung unterhalb der Variablen `key` den folgenden Code hinzu: