Dokumente mit dem Layout-Parser verarbeiten

Der Layoutparser extrahiert Dokumentinhaltselemente wie Text, Tabellen und Listen und erstellt kontextsensitive Blöcke, die das Abrufen von Informationen in Anwendungen für generative KI und Discovery erleichtern.

Funktionen des Layoutparsers

  • Dokumentlayouts parsen: Sie können HTML- oder PDF-Dateien in den Layout-Parser eingeben, um Inhaltselemente wie Textblöcke, Tabellen, Listen und strukturelle Elemente wie Titel und Überschriften zu identifizieren. Diese Elemente tragen dazu bei, die Organisation und Hierarchie eines Dokuments mit Rich Content und Strukturelementen zu definieren, die mehr Kontext für das Abrufen und Auffinden von Informationen schaffen können.

  • Dokumente in Chunks aufteilen: Der Layout-Parser kann Dokumente in Chunks aufteilen, die Kontextinformationen zur Layout-Hierarchie des Originaldokuments enthalten. LLMs, die Antworten generieren, können Chunks verwenden, um die Relevanz zu verbessern und die Rechenlast zu verringern.

    Wenn das Layout eines Dokuments beim Chunking berücksichtigt wird, verbessert das die semantische Kohärenz und reduziert das Rauschen im Inhalt, wenn er für den Abruf und die LLM-Generierung verwendet wird. Der gesamte Text in einem Chunk stammt aus derselben Layout-Einheit, z. B. einer Überschrift, einer Unterüberschrift oder einer Liste.

  • Gemini-Layout-Parser Vorschau. Der Gemini-Layout-Parser bietet eine bessere Layoutqualität bei der Tabellenerkennung, der Lesereihenfolge und der Texterkennung von PDF-Dateien. Sie können die Funktion standardmäßig aktivieren, indem Sie die Layoutparser-Prozessorversion pretrained-layout-parser-v1.4-2025-08-25, pretrained-layout-parser-v1.5-2025-08-25 oder pretrained-layout-parser-v1.5-pro-2025-08-25 für Ihren Prozessor auswählen.

  • Bilder und Tabellen als Anmerkungen parsen: Vorschau. Der Layoutparser kann erkennen, ob in geparsten Dokumenten Bilder oder Tabellen vorhanden sind. Wenn sie gefunden werden, werden sie als beschreibender Textblock mit den im Bild und in der Tabelle dargestellten Informationen annotiert.

Beschränkungen

Es gelten folgende Einschränkungen:

  • Online-Verarbeitung:
    • Die maximale Größe der Eingabedatei beträgt 20 MB für alle Dateitypen.
    • Maximal 15 Seiten pro PDF-Datei
  • Batchverarbeitung:
    • Maximale Größe einer einzelnen Datei: 1 GB für PDF-Dateien
    • Maximal 500 Seiten pro PDF-Datei

Layout-Erkennung nach Dateityp

In der folgenden Tabelle sind die Elemente aufgeführt, die der Layout-Parser pro Dokumentdateityp erkennen kann.

Dateityp MIME-Typ Erkannte Elemente Beschränkungen
HTML text/html Absatz, Tabelle, Liste, Titel, Überschrift, Seitenkopf, Seitenfuß Das Parsen hängt stark von HTML-Tags ab. CSS-basierte Formatierungen werden daher möglicherweise nicht erfasst.
PDF application/pdf Absatz, Tabelle, Titel, Überschrift, Seitenkopf, Seitenfuß Tabellen, die sich über mehrere Seiten erstrecken, werden möglicherweise in zwei Tabellen aufgeteilt.
DOCX application/vnd.openxmlformats-officedocument.wordprocessingml.document Absatz, Tabellen auf mehreren Seiten, Liste, Titel, Überschriftenelemente Verschachtelte Tabellen werden nicht unterstützt.
PPTX application/vnd.openxmlformats-officedocument.presentationml.presentation Absatz-, Tabellen-, Listen-, Titel- und Überschriftenelemente Damit Überschriften richtig erkannt werden, müssen sie in der PowerPoint-Datei als solche gekennzeichnet sein. Verschachtelte Tabellen und ausgeblendete Folien werden nicht unterstützt.
XLSX application/vnd.openxmlformats-officedocument.spreadsheetml.sheet Tabellen in Excel-Tabellen, die INT-, FLOAT- und STRING-Werte unterstützen Die Erkennung mehrerer Tabellen wird nicht unterstützt. Auch ausgeblendete Tabellenblätter, Zeilen oder Spalten können sich auf die Erkennung auswirken. Es können Dateien mit bis zu 5 Millionen Zellen verarbeitet werden.
XLSM application/vnd.ms-excel.sheet.macroenabled.12 Tabelle mit aktiviertem Makro, die die Werte INT, FLOAT und STRING unterstützt Die Erkennung mehrerer Tabellen wird nicht unterstützt. Auch ausgeblendete Tabellenblätter, Zeilen oder Spalten können sich auf die Erkennung auswirken.

Prozessorversionen

Die folgenden Modelle sind für den Layout-Parser verfügbar. Informationen zum Ändern von Modellversionen finden Sie unter Prozessorversionen verwalten.

Wenn Sie eine Anfrage zur Kontingenterhöhung für das Standardkontingent für Prozessoren stellen möchten, folgen Sie der Anleitung unter Kontingent verwalten.

Modellversion Beschreibung Release-Version Releasedatum
pretrained-layout-parser-v1.0-2024-06-03 Version mit allgemeiner Verfügbarkeit für die Analyse des Dokumentlayouts. Dies ist die Standardversion des vortrainierten Prozessors. Stabil 3. Juni 2024
pretrained-layout-parser-v1.5-2025-08-25 Die Vorschauversion basiert auf dem Gemini 2.5 Flash-LLM und bietet eine verbesserte Layoutanalyse für PDF-Dateien. Empfohlen für Nutzer, die neue Versionen ausprobieren möchten. Wenn es für Nicht-PDF-Dateien verwendet wird, verhält es sich genauso wie die stabile Version von pretrained-layout-parser-v1.0-2024-06-03. Releasekandidat 25. August 2025
pretrained-layout-parser-v1.5-pro-2025-08-25 Die Vorschauversion basiert auf dem Gemini 2.5 Pro-LLM und bietet eine bessere Layoutanalyse von PDF-Dateien. Die Latenz von v1.5-pro ist höher als die von v1.5. Wenn es für Nicht-PDF-Dateien verwendet wird, verhält es sich wie die stabile Version 1.0. Releasekandidat 25. August 2025

Hinweise

So aktivieren Sie den Layout-Parser:

  1. Erstellen Sie einen Layout-Parser. Folgen Sie dazu der Anleitung unter Prozessoren erstellen und verwalten.

    Der Name des Prozessortyps ist LAYOUT_PARSER_PROCESSOR.

  2. Aktivieren Sie den Layout-Parser gemäß der Anleitung unter Prozessor aktivieren.

Onlineprozessanfrage mit Layout Parser senden

  1. Eingabedokumente für den Layoutparser zum Parsen und Aufteilen in Blöcke.

    Folgen Sie der Anleitung für Batchverarbeitungsanfragen unter Verarbeitungsanfrage senden.

    Felder in ProcessOptions.layoutConfig in ProcessDocumentRequest konfigurieren

    REST

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • LOCATION: Der Standort Ihres Prozessors, z. B.
      • us – USA
      • eu – Europäische Union
    • PROJECT_ID: Ihre Google Cloud Projekt-ID
    • PROCESSOR_ID: Die ID Ihres benutzerdefinierten Prozessors.
    • MIME_TYPE: Der Layout-Parser unterstützt application/pdf und text/html.
    • DOCUMENT: Der Inhalt, der in Blöcke aufgeteilt werden soll. Der Layout-Parser akzeptiert Roh-PDF- oder HTML-Dokumente oder geparste Dokumente, die vom Layout-Parser ausgegeben wurden.
    • CHUNK_SIZE: Optional. Die Chunk-Größe in Tokens, die beim Aufteilen von Dokumenten verwendet werden soll.
    • INCLUDE_ANCESTOR_HEADINGS: Optional. Boolescher Wert. Gibt an, ob beim Aufteilen von Dokumenten Ancestor-Überschriften berücksichtigt werden sollen.

    HTTP-Methode und URL: 

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

    JSON-Text der Anfrage:

    // Sample for inputting raw documents such as PDF or HTML
{
  "rawDocument": {
    "mimeType": "MIME_TYPE",
    "content": "DOCUMENT"
  },
  "processOptions": {
    "layoutConfig": {
      "chunkingConfig": {
        "chunkSize": "CHUNK_SIZE",
        "includeAncestorHeadings": "INCLUDE_ANCESTOR_HEADINGS",
      }
    }
  }
}

    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 "Content-Type: application/json; charset=utf-8" \
         -d @request.json \
         "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID:process"

    PowerShell

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

    $headers = @{  }

    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:process" | Select-Object -Expand Content
    Die Antwort enthält das verarbeitete Dokument mit Layout- und Chunking-Informationen als Document.documentLayout und Document.chunkedDocument.

    Python

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

    Richten Sie zur Authentifizierung bei Document AI die 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_layout_sample(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
) -> documentai.Document:
    process_options = documentai.ProcessOptions(
        layout_config=documentai.ProcessOptions.LayoutConfig(
            chunking_config=documentai.ProcessOptions.LayoutConfig.ChunkingConfig(
                chunk_size=1000,
                include_ancestor_headings=True,
            )
        )
    )

    document = process_document(
        project_id,
        location,
        processor_id,
        processor_version,
        file_path,
        mime_type,
        process_options=process_options,
    )

    print("Document Layout Blocks")
    for block in document.document_layout.blocks:
        print(block)

    print("Document Chunks")
    for chunk in document.chunked_document.chunks:
        print(chunk)



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

Dokumente mit dem Layout-Parser im Batch verarbeiten

Gehen Sie so vor, um mehrere Dokumente in einer einzigen Anfrage zu parsen und in Chunks aufzuteilen.

  1. Eingabedokumente für den Layoutparser zum Parsen und Aufteilen in Blöcke.

    Folgen Sie der Anleitung für Batchverarbeitungsanfragen unter Verarbeitungsanfrage senden.

    Konfigurieren Sie Felder in ProcessOptions.layoutConfig, wenn Sie eine batchProcess-Anfrage stellen.

    Eingabe

    Im folgenden Beispiel wird ProcessOptions.layoutConfig mit JSON konfiguriert.

    "processOptions": {
  "layoutConfig": {
    "chunkingConfig": {
      "chunkSize": "CHUNK_SIZE",
      "includeAncestorHeadings": "INCLUDE_ANCESTOR_HEADINGS_BOOLEAN"
    }
  }
}

    Ersetzen Sie Folgendes:

    • CHUNK_SIZE: Die maximale Chunksize in Anzahl der Tokens, die beim Aufteilen von Dokumenten verwendet werden soll.
    • INCLUDE_ANCESTOR_HEADINGS_BOOLEAN: Gibt an, ob beim Aufteilen von Dokumenten auch Überschriften der übergeordneten Abschnitte berücksichtigt werden sollen. Ancestor-Überschriften sind die übergeordneten Überschriften von Unterüberschriften im Originaldokument. Sie können einen Chunks mit zusätzlichem Kontext zu seiner Position im Originaldokument bereitstellen. Ein Chunk kann bis zu zwei Überschriftenebenen enthalten.

Nächste Schritte

Zurück
Abgeleitetes Feld und Signaturerkennung
Weiter
Übersicht über vortrainierte Modelle