# Procesador de imágenes

Un procesador de imágenes se encarga de cargar imágenes (opcionalmente), preparar las características de entrada para modelos de visión y realizar el posprocesamiento de sus salidas. Esto incluye transformaciones como el redimensionado, la normalización y la conversión a tensores de PyTorch y Numpy. También puede incluir el posprocesamiento específico del modelo, como la conversión de logits en máscaras de segmentación.

Los procesadores de imágenes utilizan una arquitectura basada en backends. La jerarquía de clases es:

- [BaseImageProcessor](/docs/transformers/main/es/main_classes/image_processor#transformers.BaseImageProcessor) — clase base abstracta (solo para compatibilidad hacia atrás; no instanciar directamente)
  - [TorchvisionBackend](/docs/transformers/main/es/main_classes/image_processor#transformers.TorchvisionBackend) — el backend **predeterminado** con soporte de [torchvision](https://pytorch.org/vision/stable/index.html). Acelerado por GPU y significativamente más rápido que el backend PIL. Todos los modelos exponen una clase `<Model>ImageProcessor` que hereda de él.
  - [PilBackend](/docs/transformers/main/es/main_classes/image_processor#transformers.PilBackend) — el backend alternativo de PIL/NumPy. Portable, solo CPU. Solo disponible para modelos antiguos a través de una clase `<Model>ImageProcessorPil`; útil cuando se requiere una paridad numérica exacta con la implementación original.

Ambos backends exponen la misma API. Utilice el atributo `backend` para inspeccionar qué backend utiliza un procesador cargado (p. ej. `processor.backend == "torchvision"`).

Pase `backend` a [AutoImageProcessor.from_pretrained()](/docs/transformers/main/es/model_doc/auto#transformers.AutoImageProcessor.from_pretrained) para seleccionar un backend. Cuando se omite `backend` (el valor predeterminado), se elige torchvision si está instalado; de lo contrario, se utiliza PIL. Algunos modelos que usan interpolación Lanczos (Chameleon, Flava, Idefics3, SmolVLM) son una excepción y usan PIL de forma predeterminada cuando torchvision < 0.27. Forzar `backend="torchvision"` para estos modelos con torchvision < 0.27 recurre a la interpolación BICUBIC, ya que torchvision solo admite Lanczos para tensores a partir de la versión 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")
```

Al usar el backend torchvision, puede establecer el argumento `device` para especificar el dispositivo en el que se debe realizar el procesamiento. De forma predeterminada, el procesamiento se realiza en el mismo dispositivo que las entradas si estas son tensores, o en la CPU en caso contrario.

```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)
```

A continuación se muestran algunas comparaciones de velocidad entre los backends de torchvision y PIL para los modelos `DETR` y `RT-DETR`, y cómo impactan en el tiempo total de inferencia:

  

  

  

  

Estos benchmarks se ejecutaron en una [instancia AWS EC2 g5.2xlarge](https://aws.amazon.com/ec2/instance-types/g5/), utilizando una GPU NVIDIA A10G Tensor Core.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

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

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

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

Esta es una mezcla de procesador de imágenes que se utiliza para proporcionar funcionalidad de guardado/carga para extractores de características secuenciales y de imágenes.

#### 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)
```

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

**Parámetros:**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained image_processor hosted inside a model repo on huggingface.co. - a path to a *directory* containing a image processor file saved using the [save_pretrained()](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved image processor JSON *file*, e.g., `./my_model_directory/preprocessor_config.json`.

cache_dir (`str` o `os.PathLike`, *opcional*) : Ruta a un directorio en el que se debe almacenar en caché el procesador de imágenes de un modelo preentrenado descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los archivos del procesador de imágenes y sobrescribir las versiones en caché si existen.

proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Los proxies se utilizan en cada solicitud.

token (`str` o `bool`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, o no se especifica, se usará el token generado al ejecutar `hf auth login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git. Para probar una pull request que hayas realizado en el Hub, puedes pasar `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opcional*, valor predeterminado `False`) : Si es `False`, esta función devuelve únicamente el objeto de procesador de imágenes final. Si es `True`, esta función devuelve una `Tuple(image_processor, unused_kwargs)` donde *unused_kwargs* es un diccionario que consiste en pares clave/valor cuyas claves no son atributos del procesador de imágenes: es decir, la parte de `kwargs` que no se ha utilizado para actualizar `image_processor` y que se ignora de lo contrario.

subfolder (`str`, *opcional*, valor predeterminado `""`) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co, puede especificar aquí el nombre de la carpeta.

kwargs (`dict[str, Any]`, *opcional*) : Los valores en kwargs de cualquier clave que sea un atributo del procesador de imágenes se utilizarán para sobrescribir los valores cargados. El comportamiento respecto a los pares clave/valor cuyas claves *no* son atributos del procesador de imágenes se controla mediante el parámetro de palabra clave `return_unused_kwargs`.

**Devuelve:**

Un procesador de imágenes de tipo [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instanciar un tipo de [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin) desde un procesador de imágenes.

Ejemplos:

```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)
```

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

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el archivo JSON del procesador de imágenes (se creará si no existe).

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/main/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarde un objeto de procesador de imágenes en el directorio `save_directory` para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/transformers/main/es/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)
```

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

**Parámetros:**

data (`dict`, *opcional*) : Diccionario de listas/arrays/tensores devueltos por los métodos __call__/pad ('input_values', 'attention_mask', etc.).

tensor_type (`Union[None, str, TensorType]`, *opcional*) : Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

skip_tensor_conversion (`list[str]` o `set[str]`, *opcional*) : Lista o conjunto de claves que no deben convertirse en tensores, incluso cuando se especifica `tensor_type`.

Contiene la salida de los métodos [pad()](/docs/transformers/main/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) y `__call__` específicos del extractor de características.

Esta clase se deriva de un diccionario de Python y puede usarse como un diccionario.

#### 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)
```

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

**Parámetros:**

tensor_type (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : El tipo de tensores a utilizar. Si es `str`, debe ser uno de los valores de la enumeración [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType). Si es `None`, no se realiza ninguna modificación.

skip_tensor_conversion (`list[str]` o `set[str]`, *opcional*) : Lista o conjunto de claves que no deben convertirse en tensores, incluso cuando se especifica `tensor_type`.

Convierte el contenido interno en tensores.

Nota: Los valores que no tienen una estructura similar a un array (p. ej., cadenas, diccionarios, listas de cadenas) se omiten automáticamente y no se convierten en tensores. Se intenta convertir los arrays irregulares (listas de arrays con longitudes diferentes), aunque pueden generar errores durante la conversión.

#### a[[transformers.BatchFeature.to]]

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

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

**Parámetros:**

args (`Tuple`) : Se pasará a la función `to(...)` de los tensores.

kwargs (`Dict`, *opcional*) : Se pasará a la función `to(...)` de los tensores. Para habilitar la transferencia de datos asíncrona, establezca la bandera `non_blocking` en `kwargs` (el valor predeterminado es `False`).

**Devuelve:** [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature)

La misma instancia después de la modificación.

Envíe todos los valores al dispositivo llamando a `v.to(*args, **kwargs)` (solo PyTorch). Esto debería admitir el cambio a distintos `dtypes` y enviar el `BatchFeature` a un `device` diferente.

## BaseImageProcessor[[transformers.BaseImageProcessor]]

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

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

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

Clase base para procesadores de imágenes con una arquitectura de backend basada en herencia.

Esta clase define el pipeline de preprocesamiento: validación de kwargs, preparación de la entrada y despacho al método `_preprocess` del backend. Las subclases de backend (`TorchvisionBackend`, `PilBackend`) heredan de esta clase e implementan las operaciones de imagen reales (redimensionar, recortar, reescalar, normalizar, etc.). Los procesadores de imagen específicos de un modelo heredan de la clase de backend correspondiente.

Resumen de la arquitectura ---------------------

La jerarquía de clases es:

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

El flujo de preprocesamiento es:

__call__() → preprocess() → _preprocess_image_like_inputs() → _prepare_image_like_inputs() (llama a process_image por imagen) → _preprocess() (operaciones por lote: redimensionar, recortar, etc.)

- `process_image`: Implementado por los backends. Convierte una sola entrada cruda (PIL, NumPy o Tensor) al formato de trabajo del backend (torch.Tensor o np.ndarray), y gestiona la conversión a RGB y el reordenamiento de canales.
- `_preprocess`: Implementado por los backends. Realiza el procesamiento por lotes (redimensionar, recorte centrado, reescalar, normalizar, rellenar) y devuelve un `BatchFeature`.

Implementación básica --------------------

Para procesadores que solo necesitan operaciones estándar (redimensionar, recorte centrado, reescalar, normalizar), herede de un backend y defina atributos de clase:

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

El método `_preprocess` del backend gestiona el pipeline estándar de forma automática.

Procesamiento personalizado -----------------

Para los procesadores que requieren lógica personalizada (p. ej., procesamiento por parches, múltiples tipos de entrada), sobrescribe `_preprocess` en el procesador específico de tu modelo. El método `_preprocess` recibe imágenes ya preparadas (convertidas al formato del backend con el orden de canales primero) y realiza el procesamiento real:

class MyImageProcessor(TorchvisionBackend): def _preprocess(self, images, do_resize, size, do_normalize, image_mean, image_std, **kwargs):
# Agrupar imágenes por forma para operaciones por lotes 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 procesadores que manejan varios tipos de entrada (p. ej., imágenes + mapas de segmentación), sobrescribe `_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

Extender el comportamiento del backend --------------------------

Para personalizar las operaciones de un backend específico, subclase el backend y sobrescribe sus métodos:

from transformers.image_processing_backends import TorchvisionBackend, PilBackend

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

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

Parámetros personalizados -----------------

Para añadir parámetros además de `ImagesKwargs`, cree una clase de kwargs personalizada y establézcala como `valid_kwargs`:

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

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

Notas clave ---------

- La selección del backend se realiza a nivel de clase: hereda de `TorchvisionBackend` o `PilBackend`
- Los backends reciben las imágenes como `torch.Tensor` (Torchvision) o `np.ndarray` (PIL), siempre con los canales al inicio
- Todas las imágenes tienen la dimensión de canal al principio durante el procesamiento, independientemente del backend.
- Los argumentos que no son proporcionados por los usuarios se establecen en los valores de los atributos de la clase
- Las clases de backend encapsulan la lógica específica del backend (redimensionar, normalizar, etc.) y se pueden sobrescribir

#### 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)
```

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

**Parámetros:**

image (`np.ndarray`) : Imagen para recortar al centro.

size (`dict[str, int]`) : Tamaño de la imagen de salida.

data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de salida. Si no se establece, se utiliza el formato de la dimensión de canales de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels).

input_data_format (`ChannelDimension` o `str`, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels).

Recorta una imagen por el centro a `(size["height"], size["width"])`. Si el tamaño de entrada es menor que `crop_size` en cualquier borde, la imagen se rellena con 0 y luego se recorta por el centro.

#### normalize[[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)
```

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

**Parámetros:**

image (`np.ndarray`) : Imagen a normalizar.

mean (`float` o `Iterable[float]`) : Media de la imagen a utilizar para la normalización.

std (`float` o `Iterable[float]`) : Desviación estándar de la imagen a utilizar para la normalización.

data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de salida. Si no se establece, se utiliza el formato de la dimensión de canales de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels).

input_data_format (`ChannelDimension` o `str`, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels).

**Devuelve:** `np.ndarray`

La imagen normalizada.

Normaliza una imagen. 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'>)
```

[Fuente](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]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`.

image_like_kwargs (`dict[str, Any]`, *opcional*) : Bandera para desarrolladores destinada a entradas adicionales similares a imágenes que también se preprocesarán. Utilice esto solo si pasar las entradas como kwarg no funciona. Por ejemplo, `preprocess(images, masks=masks)` es la opción preferida, pero puede provocar problemas de prioridad de argumentos en algunos modelos. En esos casos, se puede usar `preprocess(images, image_like_inputs={"masks": masks})` en su lugar.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo.

default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

**Devuelve:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

Preprocesa una imagen o un lote de imágenes.

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

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

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

Procesa una imagen cruda individual al formato de trabajo del backend.

Implementado por subclases del backend (`TorchvisionBackend`, `PilBackend`). Convierte una entrada cruda (imagen PIL, matriz NumPy o tensor torch) al formato interno del backend (`torch.Tensor` para Torchvision, `np.ndarray` para PIL), gestiona la conversión a RGB y garantiza el orden de canales primero.

#### 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)
```

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

**Parámetros:**

image (`np.ndarray`) : Imagen que se va a reescalar.

scale (`float`) : Factor de escala para reescalar los valores de píxel.

data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de salida. Si no se establece, se utiliza el formato de la dimensión de canales de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels).

input_data_format (`ChannelDimension` o `str`, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels).

**Devuelve:** `np.ndarray`

La imagen reescalada.

Escala una imagen por un factor de escala. image = image * scale.

## TorchvisionBackend[[transformers.TorchvisionBackend]]

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

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

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

Backend de Torchvision para el procesamiento por lotes de imágenes acelerado por GPU.

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

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

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

Recortar el centro de una imagen 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)
```

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

Convierte una imagen al formato RGB.

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

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

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

Convierte una URL o ruta individual, o una lista de ellas, en objetos `torch.Tensor`.

Los objetos de imagen ya válidos (tensors, arrays de numpy, imágenes PIL) se pasan sin cambios para que los llamadores que precargan imágenes no se vean afectados.

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

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

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

Normalizar una imagen 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)
```

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

Rellene las imágenes con Torchvision mediante operaciones por lotes.

#### 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'>)
```

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

Procesa una sola imagen para el backend torchvision.

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

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

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

Escalar una imagen por un factor 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])
```

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

Escalar y normalizar imágenes usando Torchvision (fusionado para mayor eficiencia).

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

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

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

Redimensionar una imagen usando Torchvision.

## PilBackend[[transformers.PilBackend]]

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

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

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

Backend de PIL/NumPy para el procesamiento de imágenes portátil solo en CPU.

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

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

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

Recortar una imagen al centro 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)
```

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

Convierte una imagen al formato RGB.

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

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

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

Normalizar una imagen 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)
```

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

Rellene las imágenes hasta el tamaño 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'>)
```

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

Procesa una sola imagen para el backend PIL.

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

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

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

Escalar una imagen por un factor de escala usando NumPy.

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

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

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

Redimensionar una imagen usando PIL/NumPy.