# Processeurs

## Processeurs multi-modaux[[transformers.ProcessorMixin]]

Tout modèle multi-modal nécessite un objet pour encoder ou décoder les données regroupant plusieurs modalités (parmi le texte, la vision et l’audio). Cette tâche est assurée par des objets appelés processeurs, qui regroupent deux ou plusieurs objets de traitement tels que des tokenizers (pour la modalité texte), des image processors (pour la vision) et des feature extractors (pour l’audio).

Ces processeurs héritent de la classe de base suivante qui implémente les fonctionnalités d'enregistrement et de chargement :

#### transformers.ProcessorMixin[[transformers.ProcessorMixin]]

```python
transformers.ProcessorMixin(*args, **kwargs)
```

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

Il s’agit d’un mixin utilisé pour fournir la fonctionnalité de sauvegarde/chargement pour toutes les classes de processeur.

#### __appel__[[transformers.ProcessorMixin.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

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

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : 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`.

text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *facultatif*) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio.

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

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

#### prepare_inputs_layout[[transformers.ProcessorMixin.prepare_inputs_layout]]

```python
prepare_inputs_layout(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

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

Normalise et précharge les entrées avant le traitement. Enveloppe le texte dans une liste pour les processeurs multimodaux, récupère les images et les fichiers audio distants si des URL sont fournies, et s'assure que l'audio est correctement groupé par lots. Renvoie le tuple normalisé `(images, text, videos, audio)`.

#### validate_inputs[[transformers.ProcessorMixin.validate_inputs]]

```python
validate_inputs(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

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

Valide qu'au moins une entrée est fournie et qu'aucun argument mot-clé obsolète n'est utilisé. Lève `ValueError` dans le cas contraire.

À surcharger lorsque le processeur a besoin d'une validation supplémentaire sur les arguments d'entrée.

#### get_text_with_replacements[[transformers.ProcessorMixin.get_text_with_replacements]]

```python
get_text_with_replacements(text: list, images_replacements: list = [], videos_replacements: list = [], audio_replacements: list = [])
```

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

**Paramètres :**

text (*list[str]*) : Lot de chaînes de texte brutes, chacune pouvant contenir des jetons de substitution multimodaux. Notez qu'il sera modifié en place et renvoyé.

images_replacements (*list[str]*, *optionnel*, valeur par défaut *[]*) : Chaînes de remplacement développées pour chaque image, dans l'ordre où elles apparaissent dans le lot. Générées par *self._process_images*.

videos_replacements (*list[str]*, *optionnel*, par défaut *[]*) : Chaînes de remplacement développées pour chaque vidéo. Produites par *self._process_videos*.

audio_replacements (*list[str]*, *optionnel*, par défaut *[]*) : Chaînes de remplacement développées pour chaque entrée audio. Générées par *self._process_audio*.

**Retourne :** *tuple[list[str], list[dict[str, Any]]]*

Un tuple de :
- Le lot de *text* modifié avec tous les jetons de substitution dépliés.
- *batch_replacement_offsets* : une entrée par élément du lot, chacune étant
liste de dictionnaires avec les clés :
- *"type"* (*str*) : nom de la modalité — *"image"*, *"video"* ou *"audio"*
- *"span"* (*tuple[int, int]*) : décalages de caractères d'origine *(start, end)* du jeton de substitution
- *"new_span"* (*tuple[int, int]*) : décalages *(start, end)* du placeholder dans la chaîne étendue
- *"text"* (*str*) : la chaîne de jetons de substitution d'origine qui a été trouvée
- *"replacement"* (*str*) : la chaîne de caractères avec laquelle il a été remplacé

Remplacez les jetons de placeholder multimodaux dans un lot de chaînes de texte par leurs représentations développées, et renvoyez les textes modifiés ainsi que les métadonnées de décalage.

Cette méthode constitue l'étape centrale de prétraitement côté texte pour les entrées multimodales. Elle parcourt chaque texte du lot à la recherche de jetons spéciaux (image, vidéo, audio) et les remplace, dans l'ordre, par les chaînes de remplacement précalculées produites par *self.replace_image_token* / *self.replace_video_token* / *self.replace_audio_token*. Les remplacements sont consommés séquentiellement depuis la liste de chaque modalité, de sorte que la i-ème occurrence de, par exemple, `self.image_token` est remplacée par `images_replacements[i]`.

Pour ajouter un nouveau processeur multimodal avec des jetons de substitution, vous devez définir un *self.image_token* correct, qui est le même jeton que celui intégré au texte d'entrée et également utilisé comme jeton de substitution et répété de nombreuses fois. Ensuite, vous devez réécrire *self.replace_image_token* pour retourner la chaîne de substitution correcte pour une image donnée à l'index *i*. Il en va de même pour toutes les autres modalités prises en charge.

#### create_mm_token_type_ids[[transformers.ProcessorMixin.create_mm_token_type_ids]]

```python
create_mm_token_type_ids(input_ids: list)
```

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

**Paramètres :**

input_ids (*list[list[int]]*) : Lot de séquences d'identifiants de jetons. Peut être non rembourré (longueur variable), il est donc attendu une liste Python ordinaire de listes plutôt qu'un tenseur ou un tableau de forme uniforme.

**Retourne :** *list[list[int]]*

Une liste de la même structure que `input_ids`, où chaque entier est l'identifiant du type de modalité pour le jeton correspondant.

Construire les identifiants de type de modalité par jeton pour un lot de séquences de token_id.

Chaque position se voit attribuer un entier indiquant la modalité à laquelle elle appartient : `0` pour le texte régulier, `1` pour les jetons d'image, `2` pour les jetons de vidéo et `3` pour les jetons audio. L'appartenance est déterminée par comparaison avec `self.image_token_ids`, `self.video_token_ids` et `self.audio_token_ids`.

#### apply_chat_template[[transformers.ProcessorMixin.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], chat_template: str | None = None, tools: list[dict] | None = None, documents: list[dict[str, str]] | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, return_assistant_tokens_mask: bool = False, tokenize: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = 'auto', return_dict: bool = False, load_audio_from_video: bool = False, processor_kwargs: dict | None = None, **kwargs)
```

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

**Paramètres :**

conversation (`Union[list[Dict, [str, str]], list[list[dict[str, str]]]]`) : La conversation à formater.

chat_template (`Optional[str]`, *facultatif*) : Le modèle Jinja à utiliser pour formater la conversation. S'il n'est pas fourni, le modèle de discussion du tokeniseur est utilisé.

De manière similaire à la méthode `apply_chat_template` des tokenizers, cette méthode applique un modèle Jinja aux conversations d'entrée afin de les transformer en une seule chaîne tokenizable.

L'entrée est attendue au format suivant, où le contenu de chaque message est une liste composée de texte et, le cas échéant, d'entrées image ou vidéo. Il est également possible de fournir une image, une vidéo, une URL ou un chemin local, qui sera utilisé pour former `pixel_values` lorsque `return_dict=True`. En l'absence de cette information, seul le texte formaté, éventuellement tokenisé, sera renvoyé.

conversation = [ { "role": "user", "content": [ {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"}, {"type": "text", "text": "Please describe this image in detail."}, ], }, ]

### Traitement des kwargs[[transformers.ProcessingKwargs]]

Les méthodes `__call__` des classes Processor acceptent des arguments nommés organisés par modalité. Les classes TypedDict suivantes définissent les arguments nommés disponibles pour chaque modalité. Les processeurs spécifiques à un modèle peuvent sous-classes ces classes pour ajouter ou remplacer des champs.

#### transformers.ProcessingKwargs[[transformers.ProcessingKwargs]]

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

Classe de base pour la transmission des kwargs aux processeurs. Si un modèle possède des kwargs spécifiques qui ne sont pas présents dans la classe de base, ou des valeurs par défaut pour des clés existantes, il doit avoir sa propre classe `ModelProcessorKwargs` qui hérite de `ProcessingKwargs` afin de fournir :
1) Clés typées supplémentaires et que ce modèle nécessite pour traiter les entrées.
2) Valeurs par défaut des clés existantes sous l'attribut `_defaults`.
Les nouvelles clés doivent être définies comme suit afin de garantir que l'inférence de types est effectuée correctement.

```python
# adding a new image kwarg for this model
class ModelImagesKwargs(ImagesKwargs, total=False):
    new_image_kwarg: Optional[bool]

class ModelProcessorKwargs(ProcessingKwargs, total=False):
    images_kwargs: ModelImagesKwargs
    _defaults = {
        "images_kwargs: {
            "new_image_kwarg": False,
        }
        "text_kwargs": {
            "padding": "max_length",
        },
    }

```

Pour la compatibilité avec Python 3.8, lors de l'héritage de cette classe et de la surcharge de l'un des kwargs,

vous devez mettre à jour manuellement le dictionnaire __annotations__. Voici comment procéder :

```python
class CustomProcessorKwargs(ProcessingKwargs, total=False):
    images_kwargs: CustomImagesKwargs

CustomProcessorKwargs.__annotations__["images_kwargs"] = CustomImagesKwargs  # python 3.8 compatibility
```

#### transformers.TextKwargs[[transformers.TextKwargs]]

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

**Paramètres :**

add_special_tokens (`bool`, *facultatif*) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*) : Active et contrôle le bourrage.

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*) : Active et contrôle la troncature.

max_length (`int`, *facultatif*) : Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

stride (`int`, *facultatif*) : Si défini, les jetons en dépassement contiendront certains jetons de la fin de la séquence tronquée.

is_split_into_words (`bool`, *facultatif*) : Indique si l'entrée est déjà pré-tokenisée.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie.

return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton.

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention.

return_overflowing_tokens (`bool`, *facultatif*) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement.

return_special_tokens_mask (`bool`, *facultatif*) : Indique s'il faut ou non renvoyer les informations du masque des jetons spéciaux.

return_offsets_mapping (`bool`, *facultatif*) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton.

return_length (`bool`, *facultatif*) : Indique s'il faut ou non retourner les longueurs des entrées encodées.

verbose (`bool`, *facultatif*) : Indique s'il faut afficher plus d'informations et d'avertissements.

padding_side (`str`, *facultatif*) : Le côté sur lequel le bourrage sera appliqué.

return_mm_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton multimodal indiquant les positions des jetons de substitution multimodaux.

return_text_replacement_offsets (`bool`, *facultatif*) : Indique s'il faut retourner les décalages de caractères pour chaque emplacement réservé mm et son remplacement.

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

Arguments de mots-clés pour le traitement du texte. Pour une documentation étendue, consultez les méthodes et les docstrings associées de tokenization_utils_base.

#### transformers.ImagesKwargs[[transformers.ImagesKwargs]]

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

**Paramètres :**

do_convert_rgb (`bool`) : Indique s'il faut convertir l'image au format RGB.

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

size (`dict[str, int]`, *facultatif*) : Redimensionner à l'aide de l'un des dictionnaires de taille pris en charge. Les limites de surface en pixels utilisent `{"min_pixels": int, "max_pixels": int}`.

default_to_square (`bool`, *facultatif*, valeur par défaut `self.default_to_square`) : Indique s'il faut utiliser un carré par défaut lors du redimensionnement, si la taille est un entier.

crop_size (`dict[str, int]`, *facultatif*) : Taille de sortie souhaitée lors de l'application d'un recadrage centré.

resample (`PILImageResampling`, *facultatif*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image.

do_rescale (`bool`, *facultatif*) : Indique s'il faut redimensionner l'image selon l'échelle spécifiée `rescale_factor`.

rescale_factor (`int` ou `float`, *facultatif*) : Facteur d'échelle à utiliser lors du redimensionnement de l'image.

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

image_mean (`float` ou `list[float] or tuple[float, float, float]`, *facultatif*) : Moyenne à utiliser pour normaliser l'image.

image_std (`float` ou `list[float] or tuple[float, float, float]`, *facultatif*) : Écart-type à utiliser lors de la normalisation de l'image.

do_pad (`bool`, *facultatif*) : Indique s'il faut mettre en bourrage les images du lot.

pad_size (`dict[str, int]`, *facultatif*) : La taille `{"height": int, "width" int}` à laquelle rembourrer les images.

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

data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour l'image de sortie.

input_data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée.

device (`Union[str, torch.Tensor]`, *facultatif*) : L'appareil à utiliser pour le traitement (par exemple "cpu", "cuda"), pertinent uniquement pour l'arrière-plan torchvision.

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

disable_grouping (`bool`, *facultatif*) : Indique s'il faut regrouper les images par forme lors du traitement ou non ; ne concerne que l'arrière-plan torchvision.

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

Arguments de mots-clés pour le traitement d'images. Pour une documentation étendue, consultez les méthodes et les docstrings de la classe ImageProcessor appropriée.

#### transformers.VideosKwargs[[transformers.VideosKwargs]]

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

**Paramètres :**

do_convert_rgb (`bool`) : Indique s'il faut convertir la vidéo au format RGB.

do_resize (`bool`) : Indique s'il faut redimensionner la vidéo.

size (`dict[str, int]`, *facultatif*) : Redimensionner le côté le plus court de l'entrée à `size["shortest_edge"]`.

default_to_square (`bool`, *facultatif*, valeur par défaut `self.default_to_square`) : Indique s'il faut utiliser un carré par défaut lors du redimensionnement, si la taille est un entier.

resample (`PILImageResampling`, *facultatif*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de la vidéo.

do_rescale (`bool`, *facultatif*) : Indique s'il faut redimensionner la vidéo selon le facteur de mise à l'échelle `rescale_factor` spécifié.

rescale_factor (`int` ou `float`, *facultatif*) : Facteur d'échelle à utiliser lors du redimensionnement de la vidéo.

do_normalize (`bool`, *facultatif*) : Indique s'il faut normaliser la vidéo.

image_mean (`float` ou `list[float] or tuple[float, float, float]`, *facultatif*) : Moyenne à utiliser lors de la normalisation de la vidéo.

image_std (`float` ou `list[float] or tuple[float, float, float]`, *facultatif*) : Écart-type à utiliser lors de la normalisation de la vidéo.

do_center_crop (`bool`, *facultatif*) : Indique s'il faut effectuer un recadrage centré sur la vidéo.

do_pad (`bool`, *facultatif*) : Indique s'il faut mettre en bourrage les images du lot.

do_sample_frames (`bool`, *facultatif*) : Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter l'intégralité de la vidéo.

video_metadata (`Union[VideoMetadata, dict]`, *facultatif*) : Métadonnées de la vidéo contenant des informations sur la durée totale, le nombre d'images par seconde (fps) et le nombre total d'images.

num_frames (`int`, *facultatif*) : Nombre maximal d'images à échantillonner lorsque `do_sample_frames=True`.

fps (`int` ou `float`, *facultatif*) : Nombre de cibles d'images à échantillonner par seconde lorsque `do_sample_frames=True`.

crop_size (`dict[str, int]`, *facultatif*) : Taille de sortie souhaitée lors de l'application d'un recadrage centré.

data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour la vidéo de sortie.

input_data_format (`ChannelDimension` ou `str`, *facultatif*) : Le format de la dimension des canaux pour la vidéo d'entrée.

device (`Union[str, torch.Tensor]`, *facultatif*) : L'appareil à utiliser pour le traitement (par exemple "cpu", "cuda"), pertinent uniquement pour le traitement d'images rapide.

return_metadata (`bool`, *facultatif*) : Indique s'il faut renvoyer les métadonnées de la vidéo ou non.

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

Arguments de mots-clés pour le traitement vidéo.

#### transformers.AudioKwargs[[transformers.AudioKwargs]]

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

**Paramètres :**

sampling_rate (`int`, *facultatif*) : Le taux d'échantillonnage auquel l'entrée `raw_speech` a été échantillonnée.

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La séquence ou le lot de séquences à rembourrer. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Doit être un audio mono, pas stéréo, c'est-à-dire un seul flottant par pas de temps.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*) : 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'` : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le 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'`

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

truncation (`bool`, *facultatif*) : 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 rembourdée jusqu'à un multiple de la valeur fournie.

return_attention_mask (`bool`, *facultatif*) : Indique si [__call__()](/docs/transformers/main/fr/model_doc/audio-spectrogram-transformer#transformers.ASTFeatureExtractor.__call__) doit renvoyer `attention_mask`.

device (`str` ou `torch.device`, *facultatif*) : L'appareil sur lequel calculer les caractéristiques audio (par exemple "cpu", "cuda"), pertinent uniquement pour les extracteurs de caractéristiques qui les calculent avec torch.

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

load_audio_backend (`str`, *facultatif*) : Backend utilisé par `load_audio()` pour décoder/rééchantillonner l'audio référencé par URL/chemin dans `apply_chat_template`. L'un des `"auto"`, `"torchcodec"`, `"librosa"`, `"torchaudio"`.

Arguments de mot-clé pour le traitement audio.