Diese Seite wurde von der Cloud Translation API übersetzt.

Dokumente mit Layout-Parser verarbeiten

Der Layout-Parser 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 Layout-Parsers

Dokumentlayouts analysieren Sie können HTML- oder PDF-Dateien in den Layout-Parser einfügen, um Inhaltselemente wie Textblöcke, Tabellen, Listen und Strukturelemente wie Titel und Überschriften zu identifizieren. Diese Elemente helfen, die Organisation und Hierarchie eines Dokuments mit umfangreichen Inhalten und strukturellen Elementen zu definieren, die mehr Kontext für die Informationsabfrage und -suche schaffen können.
Dokumente in kleinere Abschnitte unterteilen Der Layout-Parser kann Dokumente in Blöcke aufteilen, die Kontextinformationen zur Layouthierarchie des ursprünglichen Dokuments beibehalten. LLMs, die Antworten generieren, können mithilfe von Chunks die Relevanz verbessern und die Rechenlast verringern.

Wenn beim Chunking das Layout eines Dokuments berücksichtigt wird, wird die semantische Kohärenz verbessert und es wird weniger Rauschen in den Inhalten erzeugt, wenn sie für das Abrufen und die LLM-Generierung verwendet werden. Der gesamte Text in einem Block stammt aus derselben Layout-Entität, z. B. einer Überschrift, Zwischenüberschrift oder Liste.

Beschränkungen

Es gelten folgende Einschränkungen:

Onlineverarbeitung:
- Maximale Größe der Eingabedatei für alle Dateitypen: 20 MB
- Maximal 15 Seiten pro PDF-Datei
Batchverarbeitung:
- Maximale Größe einer einzelnen Datei: 40 MB für PDF-Dateien
- Maximal 500 Seiten pro PDF-Datei

Layouterkennung nach Dateityp

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

Dateityp	Erkannte Elemente	Beschränkungen
HTML	Absatz, Tabelle, Liste, Titel, Überschrift, Seitenkopf, Seitenfuß	Das Parsen basiert stark auf HTML-Tags. CSS-basierte Formatierungen werden daher möglicherweise nicht erfasst.
PDF	Absatz, Tabelle, Titel, Überschrift, Seitenkopfzeile, Seitenfußzeile	Tabellen, die mehrere Seiten umfassen, werden möglicherweise in zwei Tabellen aufgeteilt.
DOCX (Vorabversion)	Absätze, Tabellen auf mehreren Seiten, Listen, Titel, Überschriften	Verschachtelte Tabellen werden nicht unterstützt.
PPTX (Vorabversion)	Absätze, Tabellen, Listen, Titel, Überschriften	Damit Überschriften korrekt erkannt werden, müssen sie in der PowerPoint-Datei entsprechend gekennzeichnet sein. Verschachtelte Tabellen und ausgeblendete Folien werden nicht unterstützt.
XLSX/XLSM (Vorabversion)	Tabellen in Excel-Tabellen, die `INT`-, `FLOAT`- und `STRING`-Werte unterstützen	Die Erkennung mehrerer Tabellen wird nicht unterstützt. Ausgeblendete Tabellen, Zeilen oder Spalten können sich ebenfalls auf die Erkennung auswirken.

Hinweise

So aktivieren Sie den Layout-Parser:

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

Der Name des Prozessortyps ist LAYOUT_PARSER_PROCESSOR.
Aktivieren Sie den Layout-Parser. Folgen Sie dazu der Anleitung unter Prozessor aktivieren.

Online-Prozessanfrage mit Layout-Parser senden

Dokumente in den Layout-Parser einfügen, um sie zu parsen und in Blöcke zu unterteilen.

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

Konfigurieren Sie die Felder unter ProcessOptions.layoutConfig in ProcessDocumentRequest.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

LOCATION: Standort des Prozessors, z. B.:
- us – USA
- eu – Europäische Union
PROJECT_ID: Ihre Google Cloud Projekt-ID.
PROCESSOR_ID: Die ID des 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 Größe der Blöcke in Tokens, die beim Aufteilen von Dokumenten verwendet werden soll.
INCLUDE_ANCESTOR_HEADINGS: Optional. Boolescher Wert. Ob übergeordnete Überschriften beim Aufteilen von Dokumenten eingeschlossen 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 wie 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 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 Layout-Parser im Batch verarbeiten

Mit der folgenden Methode können Sie mehrere Dokumente in einer einzigen Anfrage parsen und in einzelne Blöcke aufteilen.

Dokumente in den Layout-Parser einfügen, um sie zu parsen und in Blöcke zu unterteilen.

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

Konfigurieren Sie die Felder in ProcessOptions.layoutConfig, wenn Sie eine batchProcess-Anfrage senden.
Eingabe
Im folgenden Beispiel wird ProcessOptions.layoutConfig konfiguriert.
```
"processOptions": {
  "layoutConfig": {
    "chunkingConfig": {
      "chunkSize": "CHUNK_SIZE",
      "includeAncestorHeadings": "INCLUDE_ANCESTOR_HEADINGS_BOOLEAN"
    }
  }
}
```
Ersetzen Sie Folgendes:
- CHUNK_SIZE: Die maximale Größe eines Chunks in Form der Anzahl der Tokens, die beim Aufteilen von Dokumenten verwendet werden soll.
- INCLUDE_ANCESTOR_HEADINGS_BOOLEAN: Gibt an, ob übergeordnete Überschriften beim Aufteilen von Dokumenten berücksichtigt werden sollen. Übergeordnete Überschriften sind die übergeordneten Elemente von Zwischenüberschriften im Originaldokument. Sie können einem Textblock zusätzlichen Kontext zu seiner Position im Originaldokument liefern. Ein Block kann bis zu zwei Ebenen von Überschriften enthalten.