Verwenden des Lesemodells

In dieser Schrittanleitung erfahren Sie, wie Sie das Lesemodell der Azure Formularerkennung verwenden, um gedruckten und handschriftlichen Text aus Dokumenten zu extrahieren. Das Lesemodell kann Zeilen, Wörter, Orte und Sprachen erkennen. Sie können eine Programmiersprache Ihrer Wahl oder die REST-API verwenden. 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.

Das Lesemodell ist der Kern aller anderen Formularerkennungsmodelle. Das Layoutmodell, das allgemeine Dokumentmodell sowie benutzerdefinierte und vordefinierte Modelle verwenden das Lesemodell als Grundlage für die Extraktion von Text aus Dokumenten.

Die aktuelle API-Version ist 2022-08-31.

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

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 weiter unten in der Schnellstartanleitung in den Code eingefügt:

    Screenshot: Schlüssel und Endpunktspeicherort im Azure-Portal

Einrichten

  1. Starten Sie Visual Studio.

  2. Wählen Sie auf der Startseite Neues Projekt erstellen aus.

    Screenshot: Visual Studio-Startfenster

  3. Geben Sie auf der Seite Neues Projekt erstellen im Suchfeld den Suchbegriff Konsole ein. Wählen Sie die Vorlage Konsolenanwendung und dann Weiter aus.

    Screenshot: Visual Studio's Seite

  4. 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.

    Screenshot: Das Dialogfenster von Visual Studio zum Konfigurieren eines neuen Projekts.

  5. Wählen Sie im Dialogfenster Zusätzliche Informationen die Option .NET 6.0 (Langzeitunterstützung), und wählen Sie dann Erstellen.

    Screenshot: Das Dialogfenster für zusätzliche Informationen von Visual Studio.

Installieren der Clientbibliothek mit NuGet

  1. Klicken Sie mit der rechten Maustaste auf das Projekt formRecognizer_quickstart, und wählen Sie die Option NuGet-Pakete verwalten... aus.

    Screenshot: Fenster zum Auswählen des NuGet-Pakets in Visual Studio

  2. Wählen Sie die Registerkarte „Durchsuchen“ aus, und geben Sie „Azure.AI.FormRecognizer“ ein.

    Screenshot: Auswählen eines NuGet-Vorabversionspakets in Visual Studio

  3. Wählen Sie im Dropdownmenü Version 4.0.0 aus, und installieren Sie das Paket in Ihrem Projekt.

Lesemodell

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 im Azure-Portal sowie eine DocumentAnalysisClient-Instanz mit dem AzureKeyCredential-Element und dem endpoint Ihrer Formularerkennung.

Hinweis

  • Ab .NET 6 erzeugen neue Projekte, die die console-Vorlage verwenden, anderen Code als frühere Versionen.
  • Die neue Ausgabe verwendet aktuelle C#-Features, die den Code vereinfachen, den Sie für ein Programm schreiben müssen.
  • Wenn Sie die neuere Version verwenden, müssen Sie nur den Text der Main-Methode schreiben. Sie müssen die anderen Programmelemente nicht einbeziehen.
  • Weitere Informationen finden Sie unter sieheNeue C#-Schablonen erzeugen Top-Level-Anweisungen.
  • 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-read als Modell-ID. Der zurückgegebene Wert ist ein AnalyzeResult-Objekt mit Daten aus dem übermittelten Dokument.
  1. Öffnen Sie die Datei Program.cs.

  2. Löschen Sie den bereits vorhandenen Code, einschließlich der Zeile Console.Writeline("Hello World!"), und kopieren Sie den folgenden Beispielcode in Ihre Anwendung. 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 document
Uri fileUri = new Uri("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-read", 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),");

    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 polygon 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}");
    }
}

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("Detected languages:");

foreach (DocumentLanguage language in result.Languages)
{
    Console.WriteLine($"  Found language with locale'{language.Locale}' with confidence {language.Confidence}.");
}

Wichtig

  • Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie in der Produktionsumgebung sichere Methoden, um Ihre Anmeldeinformationen zu speichern und darauf zuzugreifen. Weitere Informationen finden Sie unter Sicherheit von Cognitive Services.
  1. 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

Ausgabe des Lesemodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Document Page 1 has 86 line(s), 697 word(s),
  Line 0 has content: 'While healthcare is still in the early stages of its Al journey, we'.
    Its bounding box is:
      Upper left => X: 259, Y= 55
      Upper right => X: 816, Y= 56
      Lower right => X: 816, Y= 79
      Lower left => X: 259, Y= 77
.
.
.
  Found language 'en' with confidence 0.95.

Um die gesamte Ausgabe anzuzeigen, navigieren Sie zum Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Lesemodells anzuzeigen.

Nächster Schritt

Testen Sie das Layoutmodell, das Auswahlzeichen und Tabellenstrukturen extrahieren kann, zusätzlich zu dem, was das Lesemodell bietet.

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

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 diese Nicht-VS Code, stellen Sie sicher, dass Folgendes in Ihrer Entwicklungsumgebung installiert ist:

  • 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 weiter unten in den Code eingefügt.

    Screenshot: Schlüssel und Endpunktspeicherort im Azure-Portal

Einrichten

Erstellen eines neuen Gradle-Projekts

  1. 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
    
  2. Führen Sie den Befehl gradle init in Ihrem Arbeitsverzeichnis aus. Mit diesem Befehl werden grundlegende Builddateien für Gradle, u. a. die Datei build.gradle.kts, erstellt. Diese Datei wird zur Laufzeit zum Erstellen und Konfigurieren Ihrer Anwendung verwendet.

    gradle init --type basic
    
  3. Wenn Sie zur Auswahl einer DSL aufgefordert werden, wählen Sie Kotlin aus.

  4. Ü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.

  1. Ö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")
    }
    

Erstellen einer Java-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 im Azure-Portal sowie eine DocumentAnalysisClient-Instanz mit dem AzureKeyCredential-Element und dem endpoint Ihrer Formularerkennung.

  1. Führen Sie im Verzeichnis form-recognizer-app den folgenden Befehl aus:

    mkdir -p src/main/java
    

    Sie erstellen die folgende Verzeichnisstruktur:

    Screenshot: Java-Verzeichnisstruktur

  2. 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:

Lesemodell

  • 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-read 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.
  1. Öffnen Sie die Datei FormRecognizer.java, und kopieren Sie das folgende Codebeispiel in Ihre Anwendung. 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/rest-api/read.png";

        String modelId = "prebuilt-read";

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

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie in der Produktionsumgebung sichere Methoden, um Ihre Anmeldeinformationen zu speichern und darauf zuzugreifen. Weitere Informationen finden Sie im Artikel zur Sicherheit von Cognitive Services.

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

  2. Erstellen Sie Ihre Anwendung mit dem Befehl build:

    gradle build
    
  3. Führen Sie Ihre Anwendung mit dem Befehl run aus:

    gradle run
    

Ausgabe des Lesemodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Page has width: 915.00 and height: 1190.00, measured with unit: pixel
Line While healthcare is still in the early stages of its Al journey, we is within a bounding box [259.0, 55.0, 816.0, 56.0, 816.0, 79.0, 259.0, 77.0].
Line are seeing pharmaceutical and other life sciences organizations is within a bounding box [258.0, 83.0, 825.0, 83.0, 825.0, 106.0, 258.0, 106.0].
Line making major investments in Al and related technologies." is within a bounding box [259.0, 112.0, 784.0, 112.0, 784.0, 136.0, 259.0, 136.0].
.
.
.
Word 'While' has a confidence score of 1.00.
Word 'healthcare' has a confidence score of 1.00.
Word 'is' has a confidence score of 1.00.

Um die gesamte Ausgabe anzuzeigen, navigieren Sie zum Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Lesemodells anzuzeigen.

Nächster Schritt

Testen Sie das Layoutmodell, das Auswahlzeichen und Tabellenstrukturen extrahieren kann, zusätzlich zu dem, was das Lesemodell bietet.

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

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 weiter unten in der Schnellstartanleitung in den Code eingefügt:

    Screenshot: Schlüssel und Endpunktspeicherort im Azure-Portal

Einrichten

  1. Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es form-recognizer-appauf.

    mkdir form-recognizer-app && cd form-recognizer-app
    
  2. Führen Sie den npm init Befehl aus, um die Anwendung zu initialisieren und ihr Projekt zu gerüsten.

    npm init
    
  3. 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.
  4. 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.
  5. 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:

Lesemodell

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 im Azure-Portal sowie eine DocumentAnalysisClient-Instanz mit dem AzureKeyCredential-Element und dem endpoint Ihrer Formularerkennung.

  • 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-read als Modell-ID.
  1. Öffnen Sie die Datei index.js in Visual Studio Code oder Ihrer bevorzugten IDE, und kopieren Sie das folgende Codebeispiel in Ihre Anwendung. 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");
 
function* getTextOfSpans(content, spans) {
  for (const span of spans) {
    yield content.slice(span.offset, span.offset + span.length);
  }
}

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

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

async function main() {
  // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
  const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));
  const poller = await client.beginAnalyzeDocument("prebuilt-read", formUrlRead);

  const { content, pages, languages, styles } = 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 (page.lines.length > 0) {
        console.log("  Lines:");

        for (const line of page.lines) {
          console.log(`  - "${line.content}"`);

          // The words of the line can also be iterated independently. The words are computed based on their
          // corresponding spans.
          for (const word of line.words()) {
            console.log(`    - "${word.content}"`);
          }
        }
      }
    }
  }

  if (languages.length <= 0) {
    console.log("No language spans were extracted from the document.");
  } else {
    console.log("Languages:");
    for (const languageEntry of languages) {
      console.log(
        `- Found language: ${languageEntry.languageCode} (confidence: ${languageEntry.confidence})`
      );
      for (const text of getTextOfSpans(content, languageEntry.spans)) {
        const escapedText = text.replace(/\r?\n/g, "\\n").replace(/"/g, '\\"');
        console.log(`  - "${escapedText}"`);
      }
    }
  }

  if (styles.length <= 0) {
    console.log("No text styles were extracted from the document.");
  } else {
    console.log("Styles:");
    for (const style of styles) {
      console.log(
        `- Handwritten: ${style.isHandwritten ? "yes" : "no"} (confidence=${style.confidence})`
      );

      for (const word of getTextOfSpans(content, style.spans)) {
        console.log(`  - "${word}"`);
      }
    }
  }
}

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

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie in der Produktionsumgebung sichere Methoden, um Ihre Anmeldeinformationen zu speichern und darauf zuzugreifen. Weitere Informationen finden Sie im Artikel zur Sicherheit von Cognitive Services.

  1. Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, navigieren Sie zu dem Ordner mit Ihrer Formularerkennungsanwendung (form-recognizer-app).

  2. Geben Sie in Ihrem Terminal den folgenden Befehl ein:

    node index.js
    

Ausgabe des Lesemodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Pages:
- Page 1 (unit: pixel)
  915x1190, angle: 0
  86 lines, 697 words
  Lines:
  - "While healthcare is still in the early stages of its Al journey, we"
    - "While"
    - "healthcare"
    - "is"
.
.
.
Languages:
- Found language: en (confidence: 0.95)
  - "While healthcare is still in the early stages of its Al journey, we\nare seeing pharmaceutical and other life sciences organizations"
  - "As pharmaceutical and other life sciences organizations invest\nin and deploy advanced technologies, they are beginning to see"
  - "are looking to incorporate automation and continuing smart"
.
.
.
No text styles were extracted from the document.

Um die gesamte Ausgabe anzuzeigen, navigieren Sie zum Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Lesemodells anzuzeigen.

Nächster Schritt

Testen Sie das Layoutmodell, das Auswahlzeichen und Tabellenstrukturen extrahieren kann, zusätzlich zu dem, was das Lesemodell bietet.

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

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 unter Erste Schritte mit Python in VS 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

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 weiter unten in der Schnellstartanleitung in den Code eingefügt:

    Screenshot: Schlüssel und Endpunktspeicherort im Azure-Portal

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

Lesemodell

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 im Azure-Portal sowie eine DocumentAnalysisClient-Instanz mit dem AzureKeyCredential-Element und dem endpoint Ihrer Formularerkennung.

  • 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_read hinzugefügt.
  • Um eine bestimmte Datei unter einer URL zu analysieren, verwenden Sie die Methode begin_analyze_document_from_url und geben prebuilt-read als Modell-ID an. Der Rückgabewert ist ein result Objekt, das Daten über das übermittelte Dokument enthält.
  1. Erstellen Sie eine neue Python-Datei namens form_recognizer_quickstart.py in Ihrem bevorzugten Editor oder IDE.

  2. Öffnen Sie die Datei form_recognizer_quickstart.py, und kopieren Sie das folgende Codebeispiel in Ihre Anwendung. 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_box(bounding_box):
    if not bounding_box:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in bounding_box])

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

    # 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-read", formUrl)
    result = poller.result()

    print ("Document contains content: ", result.content)
    
    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 Read 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_bounding_box(line.bounding_box),
                )
            )

        for word in page.words:
            print(
                "...Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

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


if __name__ == "__main__":
    analyze_read()

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie in der Produktionsumgebung sichere Methoden, um Ihre Anmeldeinformationen zu speichern und darauf zuzugreifen. Weitere Informationen finden Sie unter Sicherheit von Cognitive Services.

  1. Nachdem Sie Ihrer Anwendung ein Codebeispiel hinzugefügt haben, navigieren Sie zu dem Ordner mit Ihrer Datei form_recognizer_quickstart.py.

  2. Geben Sie in Ihrem Terminal den folgenden Befehl ein:

    python form_recognizer_quickstart.py
    

Ausgabe des Lesemodells

Hier sehen Sie einen Codeausschnitt der erwarteten Ausgabe:

Document contains content:  While healthcare is still in the early stages of its Al journey, we
are seeing pharmaceutical and other life sciences organizations
making major investments in Al and related technologies."
.
.
.
----Analyzing Read from page #1----
Page has width: 915.0 and height: 1190.0, measured with unit: pixel
...Line # 0 has text content 'While healthcare is still in the early stages of its Al journey, we' within bounding box '[259.0, 55.0], [816.0, 56.0], [816.0, 79.0], [259.0, 77.0]'
...Line # 1 has text content 'are seeing pharmaceutical and other life sciences organizations' within bounding box '[258.0, 83.0], [825.0, 83.0], [825.0, 106.0], [258.0, 106.0]'
...Line # 2 has text content 'making major investments in Al and related technologies."' within bounding box '[259.0, 112.0], [784.0, 112.0], [784.0, 136.0], [259.0, 136.0]'
.
.
.
...Word 'While' has a confidence of 0.999
...Word 'healthcare' has a confidence of 0.995
...Word 'is' has a confidence of 0.997

Um die gesamte Ausgabe anzuzeigen, navigieren Sie zum Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Lesemodells anzuzeigen.

Nächster Schritt

Testen Sie das Layoutmodell, das Auswahlzeichen und Tabellenstrukturen extrahieren kann, zusätzlich zu dem, was das Lesemodell bietet.

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos

  • cURL muss installiert sein.

  • PowerShell ab Version 7.* oder eine ähnliche Befehlszeilenanwendung. Geben Sie Get-Host | Select-Object Version ein, um Ihre PowerShell-Version zu überprüfen.

  • 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 weiter unten in der Schnellstartanleitung in den Code eingefügt:

    Screenshot: Schlüssel und Endpunktspeicherort im Azure-Portal

Lesemodell

Die Formularerkennung v3.0 konsolidiert die Anforderungen zum Analysieren von Dokumenten (POST) und zum Erhalten von Ergebnisanforderungen (GET) in einzelnen Vorgängen. Die modelId wird für POST- und die resultId für GET-Vorgänge verwendet.

  • Für dieses Beispiel benötigen Sie eine Formulardokument-Datei von einem URI. Sie können für diese Schnellstartanleitung unser Beispielformulardokument verwenden.
  • Der Wert des Datei-URI wurde dem folgenden cURL-Befehl POST hinzugefügt.

POST-Anforderung

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

  1. Ersetzen Sie {endpoint} durch den Endpunktwert aus Ihrer Formularerkennung-Instanz im Azure-Portal.
  2. Ersetzen Sie {key} durch den Schlüssel aus Ihrer Formularerkennung-Instanz im Azure-Portal.
curl -v -i POST "{endpoint}/formrecognizer/documentModels/prebuilt-read:analyze?api-version=2022-08-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png'}"

Operation-Location

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 Anforderungen

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:

  1. Ersetzen Sie {endpoint} durch den Endpunktwert aus Ihrer Formularerkennung-Instanz im Azure-Portal.
  2. Ersetzen Sie {key} durch den Schlüssel aus Ihrer Formularerkennung-Instanz im Azure-Portal.
  3. Ersetzen Sie {resultID} durch die Ergebnis-ID aus dem Operation-Location-Header.
curl -v -X GET "{endpoint}/formrecognizer/documentModels/prebuilt-read/analyzeResults/{resultId}?api-version=2022-08-31" -H "Ocp-Apim-Subscription-Key: {key}"

Ausgabe des Lesemodells

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

{
    "status": "succeeded",
    "createdDateTime": "2022-04-08T00:36:48Z",
    "lastUpdatedDateTime": "2022-04-08T00:36:50Z",
    "analyzeResult": {
        "apiVersion": "2022-08-31",
        "modelId": "prebuilt-read",
        "stringIndexType": "textElements",
        "content": "While healthcare is still in the early stages of its Al journey, we\nare seeing...",
        "pages": [
            {
                "pageNumber": 1,
                "angle": 0,
                "width": 915,
                "height": 1190,
                "unit": "pixel",
                "words": [
                    {
                        "content": "While",
                        "boundingBox": [
                            260,
                            56,
                            307,
                            56,
                            306,
                            76,
                            260,
                            76
                        ],
                        "confidence": 0.999,
                        "span": {
                            "offset": 0,
                            "length": 5
                        }
                    }
                ]
            }
        ]
    }
}

Um die gesamte Ausgabe anzuzeigen, navigieren Sie zum Repository mit Azure-Beispielen auf GitHub, um die Ausgabe des Lesemodells anzuzeigen.

Nächster Schritt

Testen Sie das Layoutmodell, das Auswahlzeichen und Tabellenstrukturen extrahieren kann, zusätzlich zu dem, was das Lesemodell bietet.