Esta página foi traduzida pela API Cloud Translation.

Processar documentos com o Layout Parser

O Layout Parser extrai elementos de conteúdo de documentos, como texto, tabelas e listas, e cria blocos com reconhecimento de contexto que facilitam a recuperação de informações em IA generativa e aplicativos de descoberta.

Recursos do analisador de layout

Analisar layouts de documentos. É possível inserir arquivos HTML ou PDF no Analisador de layout para identificar elementos de conteúdo, como blocos de texto, tabelas, listas e elementos estruturais, como títulos e cabeçalhos. Esses elementos ajudam a definir a organização e a hierarquia de um documento com conteúdo rico e elementos estruturais que podem criar mais contexto para recuperação e descoberta de informações.
Divida os documentos. O Layout Parser pode dividir documentos em partes que retêm informações contextuais sobre a hierarquia de layout do documento original. Os LLMs que geram respostas podem usar blocos para melhorar a relevância e diminuir a carga computacional.

Considerar o layout de um documento durante o agrupamento melhora a coerência semântica e reduz o ruído no conteúdo quando ele é usado para recuperação e geração de LLM. Todo o texto em um bloco vem da mesma entidade de layout, como um título, subtítulo ou lista.

Limitações

Considere as seguintes limitações:

Processamento on-line:
- O tamanho máximo do arquivo de entrada é de 20 MB para todos os tipos de arquivo
- Máximo de 15 páginas por arquivo PDF
Processamento em lote:
- Tamanho máximo de um único arquivo de 40 MB para arquivos PDF
- Máximo de 500 páginas por arquivo PDF

Detecção de layout por tipo de arquivo

A tabela a seguir lista os elementos que o Layout Parser pode detectar por tipo de arquivo de documento.

Tipo de arquivo	Elementos detectados	Limitações
HTML	parágrafo, tabela, lista, título, cabeçalho, rodapé	A análise depende muito das tags HTML. Portanto, a formatação baseada em CSS pode não ser capturada.
PDF	parágrafo, tabela, título, cabeçalho, cabeçalho da página, rodapé da página	As tabelas que abrangem várias páginas podem ser divididas em duas.
DOCX (pré-lançamento)	parágrafo, tabelas em várias páginas, lista, título, elementos de título	Não é possível usar tabelas aninhadas.
PPTX (Pré-lançamento)	parágrafo, tabela, lista, título, elementos de título	Para que os títulos sejam identificados com precisão, eles precisam ser marcados como tais no arquivo do PowerPoint. Não é possível usar tabelas aninhadas e slides ocultos.
XLSX/XLSM (pré-lançamento)	tabelas em planilhas do Excel, com suporte a valores `INT`, `FLOAT` e `STRING`	Não há suporte para a detecção de várias tabelas. Folhas, linhas ou colunas ocultas também podem afetar a detecção.

Antes de começar

Para ativar o Layout Parser, siga estas etapas:

Crie um analisador de layout seguindo as instruções em Como criar e gerenciar processadores.

O nome do tipo de processador é LAYOUT_PARSER_PROCESSOR.
Ative o Layout Parser seguindo as instruções em Ativar um processador.

Enviar uma solicitação de processo on-line com o Layout Parser

Inserir documentos no Layout Parser para analisar e dividir.

Siga as instruções para solicitações de processamento em lote em Enviar uma solicitação de processamento.

Configure os campos em ProcessOptions.layoutConfig em ProcessDocumentRequest.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

LOCATION: o local do processador, por exemplo:
- us - Estados Unidos
- eu - União Europeia
PROJECT_ID: o ID do projeto do Google Cloud .
PROCESSOR_ID: o ID do processador personalizado.
MIME_TYPE: o Layout Parser tem suporte a application/pdf e text/html.
DOCUMENT: o conteúdo a ser dividido em partes. O Layout Parser aceita documentos PDF ou HTML brutos ou documentos analisados que foram gerados pelo Layout Parser.
CHUNK_SIZE: opcional. O tamanho do bloco, em tokens, a ser usado ao dividir documentos.
INCLUDE_ANCESTOR_HEADINGS: opcional. Booleano. Se é necessário incluir títulos ancestrais ao dividir documentos.

Método HTTP e URL:

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

Corpo JSON da solicitação:

// 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",
      }
    }
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$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

A resposta inclui o documento processado com informações de layout e fragmentação como Document.documentLayout e Document.chunkedDocument.

Python

Para mais informações, consulte a documentação de referência da API Document AI Python.

Para autenticar na Document AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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

Processar documentos em lote com o Layout Parser

Use o procedimento abaixo para analisar e dividir vários documentos em uma única solicitação.

Inserir documentos no Layout Parser para analisar e dividir.

Siga as instruções para solicitações de processamento em lote em Enviar uma solicitação de processamento.

Configure campos em ProcessOptions.layoutConfig ao fazer uma solicitação batchProcess.
Entrada
O exemplo de JSON a seguir configura ProcessOptions.layoutConfig.
```
"processOptions": {
  "layoutConfig": {
    "chunkingConfig": {
      "chunkSize": "CHUNK_SIZE",
      "includeAncestorHeadings": "INCLUDE_ANCESTOR_HEADINGS_BOOLEAN"
    }
  }
}
```
Substitua:
- CHUNK_SIZE: o tamanho máximo do bloco, em número de tokens, a ser usado ao dividir documentos.
- INCLUDE_ANCESTOR_HEADINGS_BOOLEAN: se é necessário incluir títulos ancestrais ao dividir documentos. Os títulos ancestrais são os pais das subdivisões no documento original. Eles podem fornecer um bloco com mais contexto sobre a posição dele no documento original. É possível incluir até dois níveis de títulos em um bloco.

A seguir

Consulte a lista de processadores.
Crie um classificador personalizado.
Use o Enterprise Document OCR para detectar e extrair texto.

Extrator personalizado com IA generativa

Visão geral do treinamento prévio