# Processador de imagem

Um image processor é responsável por carregar imagens (opcionalmente), preparar os recursos de entrada para modelos de visão e realizar o pós-processamento de suas saídas. Isso inclui transformações como redimensionamento, normalização e conversão para tensores do PyTorch e do Numpy. Também pode incluir o pós-processamento específico do modelo, como a conversão de logits em máscaras de segmentação.

Os processadores de imagem utilizam uma arquitetura baseada em backends. A hierarquia de classes é:

- [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor) — classe base abstrata (apenas para compatibilidade reversa; não instancie diretamente)
  - [TorchvisionBackend](/docs/transformers/main/pt/main_classes/image_processor#transformers.TorchvisionBackend) — o backend **padrão** baseado em [torchvision](https://pytorch.org/vision/stable/index.html). Acelerado por GPU e significativamente mais rápido que o backend PIL. Todos os modelos expõem uma classe `<Model>ImageProcessor` que herda dele.
  - [PilBackend](/docs/transformers/main/pt/main_classes/image_processor#transformers.PilBackend) — o backend alternativo baseado em PIL/NumPy. Portável e exclusivo para CPU. Disponível apenas para modelos mais antigos por meio de uma classe `<Model>ImageProcessorPil`; útil quando é necessária paridade numérica exata com a implementação original.

Ambos os backends expõem a mesma API. Use o atributo `backend` para inspecionar qual backend um processador carregado utiliza (por exemplo, `processor.backend == "torchvision"`).

Passe `backend` para [AutoImageProcessor.from_pretrained()](/docs/transformers/main/pt/model_doc/auto#transformers.AutoImageProcessor.from_pretrained) para selecionar um backend. Quando `backend` é omitido (o padrão), o torchvision é escolhido se estiver instalado; caso contrário, o PIL é usado. Alguns modelos que usam interpolação Lanczos (Chameleon, Flava, Idefics3, SmolVLM) são uma exceção e usam PIL por padrão quando o torchvision < 0.27. Forçar `backend="torchvision"` para esses modelos com torchvision < 0.27 recorre à interpolação BICUBIC, pois o torchvision suporta Lanczos para tensors apenas a partir da versão 0.27.

```python
from transformers import AutoImageProcessor

# Default: picks torchvision if available, otherwise pil
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")

# Explicitly request torchvision
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50", backend="torchvision")

# Explicitly request PIL
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50", backend="pil")
```

Ao usar o backend torchvision, você pode definir o argumento `device` para especificar o dispositivo em que o processamento deve ser realizado. Por padrão, o processamento é feito no mesmo dispositivo dos inputs, caso os inputs sejam tensors, ou na CPU, caso contrário.

```python
import torch
from torchvision.io import read_image
from transformers import DetrImageProcessor

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

images = read_image("image.jpg")
processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
images_processed = processor(images, return_tensors="pt", device=device)
```

Aqui estão algumas comparações de velocidade entre os backends torchvision e PIL para os modelos `DETR` e `RT-DETR`, e como eles impactam o tempo total de inferência:

  

  

  

  

Esses benchmarks foram executados em uma [instância AWS EC2 g5.2xlarge](https://aws.amazon.com/ec2/instance-types/g5/), utilizando uma GPU NVIDIA A10G Tensor Core.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

#### transformers.ImageProcessingMixin[[transformers.ImageProcessingMixin]]

```python
transformers.ImageProcessingMixin(**kwargs)
```

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

Este é um mixin de processador de imagem usado para fornecer funcionalidade de salvamento/carregamento para extratores de recursos sequenciais e de imagem.

#### from_pretrained[[transformers.ImageProcessingMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

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

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Pode ser:  - uma string, o *model id* de um image_processor pré-treinado hospedado em um repositório de modelos no huggingface.co. - um caminho para um *diretório* contendo um arquivo de image processor salvo usando o método [save_pretrained()](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained), por exemplo, `./my_model_directory/`. - um caminho para um arquivo JSON de image processor salvo *file*, por exemplo, `./my_model_directory/preprocessor_config.json`.

cache_dir (`str` ou `os.PathLike`, *opcional*) : Caminho para um diretório em que o processador de imagem de um modelo pré-treinado baixado deve ser armazenado em cache, caso o cache padrão não deva ser usado.

force_download (`bool`, *opcional*, padrão `False`) : Indica se deve forçar o (re)download dos arquivos do processador de imagem e sobrescrever as versões em cache, caso existam.

proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Os proxies são usados em cada solicitação.

token (`str` ou `bool`, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, ou não especificado, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag ou um id de commit, pois usamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto `revision` pode ser qualquer identificador permitido pelo git.     Para testar um pull request que você fez no Hub, você pode passar `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opcional*, padrão `False`) : Se `False`, esta função retorna apenas o objeto final do processador de imagem. Se `True`, esta função retorna uma `Tuple(image_processor, unused_kwargs)`, onde *unused_kwargs* é um dicionário composto pelos pares de chave/valor cujas chaves não são atributos do processador de imagem: ou seja, a parte de `kwargs` que não foi usada para atualizar `image_processor` e é, de outra forma, ignorada.

subfolder (`str`, *opcional*, padrão `""`) : Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co, você pode especificar o nome da pasta aqui.

kwargs (`dict[str, Any]`, *opcional*) : Os valores em kwargs de quaisquer chaves que sejam atributos do processador de imagem serão usados para substituir os valores carregados. O comportamento em relação a pares de chave/valor cujas chaves *não* são atributos do processador de imagem é controlado pelo parâmetro de palavra-chave `return_unused_kwargs`.

**Retorna:**

Um processador de imagens do tipo [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instancie um tipo de [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin) a partir de um processador de imagem.

Exemplos:

```python
# We can't instantiate directly the base class *ImageProcessingMixin* so let's show the examples on a
# derived class: *CLIPImageProcessor*
image_processor = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32"
)  # Download image_processing_config from huggingface.co and cache.
image_processor = CLIPImageProcessor.from_pretrained(
    "./test/saved_model/"
)  # E.g. image processor (or model) was saved using *save_pretrained('./test/saved_model/')*
image_processor = CLIPImageProcessor.from_pretrained("./test/saved_model/preprocessor_config.json")
image_processor = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32", do_normalize=False, foo=False
)
assert image_processor.do_normalize is False
image_processor, unused_kwargs = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32", do_normalize=False, foo=False, return_unused_kwargs=True
)
assert image_processor.do_normalize is False
assert unused_kwargs == {"foo": False}
```

#### save_pretrained[[transformers.ImageProcessingMixin.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs)
```

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

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório onde o arquivo JSON do processador de imagem será salvo (será criado se não existir).

push_to_hub (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com `repo_id` (por padrão, será usado o nome de `save_directory` no seu namespace).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Salve um objeto de processador de imagens no diretório `save_directory` para que ele possa ser recarregado usando o método de classe [from_pretrained()](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin.from_pretrained).

## BatchFeature[[transformers.BatchFeature]]

#### transformers.BatchFeature[[transformers.BatchFeature]]

```python
transformers.BatchFeature(data: dict[str, typing.Any] | None = None, tensor_type: None | str | transformers.utils.generic.TensorType = None, skip_tensor_conversion: list[str] | set[str] | None = None)
```

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

**Parâmetros:**

data (`dict`, *opcional*) : Dicionário de listas/arrays/tensors retornados pelos métodos __call__/pad ('input_values', 'attention_mask', 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.

skip_tensor_conversion (`list[str]` ou `set[str]`, *opcional*) : Lista ou conjunto de chaves que não devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.

Contém a saída dos métodos [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) e `__call__` específicos do extrator de recursos.

Esta classe é derivada de um dicionário python e pode ser usada como um dicionário.

#### convert_to_tensors[[transformers.BatchFeature.convert_to_tensors]]

```python
convert_to_tensors(tensor_type: str | transformers.utils.generic.TensorType | None = None, skip_tensor_conversion: list[str] | set[str] | None = None)
```

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

**Parâmetros:**

tensor_type (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : O tipo de tensores a ser usado. Se for `str`, deve ser um dos valores da enumeração [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType). Se for `None`, nenhuma modificação é feita.

skip_tensor_conversion (`list[str]` ou `set[str]`, *opcional*) : Lista ou conjunto de chaves que não devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.

Converta o conteúdo interno em tensores.

Observação: Valores que não possuem uma estrutura semelhante a um array (por exemplo, strings, dicts, listas de strings) são automaticamente ignorados e não serão convertidos em tensors. Arrays irregulares (listas de arrays com comprimentos diferentes) ainda são tentados, embora possam gerar erros durante a conversão.

#### para[[transformers.BatchFeature.to]]

```python
to(*args, **kwargs)
```

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

**Parâmetros:**

args (`Tuple`) : Será passado para a função `to(...)` dos tensores.

kwargs (`Dict`, *opcional*) : Será passado para a função `to(...)` dos tensores. Para habilitar a transferência de dados assíncrona, defina a flag `non_blocking` em `kwargs` (padrão: `False`).

**Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature)

A mesma instância após a modificação.

Envie todos os valores para o dispositivo chamando `v.to(*args, **kwargs)` (somente PyTorch). Isso deve suportar o cast em diferentes `dtypes` e o envio do `BatchFeature` para um `device` diferente.

## BaseImageProcessor[[transformers.BaseImageProcessor]]

#### transformers.BaseImageProcessor[[transformers.BaseImageProcessor]]

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

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

Classe base para processadores de imagem com uma arquitetura de backend baseada em herança.

Esta classe define o pipeline de pré-processamento: validação de kwargs, preparação da entrada e despacho para o método `_preprocess` do backend. As subclasses de backend (`TorchvisionBackend`, `PilBackend`) herdam desta classe e implementam as operações de imagem reais (redimensionar, recortar, reescalar, normalizar, etc.). Os processadores de imagem específicos de um modelo, por sua vez, herdam da classe de backend apropriada.

Visão geral da arquitetura ---------------------

A hierarquia de classes é:

BaseImageProcessor (esta classe) ├── TorchvisionBackend    (acelerado por GPU, torch.Tensor) │   └── ModelImageProcessor (ex.: LlavaNextImageProcessor) └── PilBackend            (CPU portátil, np.ndarray) └── ModelImageProcessorPil (ex.: CLIPImageProcessorPil)

O fluxo de pré-processamento é:

__call__() → preprocess() → _preprocess_image_like_inputs() → _prepare_image_like_inputs() (chama process_image para cada imagem) → _preprocess() (operações em lote: redimensionar, recortar, etc.)

- `process_image`: Implementado pelos backends. Converte uma única entrada bruta (PIL, NumPy ou Tensor) para o formato de trabalho do backend (torch.Tensor ou np.ndarray), gerencia a conversão para RGB e a reordenação dos canais.
- `_preprocess`: Implementado pelos backends. Executa o processamento real do lote (redimensionar, recorte central, reescalar, normalizar, preencher) e retorna um `BatchFeature`.

Implementação básica --------------------

Para processadores que precisam apenas de operações padrão (redimensionar, recorte central, reescalar, normalizar), herde de um backend e defina atributos de classe:

from transformers.image_processing_backends import PilBackend

class MyImageProcessorPil(PilBackend): resample = PILImageResampling.BILINEAR image_mean = IMAGENET_DEFAULT_MEAN image_std = IMAGENET_DEFAULT_STD size = {"height": 224, "width": 224} do_resize = True do_rescale = True do_normalize = True

O método `_preprocess` do backend trata o pipeline padrão automaticamente.

Processamento personalizado -----------------

Para processadores que exigem lógica personalizada (por exemplo, processamento baseado em patches, múltiplos tipos de entrada), sobrescreva `_preprocess` no processador específico do seu modelo. O método `_preprocess` recebe imagens já preparadas (convertidas para o formato do backend com a ordem de canais primeiro) e executa o processamento real:

class MyImageProcessor(TorchvisionBackend): def _preprocess(self, images, do_resize, size, do_normalize, image_mean, image_std, **kwargs):
# Agrupar imagens por forma para operações em lote eficientes
grouped_images, grouped_images_index = group_images_by_shape(images) processed_groups = {} for shape, stacked_images in grouped_images.items(): if do_resize: stacked_images = self.resize(stacked_images, size=size) if do_normalize: stacked_images = self.normalize(stacked_images, mean=image_mean, std=image_std) processed_groups[shape] = stacked_images processed_images = reorder_images(processed_groups, grouped_images_index) return BatchFeature(data={"pixel_values": processed_images})

Para processadores que lidam com múltiplos tipos de entrada (por exemplo, imagens + mapas de segmentação), sobrescreva `_preprocess_image_like_inputs`:

def _preprocess_image_like_inputs( self, images: ImageInput, segmentation_maps: ImageInput | None = None, **kwargs, ) -> BatchFeature: images = self._prepare_image_like_inputs(images, **kwargs) batch_feature = self._preprocess(images, **kwargs)

if segmentation_maps is not None: maps = self._prepare_image_like_inputs(segmentation_maps, **kwargs) batch_feature["labels"] = self._preprocess(maps, **kwargs).pixel_values

return batch_feature

Estendendo o Comportamento do Backend --------------------------

Para personalizar operações para um backend específico, crie uma subclasse do backend e sobrescreva seus métodos:

from transformers.image_processing_backends import TorchvisionBackend, PilBackend

class MyTorchvisionProcessor(TorchvisionBackend): def resize(self, image, size, **kwargs):
# Lógica de redimensionamento personalizada para torchvision
return super().resize(image, size, **kwargs)

class MyPilProcessor(PilBackend): def resize(self, image, size, **kwargs):
# Lógica de redimensionamento personalizada para PIL
return super().resize(image, size, **kwargs)

Parâmetros personalizados -----------------

Para adicionar parâmetros além de `ImagesKwargs`, crie uma classe de kwargs personalizada e defina-a como `valid_kwargs`:

class MyImageProcessorKwargs(ImagesKwargs): custom_param: int | None = None

class MyImageProcessor(TorchvisionBackend): valid_kwargs = MyImageProcessorKwargs custom_param = 10  # default value

Notas principais ---------

- A seleção do backend é feita no nível da classe: herde de `TorchvisionBackend` ou `PilBackend`
- Os backends recebem imagens como `torch.Tensor` (Torchvision) ou `np.ndarray` (PIL), sempre com os canais primeiro
- Todas as imagens têm a dimensão de canal primeiro durante o processamento, independentemente do backend
- Argumentos não fornecidos pelos usuários assumem os valores dos atributos da classe
- As classes de backend encapsulam a lógica específica do backend (redimensionamento, normalização, etc.) e podem ser substituídas

#### center_crop[[transformers.BaseImageProcessor.center_crop]]

```python
center_crop(image: ndarray, size: dict, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs)
```

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

**Parâmetros:**

image (`np.ndarray`) : Imagem para recorte central.

size (`dict[str, int]`) : Tamanho da imagem de saída.

data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de saída. Se não definido, o formato da dimensão de canal da imagem de entrada é utilizado. 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).

input_data_format (`ChannelDimension` ou `str`, *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).

Centraliza o recorte de uma imagem para `(size["height"], size["width"])`. Se o tamanho de entrada for menor que `crop_size` em qualquer borda, a imagem é preenchida com zeros e, em seguida, recortada no centro.

#### normalizar[[transformers.BaseImageProcessor.normalize]]

```python
normalize(image: ndarray, mean: float | collections.abc.Iterable[float], std: float | collections.abc.Iterable[float], data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs)
```

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

**Parâmetros:**

image (`np.ndarray`) : Imagem a ser normalizada.

mean (`float` ou `Iterable[float]`) : Média da imagem a ser usada para normalização.

std (`float` ou `Iterable[float]`) : Desvio padrão da imagem a ser usado para normalização.

data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de saída. Se não definido, o formato da dimensão de canal da imagem de entrada é utilizado. 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).

input_data_format (`ChannelDimension` ou `str`, *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).

**Retorna:** `np.ndarray`

A imagem normalizada.

Normalizar uma imagem. image = (image - image_mean) / image_std.

#### preprocess[[transformers.BaseImageProcessor.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.

#### process_image[[transformers.BaseImageProcessor.process_image]]

```python
process_image(*args, **kwargs)
```

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

Processa uma única imagem bruta para o formato de trabalho do backend.

Implementado por subclasses de backend (`TorchvisionBackend`, `PilBackend`). Converte uma entrada bruta (imagem PIL, array NumPy ou Tensor torch) para o formato interno do backend (`torch.Tensor` para Torchvision, `np.ndarray` para PIL), trata a conversão para RGB e garante a ordem de canais primeiro.

#### rescale[[transformers.BaseImageProcessor.rescale]]

```python
rescale(image: ndarray, scale: float, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs)
```

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

**Parâmetros:**

image (`np.ndarray`) : Imagem para redimensionar.

scale (`float`) : O fator de escala para reescalar os valores de pixels.

data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de saída. Se não definido, o formato da dimensão de canal da imagem de entrada é utilizado. 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).

input_data_format (`ChannelDimension` ou `str`, *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).

**Retorna:** `np.ndarray`

A imagem redimensionada.

Redimensiona uma imagem por um fator de escala. image = image * scale.

## TorchvisionBackend[[transformers.TorchvisionBackend]]

#### transformers.TorchvisionBackend[[transformers.TorchvisionBackend]]

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

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

Backend Torchvision para processamento de imagens em lote com aceleração por GPU.

#### center_crop[[transformers.TorchvisionBackend.center_crop]]

```python
center_crop(image: torch.Tensor, size: SizeDict, **kwargs)
```

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

Centralizar o recorte de uma imagem usando Torchvision.

#### convert_to_rgb[[transformers.TorchvisionBackend.convert_to_rgb]]

```python
convert_to_rgb(image: torch.Tensor, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

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

Converte uma imagem para o formato RGB.

#### fetch_images[[transformers.TorchvisionBackend.fetch_images]]

```python
fetch_images(image_url_or_urls: str | list[str] | list[list[str]])
```

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

Converte uma única URL ou um conjunto de URLs / caminhos em objetos `torch.Tensor`.

Objetos de imagem já válidos (tensors, arrays numpy, Imagens PIL) são passados sem alterações, de modo que os chamadores que pré-carregam imagens não sejam afetados.

#### normalizar[[transformers.TorchvisionBackend.normalize]]

```python
normalize(image: torch.Tensor, mean: float | collections.abc.Iterable[float], std: float | collections.abc.Iterable[float], inplace: bool = False, **kwargs)
```

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

Normalizar uma imagem usando Torchvision.

#### pad[[transformers.TorchvisionBackend.pad]]

```python
pad(images: list, pad_size: SizeDict = None, fill_value: int | None = 0, padding_mode: str | None = 'constant', return_mask: bool = False, disable_grouping: bool | None = False, is_nested: bool | None = False, **kwargs)
```

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

Preencha as imagens usando Torchvision com operações em lote.

#### process_image[[transformers.TorchvisionBackend.process_image]]

```python
process_image(image: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], do_convert_rgb: bool | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, device: typing.Optional[ForwardRef('torch.device')] = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

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

Processa uma única imagem para o backend torchvision.

#### rescale[[transformers.TorchvisionBackend.rescale]]

```python
rescale(image: torch.Tensor, scale: float, **kwargs)
```

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

Redimensione uma imagem por um fator de escala usando Torchvision.

#### rescale_and_normalize[[transformers.TorchvisionBackend.rescale_and_normalize]]

```python
rescale_and_normalize(images: torch.Tensor, do_rescale: bool, rescale_factor: float, do_normalize: bool, image_mean: float | list[float], image_std: float | list[float])
```

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

Redimensione e normalize imagens usando Torchvision (fuso para eficiência).

#### resize[[transformers.TorchvisionBackend.resize]]

```python
resize(image: torch.Tensor, size: SizeDict, resample: PILImageResampling | tvF.InterpolationMode | int | None = None, antialias: bool = True, **kwargs)
```

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

Redimensione uma imagem usando Torchvision.

## PilBackend[[transformers.PilBackend]]

#### transformers.PilBackend[[transformers.PilBackend]]

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

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

Backend PIL/NumPy para processamento de imagens portátil apenas em CPU.

#### center_crop[[transformers.PilBackend.center_crop]]

```python
center_crop(image: ndarray, size: SizeDict, **kwargs)
```

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

Centralizar o recorte de uma imagem usando NumPy.

#### convert_to_rgb[[transformers.PilBackend.convert_to_rgb]]

```python
convert_to_rgb(image: ndarray, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

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

Converte uma imagem para o formato RGB.

#### normalizar[[transformers.PilBackend.normalize]]

```python
normalize(image: ndarray, mean: float | collections.abc.Iterable[float], std: float | collections.abc.Iterable[float], **kwargs)
```

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

Normalizar uma imagem usando NumPy.

#### pad[[transformers.PilBackend.pad]]

```python
pad(images: list, pad_size: SizeDict = None, fill_value: int | None = 0, padding_mode: str | None = 'constant', return_mask: bool = False, **kwargs)
```

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

Preencha as imagens até o tamanho especificado usando NumPy.

#### process_image[[transformers.PilBackend.process_image]]

```python
process_image(image: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], do_convert_rgb: bool | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

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

Processa uma única imagem para o backend PIL.

#### rescale[[transformers.PilBackend.rescale]]

```python
rescale(image: ndarray, scale: float, **kwargs)
```

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

Redimensione uma imagem por um fator de escala usando NumPy.

#### resize[[transformers.PilBackend.resize]]

```python
resize(image: ndarray, size: SizeDict, resample: PILImageResampling | None = None, reducing_gap: int | None = None, **kwargs)
```

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

Redimensione uma imagem usando PIL/NumPy.