# PatchTSMixer

## Aperçu

Le modèle PatchTSMixer a été proposé dans [TSMixer: Lightweight MLP-Mixer Model for Multivariate Time Series Forecasting](https://huggingface.co/papers/2306.09364) par Vijay Ekambaram, Arindam Jati, Nam Nguyen, Phanwadee Sinthong et Jayant Kalagnanam.

PatchTSMixer est une approche de modélisation de séries temporelles légère, fondée sur l'architecture MLP-Mixer. Dans cette implémentation HuggingFace, nous mettons à disposition les capacités de PatchTSMixer pour faciliter sans effort le mélange léger entre les patches, les canaux et les caractéristiques cachées, afin de réaliser une modélisation efficace de séries temporelles multivariées. Il prend également en charge divers mécanismes d'attention, allant de l'attention simple à porte jusqu'à des blocs d'auto-attention plus complexes, qui peuvent être personnalisés en conséquence. Le modèle peut être pré-entraîné puis utilisé pour diverses tâches en aval, telles que la prévision, la classification et la régression.

L'abstract de l'article est le suivant :

*TSMixer est une architecture neuronale légère, composée exclusivement de modules de perceptrons multicouches (MLP), conçue pour la prévision multivariée et l'apprentissage de représentations sur des séries temporelles segmentées. Notre modèle s'inspire du succès des modèles MLP-Mixer en vision par ordinateur. Nous mettons en lumière les difficultés liées à l'adaptation du Vision MLP-Mixer aux séries temporelles et introduisons des composants validés empiriquement pour améliorer la précision. Cela inclut un nouveau paradigme de conception consistant à attacher des têtes de réconciliation en ligne à l'architecture de base MLP-Mixer, afin de modéliser explicitement les propriétés des séries temporelles telles que la hiérarchie et les corrélations entre canaux. Nous proposons également une approche de modélisation hybride des canaux pour traiter efficacement les interactions de canaux bruitées et la généralisation à travers des jeux de données variés, un défi commun aux méthodes existantes de mélange de canaux par segments. En outre, un mécanisme d'attention à porte simple est introduit dans l'architecture de base pour prioriser les caractéristiques importantes. En intégrant ces composants légers, nous renforçons considérablement la capacité d'apprentissage des structures MLP simples, surpassant les modèles Transformer complexes avec un usage minimal des ressources de calcul. De plus, la conception modulaire de TSMixer permet la compatibilité avec les méthodes d'apprentissage supervisé et auto-supervisé masqué, en faisant un bloc de construction prometteur pour les modèles de fondation de séries temporelles. TSMixer surpasse les modèles MLP et Transformer de pointe en prévision avec une marge considérable de 8 à 60 %. Il surpasse également les derniers benchmarks solides des modèles Patch-Transformer (de 1 à 2 %) avec une réduction significative de la mémoire et du temps d'exécution (2 à 3 fois).*

Ce modèle a été contribué par [ajati](https://huggingface.co/ajati), [vijaye12](https://huggingface.co/vijaye12), [gsinthong](https://huggingface.co/gsinthong), [namctin](https://huggingface.co/namctin), [wmgifford](https://huggingface.co/wmgifford), [kashif](https://huggingface.co/kashif).

## Exemple d'utilisation

L'extrait de code ci-dessous montre comment initialiser aléatoirement un modèle PatchTSMixer. Le modèle est compatible avec l'[API Trainer](../trainer).

```python

from transformers import PatchTSMixerConfig, PatchTSMixerForPrediction
from transformers import Trainer, TrainingArguments,

config = PatchTSMixerConfig(context_length = 512, prediction_length = 96)
model = PatchTSMixerForPrediction(config)
trainer = Trainer(model=model, args=training_args, 
            train_dataset=train_dataset,
            eval_dataset=valid_dataset)
trainer.train()
results = trainer.evaluate(test_dataset)
```

## Conseils d'utilisation

Le modèle peut également être utilisé pour la classification de séries temporelles et la régression de séries temporelles. Consultez les classes respectives [PatchTSMixerForTimeSeriesClassification](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerForTimeSeriesClassification) et [PatchTSMixerForRegression](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerForRegression).

## Ressources

- Un article de blogue expliquant en profondeur PatchTSMixer est disponible [ici](https://huggingface.co/blog/patchtsmixer). Le blog peut également être ouvert dans Google Colab.

## PatchTSMixerConfig[[transformers.PatchTSMixerConfig]]

#### transformers.PatchTSMixerConfig[[transformers.PatchTSMixerConfig]]

```python
transformers.PatchTSMixerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, context_length: int = 32, patch_length: int = 8, num_input_channels: int = 1, patch_stride: int = 8, num_parallel_samples: int = 100, d_model: int = 8, expansion_factor: int = 2, num_layers: int = 3, dropout: float | int = 0.2, mode: str = 'common_channel', gated_attn: bool = True, norm_mlp: str = 'LayerNorm', self_attn: bool = False, self_attn_heads: int = 1, use_positional_encoding: bool = False, positional_encoding_type: str = 'sincos', scaling: str | bool | None = 'std', loss: str = 'mse', init_std: float = 0.02, norm_eps: float = 1e-05, mask_type: str = 'random', random_mask_ratio: float = 0.5, num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,), mask_value: int = 0, masked_loss: bool = True, channel_consistent_masking: bool = True, unmasked_channel_indices: list[int] | None = None, head_dropout: float | int = 0.2, distribution_output: str = 'student_t', prediction_length: int = 16, prediction_channel_indices: list | None = None, num_targets: int = 3, output_range: list | None = None, head_aggregation: str | None = 'max_pool')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/configuration_patchtsmixer.py#L24)

**Paramètres :**

context_length (`int`, *facultatif*, valeur par défaut : 32) : La longueur du contexte/historique pour la séquence d'entrée.

patch_length (`int`, *facultatif*, valeur par défaut : 8) : La longueur de la tuile pour la séquence d'entrée.

num_input_channels (`int`, *facultatif*, par défaut `1`) : Le nombre de canaux d'entrée.

patch_stride (`int`, *facultatif*, valeur par défaut : 8) : Détermine le chevauchement entre deux patches consécutifs. Définissez-le sur patch_length (ou une valeur supérieure) si vous souhaitez des patches non chevauchants.

num_parallel_samples (`int`, *facultatif*, valeur par défaut 100) : Le nombre d'échantillons à générer en parallèle pour la prévision probabiliste.

d_model (`int`, *facultatif*, valeur par défaut `8`) : Taille des couches d'encodeur et de la couche pooler.

expansion_factor (`int`, *facultatif*, valeur par défaut : 2) : Facteur d'expansion à utiliser dans le MLP. La plage recommandée est de 2 à 5. Une valeur plus élevée indique un modèle plus complexe.

num_layers (`int`, *facultatif*, valeur par défaut `3`) : Nombre de couches cachées dans le décodeur Transformer.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.2`) : Le ratio pour toutes les couches de dropout.

mode (`str`, *facultatif*, valeur par défaut `"common_channel"`) : Mode du mélangeur. Détermine la manière de traiter les canaux. Valeurs autorisées : "common_channel", "mix_channel". En mode "common_channel", nous adoptons un modélisation indépendante des canaux, sans mélange explicite des canaux. Le mélange des canaux se fait de manière implicite grâce à des poids partagés entre les canaux. (approche recommandée en premier lieu) En mode "mix_channel", nous adoptons un mélange explicite des canaux, en plus du mélangeur de patches et de caractéristiques. (approche recommandée lorsque les corrélations entre canaux sont très importantes à modéliser)

gated_attn (`bool`, *facultatif*, valeur par défaut `True`) : Active l'Attention à porte (Gated Attention).

norm_mlp (`str`, *facultatif*, par défaut `"LayerNorm"`) : couche de normalisation (BatchNorm ou LayerNorm).

self_attn (`bool`, *facultatif*, valeur par défaut `False`) : Active la Tiny self attention entre les patches. Cette option peut être activée lorsque la sortie de Vanilla PatchTSMixer avec attention à porte n'est pas satisfaisante. Son activation entraîne une attention explicite par paires et un modélisation entre les patches.

self_attn_heads (`int`, *facultatif*, valeur par défaut : 1) : Nombre de têtes d'auto-attention. Fonctionne uniquement lorsque `self_attn` est défini sur `True`.

use_positional_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Active l'utilisation de l'encodage positionnel pour les couches d'auto-attention de petite taille. Fonctionne uniquement lorsque `self_attn` est défini sur `True`.

positional_encoding_type (`str`, *facultatif*, par défaut `"sincos"`) : Encodages positionnels. Les options `"random"` et `"sincos"` sont prises en charge. Fonctionne uniquement lorsque `use_positional_encoding` est défini sur `True`

scaling (`string` ou `bool`, *facultatif*, valeur par défaut `"std"`) : Indique si les cibles d'entrée doivent être mises à l'échelle via un scaler "mean", un scaler "std" ou aucun scaler si `None`. Si `True`, le scaler est défini sur "mean".

loss (`string`, *facultatif*, valeur par défaut `"mse"`) : La fonction de perte du modèle correspondant à la tête `distribution_output`. Pour les distributions paramétriques, il s'agit de la log-vraisemblance négative ("nll") et pour les estimations ponctuelles, de l'erreur quadratique moyenne "mse".

init_std (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

norm_eps (`float`, *facultatif*, valeur par défaut 1e-05) : Une valeur ajoutée au dénominateur pour assurer la stabilité numérique de la normalisation.

mask_type (`str`, *facultatif*, valeur par défaut `"random"`) : Type de masquage à utiliser pour le mode Masked Pretraining. Les valeurs autorisées sont "random" et "forecast". Dans le masquage aléatoire, les points sont masqués de manière aléatoire. Dans le masquage de prévision, les points sont masqués vers la fin.

random_mask_ratio (`float`, *facultatif*, valeur par défaut 0,5) : Taux de masquage à utiliser lorsque `mask_type` est `random`. Une valeur plus élevée indique un masquage plus important.

num_forecast_mask_patches (`int` ou `list`, *facultatif*, valeur par défaut `[2]`) : Nombre de patches à masquer à la fin de chaque échantillon du lot. S'il s'agit d'un entier, tous les échantillons du lot auront le même nombre de patches masqués. S'il s'agit d'une liste, les échantillons du lot seront masqués aléatoirement selon les nombres définis dans la liste. Cet argument n'est utilisé que pour le pré-entraînement de prévision.

mask_value (`float`, *facultatif*, valeur par défaut `0.0`) : Valeur du masque à utiliser.

masked_loss (`bool`, *facultatif*, par défaut `True`) : Indique si la perte de pré-entraînement doit être calculée uniquement sur les portions masquées ou sur l'ensemble de la sortie.

channel_consistent_masking (`bool`, *facultatif*, valeur par défaut `True`) : Si la valeur est true, le masquage sera identique sur tous les canaux d'une série temporelle. Sinon, les positions de masquage varieront d'un canal à l'autre.

unmasked_channel_indices (`list`, *facultatif*) : Canaux qui ne sont pas masqués lors de la préformation.

head_dropout (`float`, *facultatif*, valeur par défaut 0,2) : La probabilité de dropout de la tête `PatchTSMixer`.

distribution_output (`string`, *facultatif*, valeur par défaut `"student_t"`) : La tête d'émission de distribution du modèle lorsque la perte est "nll". Peut être "student_t", "normal" ou "negative_binomial".

prediction_length (`int`, *facultatif*, valeur par défaut : 16) : Nombre d'étapes temporelles à prévoir pour une tâche de prévision. Également connu sous le nom d'Horizon de prévision.

prediction_channel_indices (`list`, *facultatif*) : Liste des indices de canaux à prévoir. Si None, tous les canaux sont prévus. Les données cibles sont censées contenir tous les canaux et nous filtrons explicitement les canaux dans la prédiction et la cible avant le calcul de la perte.

num_targets (`int`, *facultatif*, valeur par défaut : 3) : Nombre de cibles (dimension de la variable régressée) pour une tâche de régression.

output_range (`list`, *facultatif*) : Plage de sortie à restreindre pour la tâche de régression. Valeur par défaut : None.

head_aggregation (`str`, *facultatif*, valeur par défaut `"max_pool"`) : Mode d'agrégation à activer pour une tâche de classification ou de régression. Les valeurs autorisées sont `None`, "use_last", "max_pool", "avg_pool".

Ceci est la classe de configuration destinée à stocker la configuration d'un PatchTSMixerModel. Elle est utilisée pour instancier un modèle Patchtsmixer en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [ibm/patchtsmixer-etth1-pretrain](https://huggingface.co/ibm/patchtsmixer-etth1-pretrain)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import PatchTSMixerConfig, PatchTSMixerModel

>>> # Initializing a default PatchTSMixer configuration
>>> configuration = PatchTSMixerConfig()

>>> # Randomly initializing a model (with random weights) from the configuration
>>> model = PatchTSMixerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## PatchTSMixerModel[[transformers.PatchTSMixerModel]]

#### transformers.PatchTSMixerModel[[transformers.PatchTSMixerModel]]

```python
transformers.PatchTSMixerModel(config: PatchTSMixerConfig, mask_input: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1200)

**Paramètres :**

config ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

mask_input (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut masquer l'entrée à l'aide du module `PatchTSMixerMasking`.

Le modèle PatchTSMixer pour la prévision de séries temporelles.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.PatchTSMixerModel.forward]]

```python
forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1226)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, seq_length, num_input_channels)`) : Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée pour prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle. Pour les séries temporelles univariées, la dimension `num_input_channels` doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.

observed_mask (`torch.Tensor` de forme `(batch_size, sequence_length, num_input_channels)`, *facultatif*) : Masque booléen indiquant quels `past_values` ont été observés et lesquels sont manquants. Les valeurs du masque sont sélectionnées dans `[0, 1]` : - 1 pour les valeurs **observées**, - 0 pour les valeurs **manquantes** (c.-à-d. les NaN remplacés par des zéros).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

**Retourne :** `PatchTSMixerModelOutput` ou `tuple(torch.Tensor)`

Un `PatchTSMixerModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) et les entrées.

La méthode forward du modèle [PatchTSMixerModel](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_channels, num_patches, d_model)`) -- État caché à la sortie de la dernière couche du modèle.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- États cachés du modèle à la sortie de chaque couche.
- **patch_input** (`torch.Tensor` de forme `(batch_size, num_channels, num_patches, patch_length)`) -- Données d'entrée patchées pour le modèle.
- **mask** (`torch.Tensor` de forme `(batch_size, num_channels, num_patches)`, *facultatif*) -- Tenseur Bool indiquant True pour les patches masqués et False sinon.
- **loc** (`torch.Tensor` de forme `(batch_size, 1, num_channels)`, *facultatif*) -- Donne la moyenne de la fenêtre de contexte par canal. Utilisé pour la dénormalisation revin en dehors du modèle, si revin est activé.
- **scale** (`torch.Tensor` de forme `(batch_size, 1, num_channels)`, *facultatif*) -- Donne l'écart-type de la fenêtre de contexte par canal. Utilisé pour la dénormalisation revin en dehors du modèle, si revin est activé.

## PatchTSMixerForPrediction[[transformers.PatchTSMixerForPrediction]]

#### transformers.PatchTSMixerForPrediction[[transformers.PatchTSMixerForPrediction]]

```python
transformers.PatchTSMixerForPrediction(config: PatchTSMixerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1481)

**Paramètres :**

config (`PatchTSMixerConfig`) : Configuration.

**Retourne :**

`None`.

`PatchTSMixer` pour les applications de prévision.

#### forward[[transformers.PatchTSMixerForPrediction.forward]]

```python
forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1523)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, seq_length, num_input_channels)`) : Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée pour prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle. Pour les séries temporelles univariées, la dimension `num_input_channels` doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.

observed_mask (`torch.Tensor` de forme `(batch_size, sequence_length, num_input_channels)`, *facultatif*) : Masque booléen indiquant quels `past_values` ont été observés et lesquels sont manquants. Les valeurs du masque sont sélectionnées dans `[0, 1]` : - 1 pour les valeurs **observées**, - 0 pour les valeurs **manquantes** (c.-à-d. les NaN remplacés par des zéros).

future_values (`torch.Tensor` de forme `(batch_size, target_len, num_input_channels)` pour la prévision, : `(batch_size, num_targets)` pour la régression, ou `(batch_size,)` pour la classification, *facultatif*) : Valeurs cibles de la série temporelle, servant d'étiquettes pour le modèle. Les `future_values` sont ce dont le Transformer a besoin pendant l'entraînement pour apprendre à produire une sortie, étant donné les `past_values`. Notez que cela n'est PAS requis pour une tâche de pré-entraînement. Pour une tâche de prévision, la forme doit être `(batch_size, target_len, num_input_channels)`. Même si vous souhaitez ne prévoir que des canaux spécifiques en définissant les indices dans le paramètre `prediction_channel_indices`, passez les données cibles avec tous les canaux, car le filtrage des canaux pour la prévision et la cible sera appliqué manuellement avant le calcul de la perte.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_loss (`bool`,  *facultatif*) : Indique s'il faut retourner la perte lors de l'appel `forward`.

**Retourne :** `PatchTSMixerForPredictionOutput` ou `tuple(torch.Tensor)`

Un `PatchTSMixerForPredictionOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) et les entrées.

La méthode forward de [PatchTSMixerForPrediction](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerForPrediction) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`*optional*`, returned when `y` is provided, `torch.Tensor` of shape `()`) -- Total loss.
- **prediction_outputs** (`torch.Tensor` de forme `(batch_size, prediction_length, num_input_channels)`) -- Sortie de prédiction issue de la tête de prévision.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings du backbone avant le passage par la tête.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **loc** (`torch.Tensor`, *facultatif* de forme `(batch_size, 1, num_input_channels)`) -- Moyenne d'entrée
- **scale** (`torch.Tensor`, *facultatif* de forme `(batch_size, 1, num_input_channels)`) -- Écart-type de l'entrée

## PatchTSMixerForTimeSeriesClassification[[transformers.PatchTSMixerForTimeSeriesClassification]]

#### transformers.PatchTSMixerForTimeSeriesClassification[[transformers.PatchTSMixerForTimeSeriesClassification]]

```python
transformers.PatchTSMixerForTimeSeriesClassification(config: PatchTSMixerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1707)

**Paramètres :**

config (`PatchTSMixerConfig`) : Configuration.

**Retourne :**

`None`.

`PatchTSMixer` pour une application de classification.

#### forward[[transformers.PatchTSMixerForTimeSeriesClassification.forward]]

```python
forward(past_values: Tensor, target_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1734)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, seq_length, num_input_channels)`) : Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée pour prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle. Pour les séries temporelles univariées, la dimension `num_input_channels` doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.

target_values (`torch.Tensor` de forme `(batch_size, target_len, num_input_channels)` pour la prévision, : `(batch_size, num_targets)` pour la régression, ou `(batch_size,)` pour la classification, *facultatif*) : valeurs cibles de la série temporelle, servant d’étiquettes pour le modèle. `target_values` est ce que le Transformer doit apprendre à produire pendant l’entraînement, étant donné `past_values`. Notez que ce paramètre n’est PAS requis pour une tâche de pré-entraînement. Pour une tâche de prévision, la forme est `(batch_size, target_len, num_input_channels)`. Même si l’on souhaite ne prévoir que des canaux spécifiques en définissant les indices dans le paramètre `prediction_channel_indices`, il faut transmettre les données cibles avec tous les canaux, car le filtrage des canaux pour la prévision et la cible sera appliqué manuellement avant le calcul de la perte. Pour une tâche de classification, la forme est `(batch_size,)`. Pour une tâche de régression, la forme est `(batch_size, num_targets)`.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_loss (`bool`, *facultatif*) : Indique s'il faut retourner la perte lors de l'appel `forward`.

**Retourne :** `PatchTSMixerForTimeSeriesClassificationOutput` ou `tuple(torch.Tensor)`

Un `PatchTSMixerForTimeSeriesClassificationOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) et les entrées.

La méthode forward de [PatchTSMixerForTimeSeriesClassification](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerForTimeSeriesClassification) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`*optional*`, returned when `y` is provided, `torch.Tensor` of shape `()`) -- Total loss.
- **prediction_outputs** (`torch.Tensor` de forme `(batch_size, num_labels)`) -- Sortie de prédiction de la tête de classification.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings du backbone avant le passage par la tête.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

## PatchTSMixerForPretraining[[transformers.PatchTSMixerForPretraining]]

#### transformers.PatchTSMixerForPretraining[[transformers.PatchTSMixerForPretraining]]

```python
transformers.PatchTSMixerForPretraining(config: PatchTSMixerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1313)

**Paramètres :**

config ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

`PatchTSMixer` pour la préformation par masquage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.PatchTSMixerForPretraining.forward]]

```python
forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1323)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, seq_length, num_input_channels)`) : Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée pour prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle. Pour les séries temporelles univariées, la dimension `num_input_channels` doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.

observed_mask (`torch.Tensor` de forme `(batch_size, sequence_length, num_input_channels)`, *facultatif*) : Masque booléen indiquant quels `past_values` ont été observés et lesquels sont manquants. Les valeurs du masque sont sélectionnées dans `[0, 1]` : - 1 pour les valeurs **observées**, - 0 pour les valeurs **manquantes** (c.-à-d. les NaN remplacés par des zéros).

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_loss (`bool`,  *facultatif*) : Indique s'il faut retourner la perte lors de l'appel `forward`.

**Retourne :** `PatchTSMixerForPreTrainingOutput` ou `tuple(torch.Tensor)`

Un `PatchTSMixerForPreTrainingOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) et les entrées.

La méthode forward de [PatchTSMixerForPretraining](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerForPretraining) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`*optional*`, returned when `y` is provided, `torch.Tensor` of shape `()`) -- Total loss
- **prediction_outputs** (`torch.Tensor` de forme `(batch_size, num_input_channels, num_patches, patch_length)`) -- Sortie de prédiction issue de la tête de pré-entraînement.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings du backbone avant le passage par la tête.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- États cachés du modèle à la sortie de chaque couche.

## PatchTSMixerForRegression[[transformers.PatchTSMixerForRegression]]

#### transformers.PatchTSMixerForRegression[[transformers.PatchTSMixerForRegression]]

```python
transformers.PatchTSMixerForRegression(config: PatchTSMixerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1875)

**Paramètres :**

config ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

`PatchTSMixer` pour une application de régression.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.PatchTSMixerForRegression.forward]]

```python
forward(past_values: Tensor, target_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1913)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, seq_length, num_input_channels)`) : Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée pour prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle. Pour les séries temporelles univariées, la dimension `num_input_channels` doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.

target_values (`torch.Tensor` de forme `(batch_size, target_len, num_input_channels)` pour la prévision, : `(batch_size, num_targets)` pour la régression, ou `(batch_size,)` pour la classification, *facultatif*) : valeurs cibles de la série temporelle, servant d’étiquettes pour le modèle. `target_values` est ce que le Transformer doit apprendre à produire pendant l’entraînement, étant donné `past_values`. Notez que ce paramètre n’est PAS requis pour une tâche de pré-entraînement. Pour une tâche de prévision, la forme est `(batch_size, target_len, num_input_channels)`. Même si l’on souhaite ne prévoir que des canaux spécifiques en définissant les indices dans le paramètre `prediction_channel_indices`, il faut transmettre les données cibles avec tous les canaux, car le filtrage des canaux pour la prévision et la cible sera appliqué manuellement avant le calcul de la perte. Pour une tâche de classification, la forme est `(batch_size,)`. Pour une tâche de régression, la forme est `(batch_size, num_targets)`.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_loss (`bool`, *facultatif*) : Indique s'il faut retourner la perte lors de l'appel `forward`.

**Retourne :** `PatchTSMixerForRegressionOutput` ou `tuple(torch.Tensor)`

Un `PatchTSMixerForRegressionOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PatchTSMixerConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) et les entrées.

La méthode forward de [PatchTSMixerForRegression](/docs/transformers/v5.23.0/fr/model_doc/patchtsmixer#transformers.PatchTSMixerForRegression) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`*optional*`, returned when `y` is provided, `torch.Tensor` of shape `()`) -- Total loss.
- **regression_outputs** (`torch.Tensor` de forme `(batch_size, num_targets)`) -- Sortie de prédiction de la tête de régression.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings du backbone avant le passage par la tête.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

