Esta página foi traduzida pela API Cloud Translation.

Processar documentos com o Layout Parser

O analisador de layout 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. Você pode inserir arquivos HTML ou PDF no Layout Parser 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 avançado e elementos estruturais que podem criar mais contexto para a recuperação e a 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 partes para melhorar a relevância e diminuir a carga computacional.

Considerar o layout de um documento durante o chunking 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 trecho vem da mesma entidade de layout, como um cabeçalho, um subcabeçalho ou uma lista.

Limitações

Considere as seguintes limitações:

Processamento on-line:
- 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 arquivo único 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, cabeçalho da página, rodapé da página	A análise depende muito das tags HTML, então 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évia)	parágrafo, tabelas em várias páginas, lista, título, elementos de cabeçalho	Não é possível usar tabelas aninhadas.
PPTX (Prévia)	parágrafo, tabela, lista, título, elementos de cabeçalho	Para que os cabeçalhos sejam identificados com precisão, eles precisam ser marcados como tal no arquivo do PowerPoint. Tabelas aninhadas e slides ocultos não são compatíveis.
XLSX/XLSM (pré-lançamento)	tabelas em planilhas do Excel, com suporte a valores `INT`, `FLOAT` e `STRING`	Não é possível detectar várias tabelas. Planilhas, 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.
Siga as instruções em Ativar um processador.

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

Insira 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 em ProcessDocumentRequest.

REST

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

LOCATION: a localização do seu processador, por exemplo:
- us: Estados Unidos
- eu: União Europeia
PROJECT_ID: o ID do projeto do Google Cloud .
PROCESSOR_ID: o ID do seu processador personalizado.
MIME_TYPE: o Layout Parser é compatível com application/pdf e text/html.
DOCUMENT: o conteúdo a ser dividido em partes. O Layout Parser aceita documentos PDF ou HTML brutos ou analisados que foram gerados por ele.
CHUNK_SIZE: opcional. O tamanho do bloco, em tokens, a ser usado ao dividir documentos.
INCLUDE_ANCESTOR_HEADINGS: opcional. Booleano. Se os títulos ancestrais devem ser incluídos 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 divisão em partes como Document.documentLayout e Document.chunkedDocument.

Python

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

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 a seguir para analisar e dividir vários documentos em um único pedido.

Insira 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 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 os cabeçalhos ancestrais devem ser incluídos ao dividir documentos. Os títulos ancestrais são os pais dos subtítulos no documento original. Eles podem fornecer um trecho com mais contexto sobre a posição dele no documento original. É possível incluir até dois níveis de cabeçalhos com um trecho.