# PP-DocLayoutV4

## Visão geral

**PP-DocLayoutV4** é um modelo de análise de layout de documentos de ponta a ponta que prevê, em uma única passagem direta, o que é cada elemento de layout, o quadrilátero que o delimita e os logits a partir dos quais a ordem de leitura é decodificada.

## Arquitetura do Modelo

PP-DocLayoutV4 mantém o esqueleto RT-DETR de seu predecessor — um backbone HGNetV2, um encoder híbrido AIFI e um decoder deformável — e altera três coisas:

- **Quadriláteros em vez de máscaras.** [PPDocLayoutV3ForObjectDetection](/docs/transformers/main/pt/model_doc/pp_doclayout_v3#transformers.PPDocLayoutV3ForObjectDetection) previa uma máscara de segmentação por query e ajustava um polígono a ela. O PP-DocLayoutV4 elimina completamente o ramo de máscara e regressa diretamente um quadrilátero de quatro pontos, codificado como `[center_x, center_y, dx1, dy1, ..., dx4, dy4]` no espaço sigmoid. Isso lida com documentos distorcidos por perspectiva sem o custo de uma cabeça de máscara, e o recurso de backbone com stride 4 não é mais necessário.
- **Cabeças por camada não compartilhadas.** Cada camada do decodificador possui sua própria caixa e cabeça de classificação, em vez de compartilhar uma única cabeça com o codificador.
- **Duas cabeças de ordem de leitura mais uma etapa de fusão.** Além da cabeça de ordem relativa da V3 (antissimétrica: "o `i` é lido antes do `j`?"), há uma cabeça de sucessor (ROOR: "o `j` segue diretamente o `i`?"). O `PPDocLayoutV4S2RFusion` incorpora um fechamento transitivo amortecido da matriz de sucessor de volta aos logits de ordem relativa.

A ordem de leitura não é decodificada dentro do modelo. `PPDocLayoutV4ForObjectDetection` retorna os `relative_order_logits` e `successor_order_logits` brutos, e [post_process_object_detection()](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection) os converte em posições por meio do limiar da matriz de sucessores em um grafo acíclico direcionado (DAG), quebrando ciclos, ordenando cada componente conexo topologicamente e ordenando os componentes por seus votos de ordem relativa.

## Uso

Os resultados retornados por [post_process_object_detection()](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection) já estão ordenados pela ordem de leitura. Cada resultado contém `polygon_points` — um tensor `(num_boxes, 4, 2)` dos cantos regressados na ordem superior-esquerda, superior-direita, inferior-direita, inferior-esquerda — além de `boxes`, o retângulo alinhado aos eixos que envolve cada quadrado, e `order_seq`, o rank base 0 de cada caixa. O exemplo de [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel) abaixo imprime `order_seq` diretamente, enquanto os outros imprimem a posição base 1 na lista ordenada, que é `order_seq + 1`, a menos que uma consulta tenha sido mantida sob vários rótulos.

[Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) preserva a ordem de leitura na ordem da lista retornada, mas aplaina cada detecção para uma pontuação, um rótulo e uma caixa delimitadora inteira. Use o caminho [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel) abaixo para obter os quadriláteros e `order_seq`.

```python
from transformers import pipeline
from transformers.image_utils import load_image

image = load_image("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg")
layout_detector = pipeline("object-detection", model="PaddlePaddle/PP-DocLayoutV4_safetensors")
results = layout_detector(image)
for idx, res in enumerate(results):
    print(f"Order {idx + 1}: {res}")
```

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from transformers.image_utils import load_image

model_path = "PaddlePaddle/PP-DocLayoutV4_safetensors"
model = AutoModelForObjectDetection.from_pretrained(model_path, device_map="auto")
image_processor = AutoImageProcessor.from_pretrained(model_path)

image = load_image("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg")
inputs = image_processor(images=image, return_tensors="pt").to(device=model.device, dtype=model.dtype)

outputs = model(**inputs)
results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]])
for result in results:
    for score, label_id, box, quad, rank in zip(
        result["scores"], result["labels"], result["boxes"], result["polygon_points"], result["order_seq"]
    ):
        box = [round(i, 2) for i in box.tolist()]
        print(f"Order {rank.item()}: {model.config.id2label[label_id.item()]}, score: {score.item():.2f}, box: {box}")
        print(f"         corners: {[[round(x, 2) for x in point] for point in quad.tolist()]}")
```

### Inferência em lote

Passe uma lista de imagens e um tamanho de destino para cada imagem. A ordem de leitura é decodificada por imagem.

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from transformers.image_utils import load_image

model_path = "PaddlePaddle/PP-DocLayoutV4_safetensors"
model = AutoModelForObjectDetection.from_pretrained(model_path, device_map="auto")
image_processor = AutoImageProcessor.from_pretrained(model_path)

image = load_image("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg")
inputs = image_processor(images=[image, image], return_tensors="pt").to(device=model.device, dtype=model.dtype)

outputs = model(**inputs)
results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]] * 2)
for result in results:
    print("result:")
    for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])):
        box = [round(i, 2) for i in box.tolist()]
        print(f"Order {idx + 1}: {model.config.id2label[label_id.item()]}, score: {score.item():.2f}, box: {box}")
```

## PPDocLayoutV4ForObjectDetection[[transformers.PPDocLayoutV4ForObjectDetection]]

#### transformers.PPDocLayoutV4ForObjectDetection[[transformers.PPDocLayoutV4ForObjectDetection]]

```python
transformers.PPDocLayoutV4ForObjectDetection(config: PPDocLayoutV4Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1650)

**Parâmetros:**

config ([PPDocLayoutV4Config](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo PP-DocLayoutV4 (composto por um backbone e um encoder-decoder) que gera quadriláteros, logits de classe e logits de ordem de leitura, para tarefas como análise de layout de documentos.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PPDocLayoutV4ForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1668)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando `image_processor_class`. Consulte `image_processor_class.__call__` para obter detalhes (`processor_class` usa `image_processor_class` para processar imagens).

pixel_mask (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar a execução de atenção em valores de pixels de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para pixels reais (ou seja, **não mascarados**), - 0 para pixels de preenchimento (ou seja, **mascarados**).  [O que são máscaras de atenção?](../glossary#attention-mask)

encoder_outputs (`torch.Tensor`, *opcional*) : Tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do codificador. Usado na cross-attention do decodificador.

labels (`list[Dict]` de comprimento `(batch_size,)`, *opcional*) : Não suportado: PP-DocLayoutV4 é apenas para inferência no Transformers.

**Retorna:** `PPDocLayoutV4ForObjectDetectionOutput` ou `tuple(torch.Tensor)`

Um `PPDocLayoutV4ForObjectDetectionOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração (`None`) e das entradas.

O método forward de [PPDocLayoutV4ForObjectDetection](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ForObjectDetection) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **logits** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_labels)`) -- Logits de classificação (sem no-object) para todas as queries.
- **pred_boxes** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_coords)`) -- Quads normalizados para todas as queries, codificados como `[center_x, center_y, dx1, dy1, ..., dx4, dy4]`, onde os deslocamentos dos cantos são deslocados por `+0.5`. Use [post_process_object_detection()](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection) para recuperar os cantos não normalizados e suas caixas delimitadoras.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_queries, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do decodificador do modelo.
- **intermediate_hidden_states** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Estados ocultos intermediários empilhados (saída de cada camada do decodificador).
- **intermediate_reference_points** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, config.num_coords)`) -- Pontos de referência intermediários empilhados (quadriláteros refinados de cada camada do decodificador).
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **cross_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **init_reference_points** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_coords)`) -- Pontos de referência quadrados iniciais enviados através do decodificador do Transformer.
- **enc_topk_logits** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_labels)`) -- Logits de classe das propostas do codificador que foram selecionadas como consultas do decodificador.
- **enc_topk_bboxes** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_coords)`) -- Quadrados das propostas do codificador que foram selecionados como consultas do decodificador.
- **enc_outputs_class** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Logits de classe de cada proposta do codificador.
- **enc_outputs_coord_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_coords)`) -- Logits de quadrados de cada proposta do codificador.
- **denoising_meta_values** (`dict`, *opcional*) -- Dicionário extra para os valores relacionados ao denoising.
- **relative_order_logits** (`torch.Tensor` de forma `(batch_size, config.num_queries, config.num_queries)`) -- Logits de ordem de leitura relativa por pares, após a fusão S2R opcional. Um valor positivo em `relative_order_logits[i, j]` significa que a consulta `i` é lida antes da consulta `j`.
- **successor_order_logits** (`torch.Tensor` de forma `(batch_size, config.num_queries, config.num_queries)`) -- Logits de sucessor direto em pares (ROOR). Um valor positivo em `successor_order_logits[i, j]` significa que a consulta `j` segue diretamente a consulta `i`.

Exemplos:

```python
>>> from transformers import AutoImageProcessor, AutoModelForObjectDetection
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO

>>> url = "https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> model_path = "PaddlePaddle/PP-DocLayoutV4_safetensors"
>>> image_processor = AutoImageProcessor.from_pretrained(model_path)
>>> model = AutoModelForObjectDetection.from_pretrained(model_path)

>>> inputs = image_processor(images=[image], return_tensors="pt")
>>> outputs = model(**inputs)

>>> # results are already sorted by reading order
>>> results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]])
>>> for result in results:
...     for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])):
...         box = [round(i, 2) for i in box.tolist()]
...         print(f"Order {idx + 1}: {model.config.id2label[label_id.item()]}: {score.item():.2f} {box}")
Order 1: text: 0.99 [336.07, 182.04, 894.17, 652.62]
Order 2: paragraph_title: 0.98 [336.45, 681.88, 868.78, 796.91]
Order 3: text: 0.99 [334.01, 840.84, 889.11, 1452.29]
Order 4: text: 0.99 [920.65, 183.62, 1476.75, 462.75]
Order 5: text: 0.99 [919.55, 482.55, 1479.85, 763.41]
Order 6: text: 0.98 [919.34, 844.48, 1481.28, 1219.44]
Order 7: text: 0.98 [920.84, 1238.61, 1467.66, 1374.54]
Order 8: text: 0.90 [334.24, 1612.85, 1478.79, 1730.92]
Order 9: text: 0.95 [334.25, 1755.98, 1467.34, 1845.6]
Order 10: text: 0.65 [337.14, 1909.47, 659.78, 1938.2]
Order 11: footnote: 0.78 [338.73, 2114.87, 1448.16, 2172.06]
Order 12: number: 0.98 [106.08, 2257.42, 134.76, 2281.3]
Order 13: footer: 0.93 [339.27, 2255.7, 984.16, 2282.81]
```

## PPDocLayoutV4Model[[transformers.PPDocLayoutV4Model]]

#### transformers.PPDocLayoutV4Model[[transformers.PPDocLayoutV4Model]]

```python
transformers.PPDocLayoutV4Model(config: PPDocLayoutV4Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1328)

**Parâmetros:**

config ([PPDocLayoutV4Config](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo PP-DocLayoutV4 (composto por um backbone e um encoder-decoder) que produz estados ocultos brutos, sem nenhum head no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.PPDocLayoutV4Model.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1466)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando `image_processor_class`. Consulte `image_processor_class.__call__` para obter detalhes (`processor_class` usa `image_processor_class` para processar imagens).

pixel_mask (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar a execução de atenção em valores de pixels de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para pixels reais (ou seja, **não mascarados**), - 0 para pixels de preenchimento (ou seja, **mascarados**).  [O que são máscaras de atenção?](../glossary#attention-mask)

encoder_outputs (`torch.Tensor`, *opcional*) : Tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do codificador. Usado na cross-attention do decodificador.

labels (`list[Dict]` de comprimento `(batch_size,)`, *opcional*) : Não suportado: PP-DocLayoutV4 é apenas para inferência no Transformers.

**Retorna:** `PPDocLayoutV4ModelOutput` ou `tuple(torch.Tensor)`

Uma `PPDocLayoutV4ModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração (`None`) e das entradas.

O método forward do [PPDocLayoutV4Model](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4Model) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_queries, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do decodificador do modelo.
- **intermediate_hidden_states** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Estados ocultos intermediários empilhados (saída de cada camada do decodificador).
- **intermediate_reference_points** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, config.num_coords)`) -- Pontos de referência intermediários empilhados (quadriláteros refinados de cada camada do decodificador).
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **cross_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **init_reference_points** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_coords)`) -- Pontos de referência quadrados iniciais enviados através do decodificador do Transformer.
- **enc_topk_logits** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_labels)`) -- Logits de classe das propostas do codificador que foram selecionadas como consultas do decodificador.
- **enc_topk_bboxes** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_coords)`) -- Quadrados das propostas do codificador que foram selecionados como consultas do decodificador.
- **enc_outputs_class** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Logits de classe de cada proposta do codificador.
- **enc_outputs_coord_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_coords)`) -- Logits de quadrados de cada proposta do codificador.
- **denoising_meta_values** (`dict`, *opcional*) -- Dicionário extra para os valores relacionados ao denoising.
- **logits** (`torch.Tensor` de forma `(batch_size, num_queries, config.num_labels)`) -- Logits de classificação da última camada do decodificador.
- **relative_order_logits** (`torch.Tensor` de forma `(batch_size, config.num_queries, config.num_queries)`) -- Logits de ordem de leitura relativa em pares, após a fusão S2R opcional.
- **successor_order_logits** (`torch.Tensor` de forma `(batch_size, config.num_queries, config.num_queries)`) -- Logits de sucessor direto em pares (ROOR).

## PPDocLayoutV4Config[[transformers.PPDocLayoutV4Config]]

#### transformers.PPDocLayoutV4Config[[transformers.PPDocLayoutV4Config]]

```python
transformers.PPDocLayoutV4Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, initializer_range: float = 0.01, initializer_bias_prior_prob: float | None = None, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, tie_word_embeddings: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, freeze_backbone_batch_norms: bool = True, encoder_hidden_dim: int = 256, encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048), feat_strides: list[int] | tuple[int, ...] = (8, 16, 32), encoder_layers: int = 1, encoder_ffn_dim: int = 1024, encoder_attention_heads: int = 8, dropout: float | int = 0.0, activation_dropout: float | int = 0.0, encode_proj_layers: list[int] | tuple[int, ...] = (2,), positional_encoding_temperature: int = 10000, encoder_activation_function: str = 'gelu', activation_function: str = 'silu', eval_size: list[int] | tuple[int, int] | None = None, normalize_before: bool = False, hidden_expansion: float = 1.0, num_queries: int = 300, decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256), decoder_ffn_dim: int = 1024, num_feature_levels: int = 3, decoder_n_points: int = 4, decoder_layers: int = 6, decoder_attention_heads: int = 8, decoder_activation_function: str = 'relu', attention_dropout: float | int = 0.0, num_denoising: int = 100, anchor_image_size: list[int] | tuple[int, int] | None = None, disable_custom_kernels: bool = True, global_pointer_head_size: int = 64, gp_dropout_value: float | int = 0.1, hidden_size: int = 256, num_coords: int = 10, s2r_steps: int = 3, s2r_damping: float = 0.5, s2r_closure_weight_init: float = 0.0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/configuration_pp_doclayout_v4.py#L30)

**Parâmetros:**

is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não.

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

initializer_bias_prior_prob (`float`, *opcional*) : A probabilidade a priori usada pelo inicializador de viés para inicializar os vieses de `enc_score_head` e `class_embed`. Se `None`, o valor padrão é `1 / (num_labels + 1)`.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

batch_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de lote.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone.

freeze_backbone_batch_norms (`bool`, *opcional*, padrão `True`) : Se as camadas de normalização de lote no backbone devem ser congeladas.

encoder_hidden_dim (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

encoder_in_channels (`list`, *opcional*, padrão `[512, 1024, 2048]`) : Entrada de recursos em múltiplos níveis para o encoder.

feat_strides (`list[int]`, *opcional*, padrão `[8, 16, 32]`) : Passos usados em cada mapa de características.

encoder_layers (`int`, *opcional*, padrão `1`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

encoder_ffn_dim (`int`, *opcional*, padrão `1024`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador.

encoder_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.

dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

activation_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as ativações dentro da camada totalmente conectada.

encode_proj_layers (`list[int]`, *opcional*, padrão `[2]`) : Índices das camadas projetadas a serem usadas no codificador.

positional_encoding_temperature (`int`, *opcional*, padrão 10000) : O parâmetro de temperatura usado para criar as codificações posicionais.

encoder_activation_function (`str`, *opcional*, padrão `"gelu"`) : A função de ativação não linear (função ou string) no encoder e no pooler. Se for string, `"gelu"`, `"relu"`, `"silu"` e `"gelu_new"` são suportadas.

activation_function (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

eval_size (`tuple[int, int]`, *opcional*) : Altura e largura usadas para calcular a altura e a largura efetivas dos embeddings de posição após considerar o stride. Deve ser mantido como `None` para reproduzir a implementação de referência, que calcula os embeddings de posição dinamicamente.

normalize_before (`bool`, *opcional*, padrão `False`) : Determina se a normalização de camada deve ser aplicada na camada do codificador do transformer antes dos módulos de autoatenção e de avanço.

hidden_expansion (`float`, *opcional*, padrão 1.0) : Razão de expansão para aumentar o tamanho da dimensão de RepVGGBlock e CSPRepLayer.

num_queries (`int`, *opcional*, padrão 300) : Número de consultas de objeto.

decoder_in_channels (`list`, *opcional*, padrão `[256, 256, 256]`) : Dimensão dos recursos em múltiplos níveis para o decoder

decoder_ffn_dim (`int`, *opcional*, padrão 1024) : Dimensão da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador.

num_feature_levels (`int`, *opcional*, padrão 3) : O número de níveis de recursos de entrada.

decoder_n_points (`int`, *opcional*, padrão 4) : O número de chaves amostradas em cada nível de recurso para cada cabeça de atenção no decodificador.

decoder_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

decoder_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

decoder_activation_function (`str`, *opcional*, padrão `"relu"`) : A função de ativação não linear (função ou string) no decodificador. Se for string, `"gelu"`, `"relu"`, `"silu"` e `"gelu_new"` são suportadas.

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

num_denoising (`int`, *opcional*, padrão 100) : O número total de tarefas ou consultas de desruido a serem usadas para o desruido contrastivo.

anchor_image_size (`tuple[int, int]`, *opcional*) : Altura e largura da imagem de entrada usada durante a avaliação para gerar as âncoras de bounding box. Se for None, a geração automática de âncoras é aplicada.

disable_custom_kernels (`bool`, *opcional*, padrão `True`) : Se deve desativar kernels personalizados.

global_pointer_head_size (`int`, *opcional*, padrão 64) : O tamanho da cabeça do ponteiro global.

gp_dropout_value (`float`, *opcional*, padrão 0.1) : A probabilidade de dropout na cabeça de ponteiro global.

hidden_size (`int`, *opcional*, padrão 256) : Dimensão das camadas do decodificador, excluindo o codificador híbrido. Também pode ser lido como `d_model`, o nome usado pela linhagem RT-DETR da qual este modelo descende.

num_coords (`int`, *opcional*, padrão 10) : Tamanho da parametrização da caixa prevista pelas cabeças de bbox. O PP-DocLayoutV4 regressa um quadrilátero de quatro pontos codificado como `[center_x, center_y, dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4]` no espaço sigmoid, onde os deslocamentos dos cantos são deslocados por `+0.5`. Apenas `10` é suportado.

s2r_steps (`int`, *opcional*, padrão 3) : Número de etapas de propagação usadas para aproximar o fechamento transitivo da matriz de sucessores.

s2r_damping (`float`, *opcional*, padrão 0.5) : Fator de amortecimento aplicado a cada etapa adicional de propagação do fechamento transitivo.

s2r_closure_weight_init (`float`, *opcional*, padrão 0.0) : Valor inicial do gate aprendível que pondera o termo de fechamento. O padrão é `0.0`, de modo que um módulo de fusão não treinado seja numericamente idêntico ao uso apenas dos logits de ordem relativa.

Esta é a classe de configuração para armazenar a configuração de um PPDocLayoutV4Model. Ela é usada para instanciar um modelo Pp Doclayout V4 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [PaddlePaddle/PP-DocLayoutV4_safetensors](https://huggingface.co/PaddlePaddle/PP-DocLayoutV4_safetensors)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplos:

```python
>>> from transformers import PPDocLayoutV4Config, PPDocLayoutV4ForObjectDetection

>>> # Initializing a PP-DocLayoutV4 configuration
>>> configuration = PPDocLayoutV4Config()

>>> # Initializing a model (with random weights) from the configuration
>>> model = PPDocLayoutV4ForObjectDetection(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## PPDocLayoutV4ImageProcessor[[transformers.PPDocLayoutV4ImageProcessor]]

#### transformers.PPDocLayoutV4ImageProcessor[[transformers.PPDocLayoutV4ImageProcessor]]

```python
transformers.PPDocLayoutV4ImageProcessor(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/image_processing_pp_doclayout_v4.py#L36)

**Parâmetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 800, 'width': 800}`): Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0, 0, 0]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[1, 1, 1]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. --

Constrói um processador de imagem PPDocLayoutV4ImageProcessor.

disable_grouping (`bool`, *kwargs*, *opcional*): Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*): O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

#### preprocess[[transformers.PPDocLayoutV4ImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

image_like_kwargs (`dict[str, Any]`, *opcional*) : Sinalizador do desenvolvedor para entradas adicionais semelhantes a imagens que também serão pré-processadas. Use isso apenas se a passagem das entradas como kwarg não funcionar. Por exemplo, `preprocess(images, masks=masks)` é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos, `preprocess(images, image_like_inputs={"masks": masks})` pode ser usado em vez disso.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem.

rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

**Retorna:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

Pré-processa uma imagem ou um lote de imagens.

#### post_process_object_detection[[transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/image_processing_pp_doclayout_v4.py#L121)

**Parâmetros:**

outputs (`PPDocLayoutV4ForObjectDetectionOutput`) : Saídas brutas do modelo.

threshold (`float`, *opcional*, padrão 0.5) : Limiar de pontuação para manter as previsões de detecção de objetos.

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]`) : Tensor de forma `(batch_size, 2)` ou lista de tuplas (`(height, width)`) com o tamanho alvo de cada imagem no lote.

**Retorna:** `list[Dict]`

Uma lista de dicionários, um por imagem, cada um contendo os `scores`, `labels`, `boxes`, `polygon_points` e `order_seq` previstos pelo modelo. As previsões são ordenadas pela ordem de leitura, portanto `order_seq` é não decrescente (uma consulta selecionada sob vários rótulos mantém um único rank).

Converte a saída bruta de [PPDocLayoutV4ForObjectDetection](/docs/transformers/main/pt/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ForObjectDetection) em quadriláteros finais, caixas delimitadoras no formato `(top_left_x, top_left_y, bottom_right_x, bottom_right_y)` e classificações de ordem de leitura. Suporta apenas PyTorch.