# Extracteur de caractéristiques

Un extracteur de caractéristiques est chargé de préparer les caractéristiques d'entrée pour les modèles audio. Cela inclut l'extraction de caractéristiques à partir de séquences, par exemple le prétraitement de fichiers audio pour générer des caractéristiques Log-Mel Spectrogram, ainsi que la conversion en tenseurs NumPy et PyTorch.

## FeatureExtractionMixin[[transformers.FeatureExtractionMixin]]

#### transformers.FeatureExtractionMixin[[transformers.FeatureExtractionMixin]]

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

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

Il s’agit d’un mixin d’extraction de caractéristiques utilisé pour fournir la fonctionnalité de sauvegarde/chargement pour les extracteurs de caractéristiques séquentiels et audio.

#### from_pretrained[[transformers.FeatureExtractionMixin.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/feature_extraction_utils.py#L286)

**Paramètres :**

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

cache_dir (`str` ou `os.PathLike`, *facultatif*) : Chemin vers un répertoire dans lequel le feature extractor d'un 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*, valeur par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des fichiers de l'extracteur de caractéristiques 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 d'extraction de caractéristiques final. Si `True`, cette fonction renvoie un `Tuple(feature_extractor, unused_kwargs)` où *unused_kwargs* est un dictionnaire composé des paires clé/valeur dont les clés ne sont pas des attributs de l'extracteur de caractéristiques : c'est-à-dire la partie de `kwargs` qui n'a pas été utilisée pour mettre à jour `feature_extractor` et qui est autrement ignorée.

kwargs (`dict[str, Any]`, *facultatif*) : Les valeurs dans kwargs des clés qui sont des attributs de l'extracteur de caractéristiques 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 de l'extracteur de caractéristiques est contrôlé par le paramètre mot-clé `return_unused_kwargs`.

**Retourne :**

Un extracteur de caractéristiques de type [FeatureExtractionMixin](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin).

Instanciez un type de [FeatureExtractionMixin](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin) à partir d'un extracteur de caractéristiques, *par exemple* une classe dérivée de [SequenceFeatureExtractor](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor).

Exemples :

```python
# We can't instantiate directly the base class *FeatureExtractionMixin* nor *SequenceFeatureExtractor* so let's show the examples on a
# derived class: *Wav2Vec2FeatureExtractor*
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h"
)  # Download feature_extraction_config from huggingface.co and cache.
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "./test/saved_model/"
)  # E.g. feature_extractor (or model) was saved using *save_pretrained('./test/saved_model/')*
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained("./test/saved_model/preprocessor_config.json")
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h", return_attention_mask=False, foo=False
)
assert feature_extractor.return_attention_mask is False
feature_extractor, unused_kwargs = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h", return_attention_mask=False, foo=False, return_unused_kwargs=True
)
assert feature_extractor.return_attention_mask is False
assert unused_kwargs == {"foo": False}
```

#### save_pretrained[[transformers.FeatureExtractionMixin.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/feature_extraction_utils.py#L390)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire où le fichier JSON de l'extracteur de caractéristiques 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 feature_extractor 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/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained).

## SequenceFeatureExtractor[[transformers.SequenceFeatureExtractor]]

#### transformers.SequenceFeatureExtractor[[transformers.SequenceFeatureExtractor]]

```python
transformers.SequenceFeatureExtractor(feature_size: int, sampling_rate: int, padding_value: float, **kwargs)
```

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

**Paramètres :**

feature_size (`int`) : La dimension des caractéristiques des fonctionnalités extraites.

sampling_rate (`int`) : Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).

padding_value (`float`) : La valeur utilisée pour remplir les valeurs / vecteurs de bourrage.

Ceci est une classe générale d'extraction de caractéristiques pour la reconnaissance vocale.

#### pad[[transformers.SequenceFeatureExtractor.pad]]

```python
pad(processed_features: transformers.feature_extraction_utils.BatchFeature | list[transformers.feature_extraction_utils.BatchFeature] | dict[str, transformers.feature_extraction_utils.BatchFeature] | dict[str, list[transformers.feature_extraction_utils.BatchFeature]] | list[dict[str, transformers.feature_extraction_utils.BatchFeature]], padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None)
```

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

**Paramètres :**

processed_features ([BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature), liste de [BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature), `dict[str, list[float]]`, `dict[str, list[list[float]]` ou `list[dict[str, list[float]]]`) : Entrées traitées. Peut représenter une seule entrée ([BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature) ou `dict[str, list[float]]`) ou un lot de valeurs / vecteurs d'entrée (liste de [BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature), *dict[str, list[list[float]]]* ou *list[dict[str, list[float]]]*), ce qui permet d'utiliser cette méthode aussi bien lors du prétraitement que dans une fonction de collation d'un Dataloader PyTorch. À la place de `list[float]`, vous pouvez avoir des tenseurs (tableaux numpy ou tenseurs PyTorch), voir la note ci-dessus pour le type de retour.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` : Padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

truncation (`bool`) : Active la troncature pour couper les séquences d'entrée plus longues que `max_length` à `max_length`.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta), ou sur les TPU qui bénéficient de longueurs de séquence multiples de 128.

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du feature_extractor spécifique. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

Remplir les valeurs d'entrée / les vecteurs d'entrée ou un lot de valeurs d'entrée / de vecteurs d'entrée jusqu'à une longueur prédéfinie ou jusqu'à la longueur de séquence maximale du lot.

Les valeurs de bourrage (côté gauche/droite) sont définies au niveau de l'extracteur de caractéristiques (avec `self.padding_side`, `self.padding_value`)

Si les `processed_features` transmises sont un dictionnaire de tableaux numpy ou de tenseurs PyTorch, le résultat utilisera le même type, sauf si vous spécifiez un autre type de tenseur avec `return_tensors`. Dans le cas de tenseurs PyTorch, vous perdrez toutefois l’appareil spécifique de vos tenseurs.

## 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/main/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/main/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/main/src/transformers/feature_extraction_utils.py#L158)

**Paramètres :**

tensor_type (`str` ou [TensorType](/docs/transformers/main/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/main/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/main/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/main/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`.

## ImageFeatureExtractionMixin[[transformers.ImageFeatureExtractionMixin]]

#### transformers.ImageFeatureExtractionMixin[[transformers.ImageFeatureExtractionMixin]]

```python
transformers.ImageFeatureExtractionMixin()
```

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

Mixin contenant des utilitaires pour préparer les caractéristiques d'image.

#### center_crop[[transformers.ImageFeatureExtractionMixin.center_crop]]

```python
center_crop(image, size)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor` de forme (n_channels, height, width) ou (height, width, n_channels)) : l'image à redimensionner.

size (`int` ou `tuple[int, int]`) : La taille à laquelle recadrer l'image.

**Retourne :** `new_image`

Une image recadrée au centre de type `PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor` de forme : (n_channels, height, width).

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

#### convert_rgb[[transformers.ImageFeatureExtractionMixin.convert_rgb]]

```python
convert_rgb(image)
```

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

**Paramètres :**

image (`PIL.Image.Image`) : L'image à convertir.

Convertit `PIL.Image.Image` au format RGB.

#### expand_dims[[transformers.ImageFeatureExtractionMixin.expand_dims]]

```python
expand_dims(image)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : L'image à étendre.

Élargit l'`image` bidimensionnelle à 3 dimensions.

#### flip_channel_order[[transformers.ImageFeatureExtractionMixin.flip_channel_order]]

```python
flip_channel_order(image)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : L'image dont les canaux de couleur doivent être inversés. Si `np.ndarray` ou `torch.Tensor`, la dimension des canaux doit être la première.

Flips the channel order of `image` from RGB to BGR, or vice versa. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image.

#### normalize[[transformers.ImageFeatureExtractionMixin.normalize]]

```python
normalize(image, mean, std, rescale = False)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : L'image à normaliser.

mean (`list[float]` ou `np.ndarray` ou `torch.Tensor`) : La moyenne (par canal) à utiliser pour la normalisation.

std (`list[float]` ou `np.ndarray` ou `torch.Tensor`) : L'écart-type (par canal) à utiliser pour la normalisation.

rescale (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non rééchelonner l'image pour qu'elle soit comprise entre 0 et 1. Si une image PIL est fournie, le rééchelonnement est effectué automatiquement.

Normalizes `image` with `mean` and `std`. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image.

#### rescale[[transformers.ImageFeatureExtractionMixin.rescale]]

```python
rescale(image: ndarray, scale: float | int)
```

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

Redimensionner une image numpy par un facteur d'échelle

#### redimensionner[[transformers.ImageFeatureExtractionMixin.resize]]

```python
resize(image, size, resample = None, default_to_square = True, max_size = None)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : L'image à redimensionner.

size (`int` ou `tuple[int, int]`) : La taille à utiliser pour redimensionner l'image. Si `size` est une séquence de la forme (h, w), la taille de sortie sera ajustée en conséquence. Si `size` est un entier et que `default_to_square` est `True`, l'image sera redimensionnée en (size, size). Si `size` est un entier et que `default_to_square` est `False`, le plus petit côté de l'image sera ajusté à cette valeur. Par exemple, si la hauteur > la largeur, l'image sera redimensionnée en (size * height / width, size).

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

default_to_square (`bool`, *facultatif*, valeur par défaut `True`) : Méthode de conversion de `size` lorsqu'il s'agit d'un entier unique. Si défini sur `True`, `size` est converti en un carré (`size`,`size`). Si défini sur `False`, reproduit [`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize) avec la possibilité de redimensionner uniquement le plus petit côté et de fournir un `max_size` facultatif.

max_size (`int`, *facultatif*, valeur par défaut `None`) : La valeur maximale autorisée pour le côté le plus long de l'image redimensionnée : si le côté le plus long de l'image est supérieur à `max_size` après avoir été redimensionnée selon `size`, l'image est alors redimensionnée à nouveau de sorte que le côté le plus long soit égal à `max_size`. En conséquence, `size` peut être outrepassé, c'est-à-dire que le côté le plus court peut être plus petit que `size`. Utilisé uniquement si `default_to_square` est `False`.

**Retourne :** `image`

Une image `PIL.Image.Image` redimensionnée.

Redimensionne `image`. Force la conversion de l’entrée en PIL.Image.

#### rotate[[transformers.ImageFeatureExtractionMixin.rotate]]

```python
rotate(image, angle, resample = None, expand = 0, center = None, translate = None, fillcolor = None)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : L'image à faire pivoter. Si le type est `np.ndarray` ou `torch.Tensor`, il sera converti en `PIL.Image.Image` avant la rotation.

**Retourne :** `image`

Une image `PIL.Image.Image` pivotée.

Retourne une copie rotée de `image`. Cette méthode retourne une copie de `image`, tournée du nombre de degrés indiqué dans le sens antihoraire autour de son centre.

#### to_numpy_array[[transformers.ImageFeatureExtractionMixin.to_numpy_array]]

```python
to_numpy_array(image, rescale = None, channel_first = True)
```

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

**Paramètres :**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : L'image à convertir en tableau NumPy.

rescale (`bool`, *facultatif*) : Indique s'il faut appliquer le facteur d'échelle (pour convertir les valeurs de pixels en nombres flottants compris entre 0. et 1.). La valeur par défaut est `True` si l'image est une image PIL ou un tableau/tenseur d'entiers, et `False` dans le cas contraire.

channel_first (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non permuter les dimensions de l'image pour placer la dimension des canaux en premier.

Convertit `image` en tableau numpy. Effectue un redimensionnement optionnel et place la dimension des canaux en premier.

#### to_pil_image[[transformers.ImageFeatureExtractionMixin.to_pil_image]]

```python
to_pil_image(image, rescale = None)
```

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

**Paramètres :**

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

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, `False` sinon.

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