# Utilitaires pour les processeurs d'images

Cette page répertorie toutes les fonctions utilitaires utilisées par les processeurs d’images, principalement les transformations fonctionnelles employées pour traiter les images.

La plupart de ces éléments ne sont utiles que si vous étudiez le code des processeurs d’images de la bibliothèque.

## Transformations d'images[[transformers.image_transforms.center_crop]]

#### transformers.image_transforms.center_crop[[transformers.image_transforms.center_crop]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L448)

**Paramètres :**

image (`np.ndarray`) : L'image à recadrer.

size (`tuple[int, int]`) : Taille cible de l'image recadrée.

data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour l'image de sortie. 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). Si non défini, le format déduit de l'image d'entrée sera utilisé.

input_data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour 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). Si non défini, le format déduit de l'image d'entrée sera utilisé.

**Retourne :** `np.ndarray`

L'image recadrée.

Effectue un recadrage central de l'`image` à la `size` spécifiée. Notez que si l'image est trop petite pour être recadrée à la taille donnée, elle sera rembourrée (le résultat renvoyé sera donc toujours de taille `size`).

#### transformers.image_transforms.center_to_corners_format[[transformers.image_transforms.center_to_corners_format]]

```python
transformers.image_transforms.center_to_corners_format(bboxes_center: TensorType)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L553)

Convertit les boîtes englobantes du format centre au format coins.

format center : contient la coordonnée du centre de la boîte ainsi que ses dimensions largeur et hauteur (center_x, center_y, width, height) format corners : contient les coordonnées des coins en haut à gauche et en bas à droite de la boîte (top_left_x, top_left_y, bottom_right_x, bottom_right_y)

#### transformers.image_transforms.corners_to_center_format[[transformers.image_transforms.corners_to_center_format]]

```python
transformers.image_transforms.corners_to_center_format(bboxes_corners: TensorType)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L596)

Convertit les boîtes englobantes du format coins au format centre.

format corners : contient les coordonnées des coins en haut à gauche et en bas à droite de la boîte (top_left_x, top_left_y, bottom_right_x, bottom_right_y) format center : contient la coordonnée du centre de la boîte ainsi que ses dimensions largeur et hauteur (center_x, center_y, width, height)

#### transformers.image_transforms.id_to_rgb[[transformers.image_transforms.id_to_rgb]]

```python
transformers.image_transforms.id_to_rgb(id_map)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L643)

Convertit un identifiant unique en couleur RVB.

#### transformers.image_transforms.normalize[[transformers.image_transforms.normalize]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L387)

**Paramètres :**

image (`np.ndarray`) : L'image à normaliser.

mean (`float` ou `Collection[float]`) : Moyenne à utiliser pour la normalisation.

std (`float` ou `Collection[float]`) : L'écart-type à utiliser pour la normalisation.

data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image de sortie. Si non défini, le format déduit à partir de l'entrée sera utilisé.

input_data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image d'entrée. Si non défini, le format déduit de l'entrée sera utilisé.

Normalise `image` à l'aide de la moyenne et de l'écart-type spécifiés par `mean` et `std`.

image = (image - mean) / std

#### transformers.image_transforms.pad[[transformers.image_transforms.pad]]

```python
transformers.image_transforms.pad(image: ndarray, padding: int | tuple[int, int] | collections.abc.Iterable[tuple[int, int]], mode: PaddingMode = <PaddingMode.CONSTANT: 'constant'>, constant_values: float | collections.abc.Iterable[float] = 0.0, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L673)

**Paramètres :**

image (`np.ndarray`) : L'image à mettre en bordure.

padding (`int` ou `tuple[int, int]` ou `Iterable[tuple[int, int]]`) : Rembourrage à appliquer aux bords des axes hauteur et largeur. Peut être au format suivant : - `((before_height, after_height), (before_width, after_width))` largeurs de rembourrage uniques pour chaque axe. - `((before, after),)` applique le même rembourrage avant et après pour la hauteur et la largeur. - `(pad,)` ou int est un raccourci pour before = after = largeur de rembourrage pour tous les axes.

mode (`PaddingMode`) : Le mode de bourrage à utiliser. Peut être l'un des éléments suivants : - `"constant"` : bourrage avec une valeur constante. - `"reflect"` : bourrage avec la réflexion du vecteur miroir sur les premières et dernières valeurs du vecteur le long de chaque axe. - `"replicate"` : bourrage avec la réplication de la dernière valeur sur le bord du tableau le long de chaque axe. - `"symmetric"` : bourrage avec la réflexion du vecteur miroir le long du bord du tableau.

constant_values (`float` ou `Iterable[float]`, *facultatif*) : La valeur à utiliser pour le bourrage si `mode` est `"constant"`.

data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour l'image de sortie. 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). Si non défini, utilise le même format que l'image d'entrée.

input_data_format (`str` ou `ChannelDimension`, *facultatif*) : Le format de la dimension des canaux pour 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). Si non défini, le format déduit de l'image d'entrée sera utilisé.

**Retourne :** `np.ndarray`

L'image rembourrée.

Remplit l'`image` avec le `padding` (hauteur, largeur) et le `mode` spécifiés.

#### transformers.image_transforms.rgb_to_id[[transformers.image_transforms.rgb_to_id]]

```python
transformers.image_transforms.rgb_to_id(color)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L632)

Convertit une couleur RGB en identifiant unique.

#### transformers.image_transforms.rescale[[transformers.image_transforms.rescale]]

```python
transformers.image_transforms.rescale(image: ndarray, scale: float, data_format: transformers.image_utils.ChannelDimension | None = None, dtype: dtype = <class 'numpy.float32'>, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L92)

**Paramètres :**

image (`np.ndarray`) : L'image à remasquer.

scale (`float`) : L'échelle à utiliser pour redimensionner l'image.

data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image. S'il n'est pas fourni, il sera identique à celui de l'image d'entrée.

dtype (`np.dtype`, *facultatif*, par défaut `np.float32`) : Le dtype de l'image de sortie. Par défaut, `np.float32`. Utilisé pour la compatibilité ascendante avec les extracteurs de caractéristiques.

input_data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image d'entrée. S'il n'est pas fourni, il sera déduit de l'image d'entrée.

**Retourne :** `np.ndarray`

L'image redimensionnée.

Redimensionne `image` par `scale`.

#### transformers.image_transforms.resize[[transformers.image_transforms.resize]]

```python
transformers.image_transforms.resize(image: ndarray, size: tuple, resample: typing.Optional[ForwardRef('PILImageResampling')] = None, reducing_gap: int | None = None, data_format: transformers.image_utils.ChannelDimension | None = None, return_numpy: bool = True, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L316)

**Paramètres :**

image (`np.ndarray`) : L'image à redimensionner.

size (`tuple[int, int]`) : La taille à utiliser pour redimensionner l'image.

resample (`int`, *facultatif*, par défaut `PILImageResampling.BILINEAR`) : Le filtre à utiliser pour le rééchantillonnage.

reducing_gap (`int`, *facultatif*) : Applique une optimisation en redimensionnant l'image en deux étapes. Plus `reducing_gap` est grand, plus le résultat se rapproche de l'échantillonnage équitable. Consultez la documentation correspondante de Pillow pour plus de détails.

data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image de sortie. Si non défini, le format déduit à partir de l'entrée sera utilisé.

return_numpy (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non retourner l'image redimensionnée sous forme de tableau numpy. Si la valeur est False, un objet `PIL.Image.Image` est retourné.

input_data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image d'entrée. Si non défini, le format déduit de l'entrée sera utilisé.

**Retourne :** `np.ndarray`

L'image redimensionnée.

Redimensionne `image` en `(height, width)` spécifié par `size` à l'aide de la bibliothèque PIL.

#### transformers.image_transforms.to_pil_image[[transformers.image_transforms.to_pil_image]]

```python
transformers.image_transforms.to_pil_image(image: typing.Union[numpy.ndarray, ForwardRef('PIL.Image.Image'), ForwardRef('torch.Tensor')], do_rescale: bool | None = None, image_mode: str | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L157)

**Paramètres :**

image (`PIL.Image.Image` ou `numpy.ndarray` ou `torch.Tensor`) : L'image à convertir au format `PIL.Image`.

do_rescale (`bool`, *facultatif*) : Indique s'il faut appliquer le facteur d'échelle (pour rendre les valeurs de pixels des entiers compris entre 0 et 255). La valeur par défaut est `True` si le type d'image est un type à virgule flottante et que le passage en `int` entraînerait une perte de précision, et `False` dans le cas contraire.

image_mode (`str`, *facultatif*) : Le mode à utiliser pour l'image PIL. S'il n'est pas défini, le mode par défaut du type d'image d'entrée est utilisé.

input_data_format (`ChannelDimension`, *facultatif*) : Le format de la dimension des canaux de l'image d'entrée. Si non défini, le format déduit de l'entrée sera utilisé.

**Retourne :** `PIL.Image.Image`

L'image convertie.

Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if needed.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

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

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

[Source](https://github.com/huggingface/transformers/blob/main/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.

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

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

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

Convertit une URL unique ou une liste d'URL en objets `PIL.Image` correspondants.

Si une seule url est transmise, la valeur retournée sera un seul objet. Si une liste est transmise, une liste d'objets est retournée.

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

```python
from_dict(image_processor_dict: dict, **kwargs)
```

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

**Paramètres :**

image_processor_dict (`dict[str, Any]`) : Dictionnaire qui sera utilisé pour instancier l'objet de processeur d'images. Un tel dictionnaire peut être récupéré à partir d'un point de contrôle préentraîné en utilisant la méthode [to_dict()](/docs/transformers/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin.to_dict).

kwargs (`dict[str, Any]`) : Paramètres supplémentaires à partir desquels initialiser l'objet de processeur d'images.

**Retourne :** [ImageProcessingMixin](/docs/transformers/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin)

L'objet de processeur d'images instancié à partir de ces paramètres.

Instancie un type de [ImageProcessingMixin](/docs/transformers/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin) à partir d'un dictionnaire Python de paramètres.

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

```python
from_json_file(json_file: str | os.PathLike)
```

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

**Paramètres :**

json_file (`str` ou `os.PathLike`) : Chemin vers le fichier JSON contenant les paramètres.

**Retourne :** un processeur d'image de type [ImageProcessingMixin](/docs/transformers/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin)

L'objet image_processor instancié à partir de ce fichier JSON.

Instancie un processeur d'image de type [ImageProcessingMixin](/docs/transformers/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin) à partir du chemin d'accès vers un fichier JSON de paramètres.

#### 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/main/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/main/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/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instanciez un type de [ImageProcessingMixin](/docs/transformers/main/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}
```

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

```python
get_image_processor_dict(pretrained_model_name_or_path: str | os.PathLike, **kwargs)
```

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

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : L'identifiant du point de contrôle pré-entraîné à partir duquel nous voulons obtenir le dictionnaire des paramètres.

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.

image_processor_filename (`str`, *facultatif*, par défaut `"config.json"`) : Nom du fichier dans le répertoire du modèle à utiliser pour la configuration du processeur d'images.

**Retourne :** `tuple[Dict, Dict]`

Le(s) dictionnaire(s) qui sera(ont) utilisé(s) pour instancier l'objet de processeur d'images.

À partir de `pretrained_model_name_or_path`, résout en un dictionnaire de paramètres, à utiliser pour instancier un processeur d’images de type `~image_processor_utils.ImageProcessingMixin` à l’aide de `from_dict`.

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

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Paramètres :**

repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser votre image processor. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation donnée.

commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload image processor"`.

commit_description (`str`, *facultatif*) : La description du commit qui sera créé

private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà.

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

revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés.

create_pr (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.

max_shard_size (`int` ou `str`, *facultatif*, valeur par défaut `"50GB"`) : Ne s'applique qu'aux modèles. Taille maximale d'un point de contrôle avant son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`).

tags (`list[str]`, *facultatif*) : Liste de tags à pousser sur le Hub.

Téléchargez le fichier du processeur d'images sur le 🤗 Model Hub.

Exemples :

```python
from transformers import AutoImageProcessor

image processor = AutoImageProcessor.from_pretrained("google-bert/bert-base-cased")

# Push the image processor to your namespace with the name "my-finetuned-bert".
image processor.push_to_hub("my-finetuned-bert")

# Push the image processor to an organization with the name "my-finetuned-bert".
image processor.push_to_hub("huggingface/my-finetuned-bert")
```

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

```python
register_for_auto_class(auto_class = 'AutoImageProcessor')
```

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

**Paramètres :**

auto_class (`str` ou `type`, *facultatif*, valeur par défaut `"AutoImageProcessor "`) : La classe auto avec laquelle enregistrer ce nouveau processeur d'image.

Enregistrez cette classe avec une classe auto donnée. Cette opération ne doit être utilisée que pour les processeurs d'images personnalisés, car ceux de la bibliothèque sont déjà associés à `AutoImageProcessor `.

#### 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/main/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/main/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/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin.from_pretrained).

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

```python
to_dict()
```

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

**Retourne :** `dict[str, Any]`

Dictionnaire de tous les attributs qui composent cette instance de processeur d'image.

Sérialise cette instance en dictionnaire Python.

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

```python
to_json_file(json_file_path: str | os.PathLike)
```

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

**Paramètres :**

json_file_path (`str` ou `os.PathLike`) : Chemin du fichier JSON dans lequel les paramètres de cette instance d'image_processor seront enregistrés.

Enregistrez cette instance dans un fichier JSON.

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

```python
to_json_string()
```

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

**Retourne :** `str`

Chaîne de caractères contenant tous les attributs qui composent cette instance de feature_extractor au format JSON.

Sérialise cette instance en chaîne JSON.