Enterprise Document OCR

Sie können Enterprise Document OCR als Teil von Document AI verwenden, um Text und Layoutinformationen aus verschiedenen Dokumenten zu erkennen und zu extrahieren. Mit konfigurierbaren Funktionen können Sie das System an bestimmte Anforderungen der Dokumentverarbeitung anpassen.

Übersicht

Sie können Enterprise Document OCR für Aufgaben wie die Dateneingabe auf der Grundlage von Algorithmen oder maschinellem Lernen sowie für die Verbesserung und Überprüfung der Datenrichtigkeit verwenden. Sie können Enterprise Document OCR auch für Aufgaben wie die folgenden verwenden:

  • Text digitalisieren:Text- und Layoutdaten aus Dokumenten für Suchanfragen, regelbasierte Pipelines zur Dokumentverarbeitung oder zum Erstellen benutzerdefinierter Modelle extrahieren.
  • Anwendungen für Large Language Models verwenden:Mit dem Kontextverständnis von LLMs und den Text- und Layoutextraktionsfunktionen von OCR können Sie Fragen und Antworten automatisieren. Gewinnen Sie Erkenntnisse aus Daten und optimieren Sie Workflows.
  • Archivierung: Papierdokumente in maschinenlesbaren Text digitalisieren, um die Barrierefreiheit von Dokumenten zu verbessern.

Die beste OCR für Ihren Anwendungsfall auswählen

Lösung Produkt Beschreibung Anwendungsfall
Document AI Enterprise Document OCR Spezielles Modell für Anwendungsfälle im Bereich Dokumente. Zu den erweiterten Funktionen gehören der Qualitätsfaktor für Bilder, Sprachhinweise und die Drehkorrektur. Empfohlen, wenn Text aus Dokumenten extrahiert werden soll. Anwendungsfälle sind z. B. PDFs, gescannte Dokumente als Bilder oder Microsoft DocX-Dateien.
Document AI OCR-Add-ons Premium-Funktionen für bestimmte Anforderungen Nur mit Enterprise Document OCR Version 2.0 und höher kompatibel. Sie müssen mathematische Formeln erkennen, Informationen zur Schriftart erhalten oder die Auslösung von Kästchen aktivieren.
Cloud Vision API Texterkennung Global verfügbare REST API, die auf dem Standard-OCR-Modell von Google Cloud basiert. Das Standardkontingent beträgt 1.800 Anfragen pro Minute. Allgemeine Anwendungsfälle für die Textextraktion, die eine niedrige Latenz und eine hohe Kapazität erfordern.
Cloud Vision OCR Google Distributed Cloud (nicht mehr unterstützt) Google Cloud Marketplace-Anwendung, die als Container in jedem GKE-Cluster bereitgestellt werden kann, der GKE Enterprise verwendet. Um die Anforderungen an den Datenstandort oder die Compliance zu erfüllen.

Erkennung und Extraktion

Mit der Enterprise Document OCR können Blöcke, Absätze, Zeilen, Wörter und Symbole aus PDFs und Bildern erkannt sowie Dokumente zur Verbesserung der Genauigkeit entschränkt werden.

Unterstützte Attribute für die Layouterkennung und -extraktion:

Gedruckter Text Handschrift Absatz Blockieren Linie Wortmarke Symbolebene Seitennummer
Standard Standard Standard Standard Standard Standard Konfigurierbar Standard

Zu den konfigurierbaren Funktionen von Enterprise Document OCR gehören:

  • Eingebetteten oder nativen Text aus digitalen PDFs extrahieren:Mit dieser Funktion werden Text und Symbole genau so extrahiert, wie sie in den Quelldokumenten erscheinen, auch bei gedrehtem Text, extremen Schriftgrößen oder -stilen und teilweise ausgeblendetem Text.

  • Rotationskorrektur:Verwenden Sie Enterprise Document OCR, um Dokumentbilder vorzuverarbeiten und Rotationsprobleme zu korrigieren, die sich auf die Extraktionsqualität oder -verarbeitung auswirken können.

  • Bildqualitätsbewertung:Sie erhalten Qualitätsmesswerte, die beim Dokumenten-Routing helfen können. Der Bewertung der Bildqualität enthält Qualitätsmesswerte auf Seitenebene in acht Dimensionen, darunter Unschärfe, Schriftarten, die kleiner als üblich sind, und Blendeffekte.

  • Seitenbereich angeben:Gibt den Bereich der Seiten in einem Eingabedokument für die OCR an. So werden Ausgaben und Verarbeitungszeit für nicht benötigte Seiten gespart.

  • Spracherkennung:Hiermit werden die Sprachen erkannt, die in den extrahierten Texten verwendet werden.

  • Sprach- und Handschrifthinweise:Sie können die Genauigkeit verbessern, indem Sie dem OCR-Modell einen Sprach- oder Handschrifthinweis basierend auf den bekannten Merkmalen Ihrer Datasets zur Verfügung stellen.

Informationen zum Aktivieren von OCR-Konfigurationen finden Sie unter OCR-Konfigurationen aktivieren.

OCR-Add-ons

Enterprise Document OCR bietet optionale Analysefunktionen, die bei Bedarf für einzelne Verarbeitungsanfragen aktiviert werden können.

Die folgenden Add-on-Funktionen sind für die stabile Versionpretrained-ocr-v2.0-2023-06-02 und die Release-Kandidatenversionpretrained-ocr-v2.1-2024-08-07 verfügbar:

  • Mathematische OCR: Formeln aus Dokumenten im LaTeX-Format erkennen und extrahieren.
  • Kästchenextraktion: In der OCR-Antwort für Enterprise-Dokumente werden Kästchen erkannt und ihr Status (angeklickt/nicht angeklickt) extrahiert.
  • Schriftstilerkennung: Erkennen von Schrifteigenschaften auf Wortebene, einschließlich Schriftart, Schriftstil, Handschrift, Stärke und Farbe.

Informationen zum Aktivieren der aufgeführten Add-ons finden Sie unter OCR-Add-ons aktivieren.

Unterstützte Dateiformate

Die OCR-Funktion für Dokumente im Enterprise-Tarif unterstützt die Dateiformate PDF, GIF, TIFF, JPEG, PNG, BMP und WebP. Weitere Informationen finden Sie unter Unterstützte Dateien.

Enterprise Document OCR unterstützt auch DocX-Dateien mit bis zu 15 Seiten synchron und 30 Seiten asynchron. Die Unterstützung von DocX befindet sich in der privaten Vorschau. Wenn Sie Zugriff anfordern möchten, reichen Sie das Antragsformular für den DocX-Support ein .

Erweiterte Versionsverwaltung

Die erweiterte Versionierung befindet sich in der Vorabversion. Upgrades an den zugrunde liegenden KI-/ML-OCR-Modellen können zu Änderungen am OCR-Verhalten führen. Wenn eine strenge Konsistenz erforderlich ist, verwenden Sie eine eingefrorene Modellversion, um das Verhalten für bis zu 18 Monate an ein älteres OCR-Modell anzupinnen. So wird sichergestellt, dass für die OCR-Funktion immer dasselbe Bild verwendet wird. Weitere Informationen finden Sie in der Tabelle zu Prozessorversionen.

Prozessorversionen

Die folgenden Prozessorversionen sind mit dieser Funktion kompatibel. Weitere Informationen finden Sie unter Prozessorversionen verwalten.

Versions-ID Release-Version Beschreibung
pretrained-ocr-v1.0-2020-09-23 Stabile Version Die Verwendung wird nicht empfohlen und die Funktion wird ab dem 30. April 2025 in den USA und der EU eingestellt.
pretrained-ocr-v1.1-2022-09-12 Stabile Version Die Verwendung wird nicht empfohlen und die Funktion wird ab dem 30. April 2025 in den USA und der EU eingestellt.
pretrained-ocr-v1.2-2022-11-10 Stabile Version Eingefrorene Modellversion von Version 1.0: Modelldateien, Konfigurationen und Binärdateien eines Versions-Snapshots, die bis zu 18 Monate lang in einem Container-Image eingefroren sind.
pretrained-ocr-v2.0-2023-06-02 Stabile Version Produktionsreifes Modell, das speziell für Anwendungsfälle mit Dokumenten entwickelt wurde. Beinhaltet Zugriff auf alle OCR-Add-ons.
pretrained-ocr-v2.1-2024-08-07 Release-Kandidat Die wichtigsten Verbesserungen in Version 2.1 sind: bessere Erkennung von gedrucktem Text, präzisere Kästchenerkennung und genauere Lesereihenfolge.

Dokumente mit Enterprise Document OCR verarbeiten

In dieser Kurzanleitung wird die OCR für Enterprise-Dokumente vorgestellt. Dort erfahren Sie, wie Sie die OCR-Ergebnisse für Ihr Dokument für Ihren Workflow optimieren, indem Sie eine der verfügbaren OCR-Konfigurationen aktivieren oder deaktivieren.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Document AI API.

    Enable the API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Document AI API.

    Enable the API

    8.

Enterprise Document OCR-Prozessor erstellen

Erstellen Sie zuerst einen Enterprise Document OCR-Prozessor. Weitere Informationen finden Sie unter Prozessoren erstellen und verwalten.

OCR-Konfigurationen

Alle OCR-Konfigurationen können aktiviert werden, indem Sie die entsprechenden Felder in ProcessOptions.ocrConfig in ProcessDocumentRequest oder BatchProcessDocumentsRequest festlegen.

Weitere Informationen finden Sie unter Antrag auf Verarbeitung senden.

Analyse der Bildqualität

Bei der intelligenten Analyse der Dokumentqualität wird maschinelles Lernen verwendet, um die Qualität eines Dokuments anhand der Lesbarkeit des Inhalts zu bewerten. Diese Qualitätsbewertung wird als Qualitätsfaktor [0, 1] zurückgegeben, wobei 1 für eine perfekte Qualität steht. Wenn der erkannte Qualitätsfaktor unter 0.5 liegt, wird auch eine Liste mit Gründen für die schlechte Qualität zurückgegeben, sortiert nach Wahrscheinlichkeit. Eine Wahrscheinlichkeit von über 0.5 gilt als positive Erkennung.

Wenn das Dokument als fehlerhaft eingestuft wird, gibt die API die folgenden acht Arten von Dokumentfehlern zurück:

  • quality/defect_blurry
  • quality/defect_noisy
  • quality/defect_dark
  • quality/defect_faint
  • quality/defect_text_too_small
  • quality/defect_document_cutoff
  • quality/defect_text_cutoff
  • quality/defect_glare

Die aktuelle Analyse der Dokumentqualität hat einige Einschränkungen:

  • Es kann fälschlicherweise Fehler in digitalen Dokumenten erkennen, die keine Mängel aufweisen. Die Funktion eignet sich am besten für gescannte oder fotografierte Dokumente.

  • Blendeffekte sind lokal. Ihre Anwesenheit beeinträchtigt möglicherweise nicht die Lesbarkeit des Dokuments insgesamt.

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.enableImageQualityScores auf true setzen. Diese zusätzliche Funktion erhöht die Latenz des Prozessaufrufs im Vergleich zur OCR-Verarbeitung.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableImageQualityScores": true
      }
    }
  }

Ausgabe

Die Ergebnisse der Mängelerkennung werden in Document.pages[].imageQualityScores[] angezeigt.

  {
    "pages": [
      {
        "imageQualityScores": {
          "qualityScore": 0.7811847,
          "detectedDefects": [
            {
              "type": "quality/defect_document_cutoff",
              "confidence": 1.0
            },
            {
              "type": "quality/defect_glare",
              "confidence": 0.97849524
            },
            {
              "type": "quality/defect_text_cutoff",
              "confidence": 0.5
            }
          ]
        }
      }
    ]
  }

Vollständige Ausgabebeispiele finden Sie unter Beispiel für Prozessorausgabe.

Sprachhinweise

Der OCR-Prozessor unterstützt Sprachhinweise, die Sie definieren, um die Leistung der OCR-Engine zu verbessern. Wenn Sie einen Sprachhinweis anwenden, kann die OCR für eine ausgewählte Sprache statt für eine abgeleitete Sprache optimiert werden.

Eingabe

Aktivieren Sie diese Funktion, indem Sie ProcessOptions.ocrConfig.hints[].languageHints[] mit einer Liste von BCP-47-Sprachcodes festlegen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "hints": {
          "languageHints": ["en", "es"]
        }
      }
    }
  }

Vollständige Ausgabebeispiele finden Sie unter Beispiel für Prozessorausgabe.

Symbolerkennung

Fügen Sie Daten auf Symbol- oder Buchstabenebene in die Antwort des Dokuments ein.

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.enableSymbol auf true setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableSymbol": true
      }
    }
  }

Ausgabe

Wenn diese Funktion aktiviert ist, wird das Feld Document.pages[].symbols[] ausgefüllt.

Vollständige Ausgabebeispiele finden Sie unter Beispiel für Prozessorausgabe.

Integriertes PDF-Parsen

Eingebetteten Text aus digitalen PDF-Dateien extrahieren Wenn diese Option aktiviert ist und digitaler Text vorhanden ist, wird automatisch das integrierte digitale PDF-Modell verwendet. Wenn es sich um nicht digitalen Text handelt, wird automatisch das optische OCR-Modell verwendet. Der Nutzer erhält beide Textergebnisse zusammengeführt.

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.enableNativePdfParsing auf true setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableNativePdfParsing": true
      }
    }
  }

Erkennung von Personen im Feld

Standardmäßig ist bei Enterprise Document OCR ein Detektor aktiviert, um die Qualität der Textextraktion von Zeichen in einem Feld zu verbessern. Hier ein Beispiel:

enterprise-document-ocr-1

Wenn bei der OCR-Qualität Probleme mit Zeichen in Kästen auftreten, können Sie diese Option deaktivieren.

Eingabe

Deaktivieren Sie die Funktion, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.disableCharacterBoxesDetection auf true setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "disableCharacterBoxesDetection": true
      }
    }
  }

Altes Layout

Wenn Sie einen heuristischen Algorithmus zur Layouterkennung benötigen, können Sie das alte Layout aktivieren. Es dient als Alternative zum aktuellen ML-basierten Algorithmus zur Layouterkennung. Dies ist nicht die empfohlene Konfiguration. Kunden können den am besten geeigneten Layoutalgorithmus basierend auf ihrem Dokumentenworkflow auswählen.

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.advancedOcrOptions auf ["legacy_layout"] setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "advancedOcrOptions": ["legacy_layout"]
      }
    }
  }

Seitenbereich angeben

Standardmäßig werden mit der OCR-Technologie Text und Layoutinformationen aus allen Seiten der Dokumente extrahiert. Sie können bestimmte Seitenzahlen oder Seitenbereiche auswählen und nur Text von diesen Seiten extrahieren.

In ProcessOptions gibt es drei Möglichkeiten, dies zu konfigurieren:

  • So verarbeiten Sie nur die zweite und fünfte Seite:
  {
    "individualPageSelector": {"pages": [2, 5]}
  }
  • So werden nur die ersten drei Seiten verarbeitet:
  {
    "fromStart": 3
  }
  • So verarbeiten Sie nur die letzten vier Seiten:
  {
    "fromEnd": 4
  }

In der Antwort entspricht jedes Document.pages[].pageNumber den Seiten, die in der Anfrage angegeben wurden.

Verwendung von OCR-Add-ons

Diese optionalen Analysefunktionen der Enterprise Document OCR können bei Bedarf für einzelne Verarbeitungsanfragen aktiviert werden.

Mathematik-OCR

Die mathematische OCR erkennt und extrahiert Formeln wie mathematische Gleichungen, die als LaTeX dargestellt sind, zusammen mit Begrenzungsrahmenkoordinaten.

Hier ein Beispiel für die LaTeX-Darstellung:

  • Bild erkannt

    enterprise-document-ocr-2

  • In LaTeX konvertieren

    enterprise-document-ocr-3

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr auf true setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableMathOcr": true
          }
      }
    }
  }

Ausgabe

Die OCR-Ausgabe für Mathematik wird in Document.pages[].visualElements[] mit "type": "math_formula" angezeigt.

"visualElements": [
  {
    "layout": {
      "textAnchor": {
        "textSegments": [
          {
            "endIndex": "46"
          }
        ]
      },
      "confidence": 1,
      "boundingPoly": {
        "normalizedVertices": [
          {
            "x": 0.14662756,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.8027211
          },
          {
            "x": 0.14662756,
            "y": 0.8027211
          }
        ]
      },
      "orientation": "PAGE_UP"
    },
    "type": "math_formula"
  }
]

Die vollständige Document-JSON-Ausgabe findest du unter diesem Link .

Extraktion von Auswahlmarkierungen

Wenn diese Option aktiviert ist, versucht das Modell, alle Kästchen und Optionsfelder im Dokument zusammen mit den Begrenzungsrahmenkoordinaten zu extrahieren.

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection auf true setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableSelectionMarkDetection": true
          }
      }
    }
  }

Ausgabe

Die Kästchenausgabe wird in Document.pages[].visualElements[] mit "type": "unfilled_checkbox" oder "type": "filled_checkbox" angezeigt.

"visualElements": [
  {
    "layout": {
      "confidence": 0.89363575,
      "boundingPoly": {
        "vertices": [
          {
            "x": 11,
            "y": 24
          },
          {
            "x": 37,
            "y": 24
          },
          {
            "x": 37,
            "y": 56
          },
          {
            "x": 11,
            "y": 56
          }
        ],
        "normalizedVertices": [
          {
            "x": 0.017488075,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.9032258
          },
          {
            "x": 0.017488075,
            "y": 0.9032258
          }
        ]
      }
    },
    "type": "unfilled_checkbox"
  },
  {
    "layout": {
      "confidence": 0.9148201,
      "boundingPoly": ...
    },
    "type": "filled_checkbox"
  }
],

Die vollständige Document-JSON-Ausgabe findest du unter diesem Link .

Erkennung von Schriftarten

Wenn die Schriftstilerkennung aktiviert ist, extrahiert Enterprise Document OCR Schriftattribute, die für eine bessere Nachbearbeitung verwendet werden können.

Auf Tokenebene (Wortebene) werden die folgenden Attribute erkannt:

  • Handschrifterkennung
  • Schriftstil
  • Schriftgröße
  • Schriftart
  • Schriftfarbe
  • Schriftstärke
  • Zeichenabstand
  • Fett
  • Kursiv
  • Unterstreichen
  • Textfarbe (RGBa)

  • Hintergrundfarbe (RGBa)

Eingabe

Aktivieren Sie diese Option, indem Sie in der Verarbeitungsanfrage ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo auf true setzen.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "computeStyleInfo": true
          }
      }
    }
  }

Ausgabe

Die Ausgabe des Schriftstils wird in Document.pages[].tokens[].styleInfo mit dem Typ StyleInfo angezeigt.

"tokens": [
  {
    "styleInfo": {
      "fontSize": 3,
      "pixelFontSize": 13,
      "fontType": "SANS_SERIF",
      "bold": true,
      "fontWeight": 564,
      "textColor": {
        "red": 0.16862746,
        "green": 0.16862746,
        "blue": 0.16862746
      },
      "backgroundColor": {
        "red": 0.98039216,
        "green": 0.9882353,
        "blue": 0.99215686
      }
    }
  },
  ...
]

Die vollständige Document-JSON-Ausgabe findest du unter diesem Link .

Dokumentobjekte in das Vision AI API-Format konvertieren

Die Document AI Toolbox enthält ein Tool, mit dem das Format der Document AI API Document in das Vision AI-Format AnnotateFileResponse konvertiert wird. So können Nutzer die Antworten des Dokument-OCR-Prozessors mit denen der Vision AI API vergleichen. Hier ist ein Beispielcode.

Bekannte Abweichungen zwischen der Vision AI API-Antwort und der Document AI API-Antwort und dem Converter:

  • In der Vision AI API-Antwort wird nur vertices für Bildanfragen und nur normalized_vertices für PDF-Anfragen eingefügt. Die Antwort von Document AI und der Konverter füllen sowohl vertices als auch normalized_vertices aus.
  • In der Vision AI API-Antwort wird das detected_break im letzten Symbol des Wortes eingefügt. In der Antwort der Document AI API und im Konverter wird detected_break in das Wort und das letzte Symbol des Wortes eingefügt.
  • In der Vision AI API-Antwort werden immer Symbolfelder ausgefüllt. Standardmäßig werden in der Antwort der Document AI keine Symbolfelder ausgefüllt. Damit die Symbolfelder in der Document AI-Antwort und im Konverter ausgefüllt werden, müssen Sie die enable_symbol-Funktion so festlegen, wie unten beschrieben.

Codebeispiele

In den folgenden Codebeispielen wird gezeigt, wie Sie eine Verarbeitungsanfrage senden, mit der OCR-Konfigurationen und Add-ons aktiviert werden, und dann die Felder lesen und im Terminal ausdrucken:

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Standort des Prozessors, z. B.:
    • us – USA
    • eu – Europäische Union
  • PROJECT_ID: Die Projekt-ID Ihres Google Cloud -Abos.
  • PROCESSOR_ID: Die ID des benutzerdefinierten Prozessors.
  • PROCESSOR_VERSION: die Prozessorversion. Weitere Informationen finden Sie unter Prozessorversion auswählen. Beispiel:
    • pretrained-TYPE-vX.X-YYYY-MM-DD
    • stable
    • rc
  • skipHumanReview: Boolescher Wert, um die manuelle Überprüfung zu deaktivieren. Wird nur von Human-in-the-Loop-Prozessoren unterstützt.
    • true – manuelle Überprüfung wird übersprungen
    • false – Aktiviert die manuelle Überprüfung (Standard)
  • MIME_TYPE†: Eine der gültigen Optionen für den MIME-Typ.
  • IMAGE_CONTENT†: Einer der gültigen Inline-Dokumentinhalte, dargestellt als Bytestream. Bei JSON-Darstellungen die Base64-Codierung (ASCII-String) Ihrer Binärbilddaten. Dieser String sollte in etwa so aussehen:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Weitere Informationen finden Sie unter Base64-Codierung.
  • FIELD_MASK: Gibt an, welche Felder in die Document-Ausgabe eingeschlossen werden sollen. Dies ist eine durch Kommas getrennte Liste vollständig qualifizierter Feldnamen im FieldMask-Format.
    • Beispiel: text,entities,pages.pageNumber
  • OCR-Konfigurationen
    • ENABLE_NATIVE_PDF_PARSING: (Boolescher Wert) Gibt an, ob eingebetteter Text aus PDFs extrahiert werden soll, sofern verfügbar.
    • ENABLE_IMAGE_QUALITY_SCORES: (Boolescher Wert) Aktiviert intelligente Bewertungen der Dokumentqualität.
    • ENABLE_SYMBOL: (Boolescher Wert) Enthält OCR-Informationen zu Symbolen (Buchstaben).
    • DISABLE_CHARACTER_BOXES_DETECTION: (Boolescher Wert) Deaktiviert die Erkennung von Textfeldern in der OCR-Engine.
    • LANGUAGE_HINTS: Liste der BCP-47-Sprachcodes, die für die OCR verwendet werden sollen.
    • ADVANCED_OCR_OPTIONS: Eine Liste erweiterter OCR-Optionen, mit denen sich das OCR-Verhalten weiter optimieren lässt. Derzeit gültige Werte:
      • legacy_layout: ein heuristischer Algorithmus zur Layouterkennung, der als Alternative zum aktuellen ML-basierten Algorithmus zur Layouterkennung dient.
  • Premium-OCR-Add-ons
    • ENABLE_SELECTION_MARK_DETECTION: (Boolesch) Aktivieren Sie die Erkennung von Auswahlmarkierungen in der OCR-Engine.
    • COMPUTE_STYLE_INFO (boolescher Wert) Aktivieren Sie das Modell zur Schriftarterkennung, um Informationen zur Schriftart zurückzugeben.
    • ENABLE_MATH_OCR: (boolescher Wert) Aktivieren Sie das Modell, das mathematische Formeln aus LaTeX extrahieren kann.
  • INDIVIDUAL_PAGES: Eine Liste der einzelnen Seiten, die verarbeitet werden sollen.
    • Alternativ können Sie das Feld fromStart oder fromEnd angeben, um eine bestimmte Anzahl von Seiten vom Anfang oder Ende des Dokuments zu verarbeiten.

† Dieser Inhalt kann auch im inlineDocument-Objekt als Base64-codierter Inhalt angegeben werden.

HTTP-Methode und URL:

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process

JSON-Text der Anfrage:

{
  "skipHumanReview": skipHumanReview,
  "rawDocument": {
    "mimeType": "MIME_TYPE",
    "content": "IMAGE_CONTENT"
  },
  "fieldMask": "FIELD_MASK",
  "processOptions": {
    "ocrConfig": {
      "enableNativePdfParsing": ENABLE_NATIVE_PDF_PARSING,
      "enableImageQualityScores": ENABLE_IMAGE_QUALITY_SCORES,
      "enableSymbol": ENABLE_SYMBOL,
      "disableCharacterBoxesDetection": DISABLE_CHARACTER_BOXES_DETECTION,
      "hints": {
        "languageHints": [
          "LANGUAGE_HINTS"
        ]
      },
      "advancedOcrOptions": ["ADVANCED_OCR_OPTIONS"],
      "premiumFeatures": {
        "enableSelectionMarkDetection": ENABLE_SELECTION_MARK_DETECTION,
        "computeStyleInfo": COMPUTE_STYLE_INFO,
        "enableMathOcr": ENABLE_MATH_OCR,
      }
    },
    "individualPageSelector" {
      "pages": [INDIVIDUAL_PAGES]
    }
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process" | Select-Object -Expand Content

Wenn die Anfrage erfolgreich ist, gibt der Server den HTTP-Statuscode 200 OK und die Antwort im JSON-Format zurück. Der Antworttext enthält eine Instanz von Document.

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Document AI Python API.

Richten Sie zur Authentifizierung bei Document AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


from typing import Optional, Sequence

from google.api_core.client_options import ClientOptions
from google.cloud import documentai

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu"
# processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample
# processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information
# file_path = "/path/to/local/pdf"
# mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types


def process_document_ocr_sample(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
) -> None:
    # Optional: Additional configurations for Document OCR Processor.
    # For more information: https://cloud.google.com/document-ai/docs/enterprise-document-ocr
    process_options = documentai.ProcessOptions(
        ocr_config=documentai.OcrConfig(
            enable_native_pdf_parsing=True,
            enable_image_quality_scores=True,
            enable_symbol=True,
            # OCR Add Ons https://cloud.google.com/document-ai/docs/ocr-add-ons
            premium_features=documentai.OcrConfig.PremiumFeatures(
                compute_style_info=True,
                enable_math_ocr=False,  # Enable to use Math OCR Model
                enable_selection_mark_detection=True,
            ),
        )
    )
    # Online processing request to Document AI
    document = process_document(
        project_id,
        location,
        processor_id,
        processor_version,
        file_path,
        mime_type,
        process_options=process_options,
    )

    text = document.text
    print(f"Full document text: {text}\n")
    print(f"There are {len(document.pages)} page(s) in this document.\n")

    for page in document.pages:
        print(f"Page {page.page_number}:")
        print_page_dimensions(page.dimension)
        print_detected_languages(page.detected_languages)

        print_blocks(page.blocks, text)
        print_paragraphs(page.paragraphs, text)
        print_lines(page.lines, text)
        print_tokens(page.tokens, text)

        if page.symbols:
            print_symbols(page.symbols, text)

        if page.image_quality_scores:
            print_image_quality_scores(page.image_quality_scores)

        if page.visual_elements:
            print_visual_elements(page.visual_elements, text)


def print_page_dimensions(dimension: documentai.Document.Page.Dimension) -> None:
    print(f"    Width: {str(dimension.width)}")
    print(f"    Height: {str(dimension.height)}")


def print_detected_languages(
    detected_languages: Sequence[documentai.Document.Page.DetectedLanguage],
) -> None:
    print("    Detected languages:")
    for lang in detected_languages:
        print(f"        {lang.language_code} ({lang.confidence:.1%} confidence)")


def print_blocks(blocks: Sequence[documentai.Document.Page.Block], text: str) -> None:
    print(f"    {len(blocks)} blocks detected:")
    first_block_text = layout_to_text(blocks[0].layout, text)
    print(f"        First text block: {repr(first_block_text)}")
    last_block_text = layout_to_text(blocks[-1].layout, text)
    print(f"        Last text block: {repr(last_block_text)}")


def print_paragraphs(
    paragraphs: Sequence[documentai.Document.Page.Paragraph], text: str
) -> None:
    print(f"    {len(paragraphs)} paragraphs detected:")
    first_paragraph_text = layout_to_text(paragraphs[0].layout, text)
    print(f"        First paragraph text: {repr(first_paragraph_text)}")
    last_paragraph_text = layout_to_text(paragraphs[-1].layout, text)
    print(f"        Last paragraph text: {repr(last_paragraph_text)}")


def print_lines(lines: Sequence[documentai.Document.Page.Line], text: str) -> None:
    print(f"    {len(lines)} lines detected:")
    first_line_text = layout_to_text(lines[0].layout, text)
    print(f"        First line text: {repr(first_line_text)}")
    last_line_text = layout_to_text(lines[-1].layout, text)
    print(f"        Last line text: {repr(last_line_text)}")


def print_tokens(tokens: Sequence[documentai.Document.Page.Token], text: str) -> None:
    print(f"    {len(tokens)} tokens detected:")
    first_token_text = layout_to_text(tokens[0].layout, text)
    first_token_break_type = tokens[0].detected_break.type_.name
    print(f"        First token text: {repr(first_token_text)}")
    print(f"        First token break type: {repr(first_token_break_type)}")
    if tokens[0].style_info:
        print_style_info(tokens[0].style_info)

    last_token_text = layout_to_text(tokens[-1].layout, text)
    last_token_break_type = tokens[-1].detected_break.type_.name
    print(f"        Last token text: {repr(last_token_text)}")
    print(f"        Last token break type: {repr(last_token_break_type)}")
    if tokens[-1].style_info:
        print_style_info(tokens[-1].style_info)


def print_symbols(
    symbols: Sequence[documentai.Document.Page.Symbol], text: str
) -> None:
    print(f"    {len(symbols)} symbols detected:")
    first_symbol_text = layout_to_text(symbols[0].layout, text)
    print(f"        First symbol text: {repr(first_symbol_text)}")
    last_symbol_text = layout_to_text(symbols[-1].layout, text)
    print(f"        Last symbol text: {repr(last_symbol_text)}")


def print_image_quality_scores(
    image_quality_scores: documentai.Document.Page.ImageQualityScores,
) -> None:
    print(f"    Quality score: {image_quality_scores.quality_score:.1%}")
    print("    Detected defects:")

    for detected_defect in image_quality_scores.detected_defects:
        print(f"        {detected_defect.type_}: {detected_defect.confidence:.1%}")


def print_style_info(style_info: documentai.Document.Page.Token.StyleInfo) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    print(f"           Font Size: {style_info.font_size}pt")
    print(f"           Font Type: {style_info.font_type}")
    print(f"           Bold: {style_info.bold}")
    print(f"           Italic: {style_info.italic}")
    print(f"           Underlined: {style_info.underlined}")
    print(f"           Handwritten: {style_info.handwritten}")
    print(
        f"           Text Color (RGBa): {style_info.text_color.red}, {style_info.text_color.green}, {style_info.text_color.blue}, {style_info.text_color.alpha}"
    )


def print_visual_elements(
    visual_elements: Sequence[documentai.Document.Page.VisualElement], text: str
) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    checkboxes = [x for x in visual_elements if "checkbox" in x.type]
    math_symbols = [x for x in visual_elements if x.type == "math_formula"]

    if checkboxes:
        print(f"    {len(checkboxes)} checkboxes detected:")
        print(f"        First checkbox: {repr(checkboxes[0].type)}")
        print(f"        Last checkbox: {repr(checkboxes[-1].type)}")

    if math_symbols:
        print(f"    {len(math_symbols)} math symbols detected:")
        first_math_symbol_text = layout_to_text(math_symbols[0].layout, text)
        print(f"        First math symbol: {repr(first_math_symbol_text)}")




def process_document(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
    process_options: Optional[documentai.ProcessOptions] = None,
) -> documentai.Document:
    # You must set the `api_endpoint` if you use a location other than "us".
    client = documentai.DocumentProcessorServiceClient(
        client_options=ClientOptions(
            api_endpoint=f"{location}-documentai.googleapis.com"
        )
    )

    # The full resource name of the processor version, e.g.:
    # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`
    # You must create a processor before running this sample.
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version
    )

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

    # Configure the process request
    request = documentai.ProcessRequest(
        name=name,
        raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),
        # Only supported for Document OCR processor
        process_options=process_options,
    )

    result = client.process_document(request=request)

    # For a full list of `Document` object attributes, reference this page:
    # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document
    return result.document




def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:
    """
    Document AI identifies text in different parts of the document by their
    offsets in the entirety of the document"s text. This function converts
    offsets to a string.
    """
    # If a text segment spans several lines, it will
    # be stored in different text segments.
    return "".join(
        text[int(segment.start_index) : int(segment.end_index)]
        for segment in layout.text_anchor.text_segments
    )

Nächste Schritte