Diese Seite wurde von der Cloud Translation API übersetzt.

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.

Layoutparser-Funktionen

Dokumentlayouts parsen: Sie können HTML- oder PDF-Dateien in 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: Mit Layout Parser können Dokumente in Chunks unterteilt werden, die Kontextinformationen zur Layouthierarchie 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.

Beschränkungen

Es gelten folgende Einschränkungen:

Onlineverarbeitung:
- 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 von 40 MB für PDF-Dateien
- Maximal 500 Seiten pro PDF-Datei

Layout-Erkennung nach Dateityp

In der folgenden Tabelle sind die Elemente aufgeführt, die von Layout Parser pro Dokumentdateityp erkannt werden können.

Dateityp	Erkannte Elemente	Beschränkungen
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	Absatz, Tabelle, Titel, Überschrift, Seitenkopf, Seitenfuß	Tabellen, die sich über mehrere Seiten erstrecken, werden möglicherweise in zwei Tabellen aufgeteilt.
DOCX (Vorschau)	Absatz, Tabellen auf mehreren Seiten, Liste, Titel, Überschriftenelemente	Verschachtelte Tabellen werden nicht unterstützt.
PPTX (Vorschau)	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/XLSM (Vorschau)	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.

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 gemäß der Anleitung unter Prozessor aktivieren.

Onlineprozessanfrage mit Layout Parser senden

Geben Sie Dokumente in den Layout-Parser ein, um sie zu parsen und in Blöcke zu unterteilen.

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 Ancestor-Überschriften beim Aufteilen von Dokumenten 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 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.

Geben Sie Dokumente in den Layout-Parser ein, um sie zu parsen und in Blöcke zu unterteilen.

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