# Processeur d'image

Un processeur d’images est chargé du chargement des images (le cas échéant), de la préparation des caractéristiques d’entrée pour les modèles de vision et du post-traitement de leurs sorties. Cela inclut des transformations telles que le redimensionnement, la normalisation et la conversion en tenseurs PyTorch et Numpy. Il peut également inclure un post-traitement spécifique au modèle, tel que la conversion des logits en masques de segmentation.

Les processeurs d’images utilisent une architecture basée sur un backend. La hiérarchie des classes est la suivante :

- [BaseImageProcessor](/docs/transformers/v5.23.0/fr/main_classes/image_processor#transformers.BaseImageProcessor) — classe de base abstraite (uniquement pour la rétrocompatibilité ; ne pas instancier directement)
  - [TorchvisionBackend](/docs/transformers/v5.23.0/fr/main_classes/image_processor#transformers.TorchvisionBackend) — l’arrière-plan **par défaut** basé sur [torchvision](https://pytorch.org/vision/stable/index.html). Accéléré par GPU et nettement plus rapide que l’arrière-plan PIL. Tous les modèles exposent une classe `<Model>ImageProcessor` qui en hérite.
  - [PilBackend](/docs/transformers/v5.23.0/fr/main_classes/image_processor#transformers.PilBackend) — backend alternatif PIL/NumPy. Portable, CPU uniquement. Disponible uniquement pour les anciens modèles via une classe `<Model>ImageProcessorPil` ; utile lorsque l’équivalence numérique exacte avec l’implémentation d’origine est requise.

Les deux backends exposent la même API. Utilisez l'attribut `backend` pour inspecter le backend utilisé par un processeur chargé (par exemple `processor.backend == "torchvision"`).

Passer `backend` à [AutoImageProcessor.from_pretrained()](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoImageProcessor.from_pretrained) pour sélectionner un backend. Lorsque `backend` est omis (par défaut), torchvision est choisi s'il est installé, sinon PIL est utilisé. Quelques modèles qui utilisent l'interpolation Lanczos (Chameleon, Flava, Idefics3, SmolVLM) font exception et utilisent PIL par défaut lorsque torchvision < 0.27. Forcer `backend="torchvision"` pour ces modèles sur torchvision < 0.27 bascule sur l'interpolation BICUBIC, car torchvision ne prend en charge Lanczos pour les tenseurs qu'à partir de la version 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")
```

Lors de l'utilisation du backend torchvision, vous pouvez définir l'argument `device` pour spécifier le dispositif sur lequel le traitement doit être effectué. Par défaut, le traitement est effectué sur le même dispositif que les entrées si celles-ci sont des tenseurs, ou sur le CPU dans le cas contraire.

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

Voici quelques comparaisons de vitesse entre les backends torchvision et PIL pour les modèles `DETR` et `RT-DETR`, et leur impact sur le temps d’inférence global :

  

  

  

  

Ces benchmarks ont été exécutés sur une [instance AWS EC2 g5.2xlarge](https://aws.amazon.com/ec2/instance-types/g5/), en utilisant un GPU NVIDIA A10G Tensor Core.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_base.py#L61)

Il s’agit d’un mixin de processeur d’images utilisé pour fournir la fonctionnalité d’enregistrement/chargement pour les extracteurs de caractéristiques séquentiels et d’images.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_base.py#L84)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Peut être l'un des éléments suivants :  - une chaîne de caractères, l'*identifiant de modèle* d'un image_processor pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co. - un chemin vers un *répertoire* contenant un fichier de processeur d'image enregistré à l'aide de la méthode [save_pretrained()](/docs/transformers/v5.23.0/fr/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained), par exemple `./my_model_directory/`. - un chemin vers un fichier JSON de processeur d'image *fichier* enregistré, par exemple `./my_model_directory/preprocessor_config.json`.

cache_dir (`str` ou `os.PathLike`, *facultatif*) : Chemin vers un répertoire dans lequel le processeur d’images de modèle pré-entraîné téléchargé doit être mis en cache si le cache standard ne doit pas être utilisé.

force_download (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des fichiers du processeur d'images et remplacer les versions en cache si elles existent.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Les proxys sont utilisés pour chaque requête.

token (`str` ou `bool`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, ou non spécifié, le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

revision (`str`, *facultatif*, par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag ou d'un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, de sorte que `revision` peut être n'importe quel identifiant autorisé par git.     Pour tester une pull request que vous avez créée sur le Hub, vous pouvez passer `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *facultatif*, valeur par défaut `False`) : Si `False`, cette fonction renvoie uniquement l'objet processeur d'image final. Si `True`, cette fonction renvoie un `Tuple(image_processor, unused_kwargs)` où *unused_kwargs* est un dictionnaire composé des paires clé/valeur dont les clés ne sont pas des attributs du processeur d'image : c'est-à-dire la partie de `kwargs` qui n'a pas été utilisée pour mettre à jour `image_processor` et qui est autrement ignorée.

subfolder (`str`, *facultatif*, valeur par défaut `""`) : si les fichiers concernés se trouvent dans un sous-dossier du dépôt de modèle sur huggingface.co, vous pouvez spécifier le nom du dossier ici.

kwargs (`dict[str, Any]`, *facultatif*) : Les valeurs dans kwargs des clés qui sont des attributs du processeur d'images seront utilisées pour remplacer les valeurs chargées. Le comportement concernant les paires clé/valeur dont les clés ne sont *pas* des attributs du processeur d'images est contrôlé par le paramètre mot-clé `return_unused_kwargs`.

**Retourne :**

Un processeur d'image de type [ImageProcessingMixin](/docs/transformers/v5.23.0/fr/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instanciez un type de [ImageProcessingMixin](/docs/transformers/v5.23.0/fr/internal/image_processing_utils#transformers.ImageProcessingMixin) à partir d'un processeur d'images.

Exemples :

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_base.py#L190)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : répertoire où le fichier JSON du processeur d'images sera enregistré (sera créé s'il n'existe pas).

push_to_hub (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms).

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Enregistrer un objet de processeur d’images dans le répertoire `save_directory` afin qu’il puisse être rechargé à l’aide de la méthode de classe [from_pretrained()](/docs/transformers/v5.23.0/fr/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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/feature_extraction_utils.py#L58)

**Paramètres :**

data (`dict`, *facultatif*) : Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes __call__/pad (« input_values », « attention_mask », etc.).

tensor_type (`Union[None, str, TensorType]`, *facultatif*) : Vous pouvez indiquer un tensor_type ici pour convertir les listes d'entiers en Tensors PyTorch/Numpy lors de l'initialisation.

skip_tensor_conversion (`list[str]` ou `set[str]`, *facultatif*) : Liste ou ensemble de clés qui ne doivent PAS être converties en tenseurs, même si `tensor_type` est spécifié.

Contient la sortie des méthodes [pad()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) et `__call__` spécifiques à l'extracteur de caractéristiques.

Cette classe est dérivée d'un dictionnaire Python et peut être utilisée comme un dictionnaire.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/feature_extraction_utils.py#L158)

**Paramètres :**

tensor_type (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Le type de tenseurs à utiliser. Si `str`, doit être l'une des valeurs de l'enum [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType). Si `None`, aucune modification n'est effectuée.

skip_tensor_conversion (`list[str]` ou `set[str]`, *facultatif*) : Liste ou ensemble de clés qui ne doivent PAS être converties en tenseurs, même si `tensor_type` est spécifié.

Convertir le contenu interne en tenseurs.

Note : Les valeurs qui n'ont pas une structure de type tableau (par exemple, des chaînes de caractères, des dictionnaires, des listes de chaînes de caractères) sont automatiquement ignorées et ne seront pas converties en tenseurs. Les tableaux irréguliers (listes de tableaux de longueurs différentes) sont tout de même tentés, bien qu'ils puissent provoquer des erreurs lors de la conversion.

#### vers[[transformers.BatchFeature.to]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/feature_extraction_utils.py#L215)

**Paramètres :**

args (`Tuple`) : Sera transmis à la fonction `to(...)` des tenseurs.

kwargs (`Dict`, *facultatif*) : Sera transmis à la fonction `to(...)` des tenseurs. Pour activer le transfert de données asynchrone, définissez le drapeau `non_blocking` dans `kwargs` (valeur par défaut : `False`).

**Retourne :** [BatchFeature](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.BatchFeature)

La même instance après modification.

Envoyer toutes les valeurs sur l'appareil en appelant `v.to(*args, **kwargs)` (PyTorch uniquement). Cela doit prendre en charge le cast dans différents `dtypes` et l'envoi du `BatchFeature` vers un autre `device`.

## BaseImageProcessor[[transformers.BaseImageProcessor]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L60)

Classe de base pour les processeurs d’images avec une architecture de backend basée sur l’héritage.

Cette classe définit le pipeline de prétraitement : validation des kwargs, préparation des entrées et délégation à la méthode `_preprocess` du backend. Les sous-classes de backend (`TorchvisionBackend`, `PilBackend`) héritent de cette classe et implémentent les opérations d’image effectives (redimensionnement, recadrage, remise à l’échelle, normalisation, etc.). Les processeurs d’images spécifiques à un modèle héritent ensuite de la classe de backend appropriée.

Aperçu de l'architecture ---------------------

La hiérarchie des classes est la suivante :

BaseImageProcessor (cette classe) ├── TorchvisionBackend    (accélération GPU, torch.Tensor) │   └── ModelImageProcessor (par ex. LlavaNextImageProcessor) └── PilBackend            (CPU portable, np.ndarray) └── ModelImageProcessorPil (par ex. CLIPImageProcessorPil)

Le flux de prétraitement est le suivant :

__call__() → preprocess() → _preprocess_image_like_inputs() → _prepare_image_like_inputs() (appelle process_image pour chaque image) → _preprocess() (opérations par lot : redimensionnement, recadrage, etc.)

- `process_image` : Implémentée par les backends. Convertit une seule entrée brute (PIL, NumPy ou Tensor) vers le format de travail du backend (torch.Tensor ou np.ndarray), gère la conversion en RGB et le réordonnancement des canaux.
- `_preprocess` : Implémenté par les backends. Effectue le traitement par lots proprement dit (redimensionnement, recadrage centré, remise à l'échelle, normalisation, bourrage) et renvoie un `BatchFeature`.

Implémentation de base --------------------

Pour les processeurs qui n'ont besoin que d'opérations standard (redimensionnement, recadrage centré, remise à l'échelle, normalisation), héritez d'un backend et définissez des attributs 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

La méthode `_preprocess` du backend gère automatiquement le pipeline standard.

Traitement personnalisé -----------------

Pour les processeurs nécessitant une logique personnalisée (par exemple, un traitement par patchs, plusieurs types d’entrées), surchargez `_preprocess` dans votre processeur spécifique au modèle. La méthode `_preprocess` reçoit des images déjà préparées (converties au format du backend avec un ordonnancement canaux-d’abord) et effectue le traitement proprement dit :

class MyImageProcessor(TorchvisionBackend): def _preprocess(self, images, do_resize, size, do_normalize, image_mean, image_std, **kwargs):
# Grouper les images par forme pour des opérations par lots efficaces
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})

Pour les processeurs gérant plusieurs types d'entrées (par exemple, images + cartes de segmentation), surchargez `_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

Étendre le comportement de l'arrière-plan

Pour personnaliser les opérations pour un backend spécifique, sous-classez le backend et écrasez ses méthodes :

from transformers.image_processing_backends import TorchvisionBackend, PilBackend

class MyTorchvisionProcessor(TorchvisionBackend): def resize(self, image, size, **kwargs):
# Logique de redimensionnement personnalisée pour torchvision
return super().resize(image, size, **kwargs)

class MyPilProcessor(PilBackend): def resize(self, image, size, **kwargs):
# Logique de redimensionnement personnalisée pour PIL
return super().resize(image, size, **kwargs)

Paramètres personnalisés -----------------

Pour ajouter des paramètres au-delà de `ImagesKwargs`, créez une classe kwargs personnalisée et définissez-la comme `valid_kwargs` :

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

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

Notes importantes ---------

- La sélection du backend est effectuée au niveau de la classe : héritez de `TorchvisionBackend` ou de `PilBackend`
- Les backends reçoivent les images sous forme de `torch.Tensor` (Torchvision) ou de `np.ndarray` (PIL), toujours avec les canaux en premier
- Toutes les images ont la dimension des canaux en premier pendant le traitement, quel que soit le backend
- Les arguments non fournis par les utilisateurs prennent par défaut les valeurs des attributs de classe
- Les classes de backend encapsulent la logique spécifique au backend (redimensionnement, normalisation, etc.) et peuvent être remplacées

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L500)

**Paramètres :**

image (`np.ndarray`) : Image à recadrer au centre.

size (`dict[str, int]`) : Taille de l'image de sortie.

data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour l'image de sortie. Si non défini, le format de la dimension des canaux de l'image d'entrée est utilisé. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels).

input_data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels).

Effectue un recadrage central d'une image sur `(size["height"], size["width"])`. Si la taille d'entrée est inférieure à `crop_size` sur l'un des côtés, l'image est d'abord rembourrée avec des zéros, puis recadrée au centre.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L463)

**Paramètres :**

image (`np.ndarray`) : Image à normaliser.

mean (`float` ou `Iterable[float]`) : Moyenne de l'image à utiliser pour la normalisation.

std (`float` ou `Iterable[float]`) : Écart-type de l'image à utiliser pour la normalisation.

data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour l'image de sortie. Si non défini, le format de la dimension des canaux de l'image d'entrée est utilisé. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels).

input_data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels).

**Retourne :** `np.ndarray`

L'image normalisée.

Normaliser une image. image = (image - image_mean) / image_std.

#### prétraiter[[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'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L382)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

image_like_kwargs (`dict[str, Any]`, *facultatif*) : Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant qu'argument nommé ne fonctionne pas. Par exemple, `preprocess(images, masks=masks)` est l'option recommandée, mais cela peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas, vous pouvez utiliser à la place `preprocess(images, image_like_inputs={"masks": masks})`.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

Prétraitez une image ou un lot d'images.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L219)

Traiter une image brute unique vers le format de travail du backend.

Implémentée par les sous-classes de backend (`TorchvisionBackend`, `PilBackend`). Convertit une entrée brute (image PIL, tableau NumPy ou tenseur torch) au format interne du backend (`torch.Tensor` pour Torchvision, `np.ndarray` pour PIL), gère la conversion en RVB et garantit un ordre des canaux en premier.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L430)

**Paramètres :**

image (`np.ndarray`) : Image à redimensionner.

scale (`float`) : Facteur d'échelle pour rééchelonner les valeurs de pixels.

data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour l'image de sortie. Si non défini, le format de la dimension des canaux de l'image d'entrée est utilisé. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels).

input_data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels).

**Retourne :** `np.ndarray`

L'image redimensionnée.

Redimensionner une image par un facteur d'échelle. image = image * scale.

## TorchvisionBackend[[transformers.TorchvisionBackend]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L86)

Backend Torchvision pour le traitement par lots d'images accéléré par GPU.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L371)

Effectuer un recadrage central d'une image à l'aide de 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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L156)

Convertir une image au format RGB.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L100)

Convertit une URL ou un chemin unique, ou une liste d’URLs / chemins, en objets `torch.Tensor`.

Les objets image déjà valides (tenseurs, tableaux numpy, images PIL) sont transmis sans modification, de sorte que les appelants qui préchargent des images ne soient pas affectés.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L317)

Normaliser une image à l'aide de Torchvision.

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

```python
pad(images: list['torch.Tensor'], 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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L184)

Pad des images à l'aide de Torchvision avec des opérations par lots.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L116)

Traiter une image unique pour l’arrière-plan torchvision.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L308)

Redimensionner une image par un facteur d'échelle à l'aide de 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])
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L345)

Redimensionner et normaliser les images à l'aide de Torchvision (fusionné pour l'efficacité).

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L234)

Redimensionner une image à l'aide de Torchvision.

## PilBackend[[transformers.PilBackend]]

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L448)

Backend PIL/NumPy pour le traitement d'images portable sur CPU uniquement.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L639)

Effectuer un recadrage central d'une image à l'aide de 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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L499)

Convertir une image au format RGB.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L623)

Normaliser une image à l'aide de NumPy.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L507)

Rembourrer les images à la taille spécifiée à l'aide de 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'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L462)

Traiter une image unique pour l’arrière-plan PIL.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L609)

Redimensionner une image par un facteur d'échelle à l'aide de NumPy.

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

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L558)

Redimensionner une image à l'aide de PIL/NumPy.