Transformers documentation
Procesador de imágenes
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 — clase base abstracta (solo para compatibilidad hacia atrás; no instanciar directamente)
- TorchvisionBackend — el backend predeterminado con soporte de torchvision. Acelerado por GPU y significativamente más rápido que el backend PIL. Todos los modelos exponen una clase
<Model>ImageProcessorque hereda de él. - 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.
- TorchvisionBackend — el backend predeterminado con soporte de torchvision. Acelerado por GPU y significativamente más rápido que el backend PIL. Todos los modelos exponen una clase
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() 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.
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.
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, utilizando una GPU NVIDIA A10G Tensor Core.
ImageProcessingMixin
Esta es una clase mixin de procesador de imágenes que se utiliza para proporcionar funcionalidad de guardado y carga para extractores de características secuenciales e imágenes.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )
Parámetros
- pretrained_model_name_or_path (
stroos.PathLike) — Puede ser:- una cadena, el model id de un image_processor preentrenado alojado en un repositorio de modelos en huggingface.co.
- una ruta a un directorio que contenga un archivo de procesador de imágenes guardado usando el método
save_pretrained(), por ejemplo,
./my_model_directory/. - una ruta a un archivo JSON de procesador de imágenes guardado, archivo, p. ej.,
./my_model_directory/preprocessor_config.json.
- cache_dir (
stroos.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 predeterminadoFalse) — 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 (
strobool, opcional) — El token que se usará como autorización HTTP bearer para archivos remotos. Si esTrue, o no se especifica, se usará el token generado al ejecutarhf 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 querevisionpuede ser cualquier identificador permitido por git.
Instanciar un tipo de ImageProcessingMixin desde un procesador de imágenes.
Ejemplos:
# 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
< source >( save_directory: str | os.PathLikepush_to_hub: bool = False**kwargs )
Parámetros
- save_directory (
stroos.PathLike) — Directorio donde se guardará el archivo JSON del procesador de imágenes (se creará si no existe). - push_to_hub (
bool, opcional, valor predeterminadoFalse) — Indica si se debe subir el modelo al hub de modelos de Hugging Face después de guardarlo. Puedes especificar el repositorio al que deseas subirlo conrepo_id(por defecto, usará el nombre desave_directoryen tu espacio de nombres). - kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan al método 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().
BatchFeature
clase transformers.BatchFeature
< source >( data: dict[str, typing.Any] | None = Nonetensor_type: None | str | transformers.utils.generic.TensorType = Noneskip_tensor_conversion: list[str] | set[str] | None = None )
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 indicar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. - skip_tensor_conversion (
list[str]oset[str], opcional) — Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especificatensor_type.
Contiene la salida de los métodos 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
< source >( tensor_type: str | transformers.utils.generic.TensorType | None = Noneskip_tensor_conversion: list[str] | set[str] | None = None )
Parámetros
- tensor_type (
stro TensorType, opcional) — El tipo de tensores a utilizar. Si esstr, debe ser uno de los valores del enum TensorType. Si esNone, no se realiza ninguna modificación. - skip_tensor_conversion (
list[str]oset[str], opcional) — Lista o conjunto de claves que NO deben convertirse en tensores, incluso cuando se especificatensor_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.
hasta
< source >( *args**kwargs ) → BatchFeature
Parámetros
- args (
Tuple) — Se pasará a la funciónto(...)de los tensores. - kwargs (
Dict, opcional) — Se pasará a la funciónto(...)de los tensores. Para habilitar la transferencia de datos asíncrona, establezca la banderanon_blockingenkwargs(el valor predeterminado esFalse).
Devuelve
La misma instancia después de la modificación.
Envía todos los valores al dispositivo llamando a v.to(*args, **kwargs) (solo PyTorch). Esto debería admitir el cambio a diferentes dtypes y enviar el BatchFeature a un device diferente.
BaseImageProcessor
clase transformers.BaseImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
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 luego 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 cada 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 unBatchFeature.
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 maneja el pipeline estándar automáticamente.
Procesamiento personalizado
Para los procesadores que requieren lógica personalizada (p. ej., procesamiento por parches, múltiples tipos de entrada), sobrescribe _preprocess en tu procesador específico del 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
TorchvisionBackendoPilBackend - Los backends reciben las imágenes como
torch.Tensor(Torchvision) onp.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
< source >( image: ndarraysize: dictdata_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs )
Parámetros
- image (
np.ndarray) — Imagen para recortar al centro. - size (
dict[str, int]) — Tamaño de la imagen de salida. - data_format (
stroChannelDimension, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
- input_data_format (
ChannelDimensionostr, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:"channels_first"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
Recorta una imagen al centro hasta (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 al centro.
normalize
< source >( image: ndarraymean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]data_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs ) → np.ndarray
Parámetros
- image (
np.ndarray) — Imagen a normalizar. - mean (
floatoIterable[float]) — Media de la imagen a utilizar para la normalización. - std (
floatoIterable[float]) — Desviación estándar de la imagen a utilizar para la normalización. - data_format (
stroChannelDimension, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
- input_data_format (
ChannelDimensionostr, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:"channels_first"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
Devuelve
np.ndarray
La imagen normalizada.
Normaliza una imagen. image = (image - image_mean) / image_std.
preprocesar
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature
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, establezcado_rescale=False. - image_like_kwargs (
dict[str, Any], opcional) — Bandera para desarrolladores destinada a entradas adicionales de tipo imagen 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 provoca problemas de prioridad de argumentos en algunos modelos. En esos casos se puede usarpreprocess(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 de entrada máximas del modelo. - default_to_square (
bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicarcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enumPILImageResampling. Solo tiene efecto sido_resizeestá establecido enTrue. - do_rescale (
bool, kwargs, opcional) — Si se debe reescalar la imagen. - rescale_factor (
float, kwargs, opcional) — Factor de reescalado para reescalar la imagen sido_rescaleestá establecido enTrue. - 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 sido_normalizeestá establecido enTrue. - 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 sido_normalizeestá establecido enTrue. - 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 cualquier tamaño de imagen proporcionado para el preprocesamiento. Si no se proporcionapad_size, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuandodo_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 admiteChannelDimension.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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:"channels_first"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales)."none"oChannelDimension.NONE: imagen en formato (altura, ancho).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse 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.
Procesa una imagen cruda individual al formato de trabajo del backend.
Implementado por subclases de 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
< source >( image: ndarrayscale: floatdata_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs ) → np.ndarray
Parámetros
- image (
np.ndarray) — Imagen para reescalar. - scale (
float) — El factor de escala para reescalar los valores de píxel. - data_format (
stroChannelDimension, 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"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
- input_data_format (
ChannelDimensionostr, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:"channels_first"oChannelDimension.FIRST: imagen en formato (num_channels, height, width)."channels_last"oChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
Devuelve
np.ndarray
La imagen reescalada.
Escala una imagen por un factor de escala. image = image * scale.
TorchvisionBackend
clase transformers.TorchvisionBackend
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Backend de Torchvision para el procesamiento por lotes de imágenes acelerado por GPU.
Recortar el centro de una imagen usando Torchvision.
convert_to_rgb
< source >( image: torch.Tensorinput_data_format: str | transformers.image_utils.ChannelDimension | None = None )
Convierte una imagen al formato RGB.
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
< source >( image: torch.Tensormean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]inplace: bool = False**kwargs )
Normalizar una imagen usando Torchvision.
pad
< source >( images: listpad_size: SizeDict = Nonefill_value: int | None = 0padding_mode: str | None = 'constant'return_mask: bool = Falsedisable_grouping: bool | None = Falseis_nested: bool | None = False**kwargs )
Rellene las imágenes con Torchvision mediante operaciones por lotes.
process_image
< source >( 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 = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = Nonedevice: typing.Optional[ForwardRef('torch.device')] = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Procesa una sola imagen para el backend torchvision.
Escalar una imagen por un factor de escala usando Torchvision.
rescale_and_normalize
< source >( images: torch.Tensordo_rescale: boolrescale_factor: floatdo_normalize: boolimage_mean: float | list[float]image_std: float | list[float] )
Escalar y normalizar imágenes usando Torchvision (fusionado para mayor eficiencia).
resize
< source >( image: torch.Tensorsize: SizeDictresample: PILImageResampling | tvF.InterpolationMode | int | None = Noneantialias: bool = True**kwargs )
Redimensionar una imagen usando Torchvision.
PilBackend
clase transformers.PilBackend
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Backend de PIL/NumPy para el procesamiento de imágenes portátil solo en CPU.
Recortar una imagen al centro usando NumPy.
convert_to_rgb
< source >( image: ndarrayinput_data_format: str | transformers.image_utils.ChannelDimension | None = None )
Convierte una imagen al formato RGB.
normalize
< source >( image: ndarraymean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]**kwargs )
Normalizar una imagen usando NumPy.
pad
< source >( images: listpad_size: SizeDict = Nonefill_value: int | None = 0padding_mode: str | None = 'constant'return_mask: bool = False**kwargs )
Rellene las imágenes hasta el tamaño especificado usando NumPy.
process_image
< source >( 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 = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Procesa una sola imagen para el backend PIL.
Escalar una imagen por un factor de escala usando NumPy.
resize
< source >( image: ndarraysize: SizeDictresample: PILImageResampling | None = Nonereducing_gap: int | None = None**kwargs )
Redimensionar una imagen usando PIL/NumPy.