# PatchTST

## Aperçu

Le modèle PatchTST a été proposé dans [A Time Series is Worth 64 Words: Long-term Forecasting with Transformers](https://huggingface.co/papers/2211.14730) par Yuqi Nie, Nam H. Nguyen, Phanwadee Sinthong et Jayant Kalagnanam.

De manière générale, le modèle vectorise les séries temporelles en patches d'une taille donnée et encode la séquence de vecteurs résultante via un Transformer, qui produit ensuite la prévision de la longueur de prédiction souhaitée via une tête appropriée. Le modèle est illustré dans la figure suivante :

![model](https://github.com/namctin/transformers/assets/8100/150af169-29de-419a-8d98-eb78251c21fa)

L'abstract de l'article est le suivant :

*Nous proposons une conception efficace de modèles basés sur les Transformers pour la prévision de séries temporelles multivariées et l'apprentissage de représentations auto-supervisées. Elle repose sur deux composants clés : (i) le découpage des séries temporelles en patches au niveau des sous-séries, qui servent de jetons d'entrée au Transformer ; (ii) l'indépendance des canaux, où chaque canal contient une série temporelle univariée unique qui partage les mêmes poids d'embedding et de Transformer entre toutes les séries. La conception par patches présente naturellement un triple avantage : les informations sémantiques locales sont conservées dans l'embedding ; le calcul et l'utilisation de la mémoire des cartes d'attention sont réduits de manière quadratique pour une même fenêtre de retour en arrière ; et le modèle peut prendre en compte un historique plus long. Notre Transformer de séries temporelles par patches à canaux indépendants (PatchTST) améliore significativement la précision des prévisions à long terme par rapport aux modèles basés sur les Transformers de l'état de l'art. Nous appliquons également notre modèle à des tâches de pré-entraînement auto-supervisé et obtenons d'excellentes performances de fine-tuning, qui surpassent l'entraînement supervisé sur de grands jeux de données. Le transfert de représentations pré-entraînées masquées d'un jeu de données à d'autres produit également une précision de prévision de l'état de l'art.*

Ce modèle a été contribué par [namctin](https://huggingface.co/namctin), [gsinthong](https://huggingface.co/gsinthong), [diepi](https://huggingface.co/diepi), [vijaye12](https://huggingface.co/vijaye12), [wmgifford](https://huggingface.co/wmgifford) et [kashif](https://huggingface.co/kashif). Le code d'origine peut être trouvé [ici](https://github.com/yuqinie98/PatchTST).

## 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 [PatchTSTForClassification](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTForClassification) et [PatchTSTForRegression](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTForRegression).

## Ressources

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

## PatchTSTConfig[[transformers.PatchTSTConfig]]

#### transformers.PatchTSTConfig[[transformers.PatchTSTConfig]]

```python
transformers.PatchTSTConfig(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, num_input_channels: int = 1, context_length: int = 32, distribution_output: str = 'student_t', loss: str | None = 'mse', patch_length: int = 1, patch_stride: int = 1, num_hidden_layers: int = 3, d_model: int = 128, num_attention_heads: int = 4, share_embedding: bool = True, channel_attention: bool = False, ffn_dim: int = 512, norm_type: str = 'batchnorm', norm_eps: float = 1e-05, attention_dropout: float | int = 0.0, positional_dropout: float | int = 0.0, path_dropout: float | int = 0.0, ff_dropout: float | int = 0.0, bias: bool = True, activation_function: str = 'gelu', pre_norm: bool = True, positional_encoding_type: str = 'sincos', use_cls_token: bool = False, init_std: float = 0.02, share_projection: bool = True, scaling: str | bool | None = 'std', do_mask_input: bool | None = None, mask_type: str = 'random', random_mask_ratio: float = 0.5, num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,), channel_consistent_masking: bool | None = False, unmasked_channel_indices: list[int] | None = None, mask_value: int = 0, pooling_type: str | None = 'mean', head_dropout: float | int = 0.0, prediction_length: int = 24, num_targets: int = 1, output_range: list | None = None, num_parallel_samples: int = 100)
```

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

**Paramètres :**

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

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

distribution_output (`str`, *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".

loss (`str`, *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 négative de la log-vraisemblance ("nll") et pour les estimations ponctuelles, il s'agit de l'erreur quadratique moyenne "mse".

patch_length (`int`, *facultatif*, valeur par défaut 1) : Définit la longueur des patchs du processus de patchification.

patch_stride (`int`, *facultatif*, valeur par défaut : 1) : Définit le pas du processus de patchification.

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

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

num_attention_heads (`int`, *facultatif*, valeur par défaut : 4) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

share_embedding (`bool`, *facultatif*, valeur par défaut `True`) : Partage de l'embedding d'entrée entre tous les canaux.

channel_attention (`bool`, *facultatif*, par défaut `False`) : Active le bloc d'attention de canal dans le Transformer pour permettre aux canaux de s'attacher mutuellement.

ffn_dim (`int`, *facultatif*, valeur par défaut : 512) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur Transformer.

norm_type (`str` , *facultatif*, par défaut `"batchnorm"`) : Normalisation à chaque couche Transformer. Peut être `"batchnorm"` ou `"layernorm"`.

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.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

positional_dropout (`float`, *facultatif*, valeur par défaut 0.0) : La probabilité de dropout dans la couche d'incorporation positionnelle.

path_dropout (`float`, *facultatif*, valeur par défaut 0.0) : Le taux de dropout dans le bloc résiduel.

ff_dropout (`float`, *facultatif*, valeur par défaut 0.0) : La probabilité de dropout utilisée entre les deux couches des réseaux feed-forward.

bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais dans les réseaux feed-forward.

activation_function (`str`, *facultatif*, valeur par défaut `"gelu"`) : Fonction d'activation non linéaire (chaîne de caractères) du Transformer. `"gelu"` et `"relu"` sont pris en charge.

pre_norm (`bool`, *facultatif*, valeur par défaut `True`) : La normalisation est appliquée avant l'auto-attention si pre_norm est défini sur `True`. Sinon, la normalisation est appliquée après le bloc résiduel.

positional_encoding_type (`str`, *facultatif*, valeur par défaut `"sincos"`) : Encodages positionnels. Les options `"random"` et `"sincos"` sont prises en charge.

use_cls_token (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le jeton cls est utilisé.

init_std (`float`, *facultatif*, valeur par défaut 0.02) : L'écart-type de la distribution normale tronquée utilisée pour l'initialisation des poids.

share_projection (`bool`, *facultatif*, valeur par défaut `True`) : Partage de la couche de projection entre les différents canaux de la tête de prévision.

scaling (`Union`, *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 ».

do_mask_input (`bool`, *facultatif*) : Applique le masquage pendant le pré-entraînement.

mask_type (`str`, *facultatif*, valeur par défaut `"random"`) : Type de masquage. Seuls `"random"` et `"forecast"` sont actuellement pris en charge.

random_mask_ratio (`float`, *facultatif*, valeur par défaut 0,5) : Taux de masquage appliqué pour masquer les données d'entrée lors de la préformation aléatoire.

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.

channel_consistent_masking (`bool`, *facultatif*, valeur par défaut `False`) : Si le masquage cohérent par canal est True, tous les canaux auront le même motif de masquage.

unmasked_channel_indices (`list`, *facultatif*) : Indices des canaux qui ne sont pas masqués pendant le pré-entraînement. Les valeurs de la liste sont des nombres compris entre 1 et `num_input_channels`

mask_value (`int`, *facultatif*, valeur par défaut 0) : Les valeurs des patches masqués seront remplies par `mask_value`.

pooling_type (`str`, *facultatif*, valeur par défaut `"mean"`) : Pooling de l'embedding. `"mean"`, `"max"` et `None` sont pris en charge.

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

prediction_length (`int`, *facultatif*, valeur par défaut : 24) : L'horizon de prédiction que le modèle produira.

num_targets (`int`, *facultatif*, valeur par défaut : 1) : Nombre de cibles pour les tâches de régression et de classification. Pour la classification, il s'agit du nombre de classes.

output_range (`list`, *facultatif*) : Plage de sortie pour la tâche de régression. La plage des valeurs de sortie peut être définie pour forcer le modèle à produire des valeurs dans une plage donnée.

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

Il s’agit de la classe de configuration destinée à stocker la configuration d’un PatchTSTModel. Elle est utilisée pour instancier un modèle Patchtst 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-granite/granite-timeseries-patchtst](https://huggingface.co/ibm-granite/granite-timeseries-patchtst)

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.

```python
>>> from transformers import PatchTSTConfig, PatchTSTModel

>>> # Initializing an PatchTST configuration with 12 time steps for prediction
>>> configuration = PatchTSTConfig(prediction_length=12)

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

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

## PatchTSTModel[[transformers.PatchTSTModel]]

#### transformers.PatchTSTModel[[transformers.PatchTSTModel]]

```python
transformers.PatchTSTModel(config: PatchTSTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1066)

**Paramètres :**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) : 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.

Le modèle Patchtst brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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.PatchTSTModel.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1085)

**Paramètres :**

past_values (`torch.Tensor` de forme `(bs, sequence_length, num_input_channels)`, *obligatoire*) : Séquence d'entrée du modèle

past_observed_mask (`torch.BoolTensor` 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 comprises 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.BoolTensor` de forme `(batch_size, prediction_length, num_input_channels)`, *facultatif*) : Valeurs cibles futures associées aux `past_values`

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches

output_attentions (`bool`, *facultatif*) : Indique s'il faut renvoyer l'attention de sortie de toutes les couches

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un `ModelOutput` plutôt qu'un simple tuple.

**Retourne :**

`PatchTSTModelOutput` ou tuple de `torch.Tensor` (si `return_dict`=False ou `config.return_dict`=False)

Exemples :

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTModel

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = PatchTSTModel.from_pretrained("namctin/patchtst_etth1_pretrain")

>>> # during training, one provides both past and future values
>>> outputs = model(
...     past_values=batch["past_values"],
...     future_values=batch["future_values"],
... )

>>> last_hidden_state = outputs.last_hidden_state
```

## PatchTSTForPrediction[[transformers.PatchTSTForPrediction]]

#### transformers.PatchTSTForPrediction[[transformers.PatchTSTForPrediction]]

```python
transformers.PatchTSTForPrediction(config: PatchTSTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1560)

**Paramètres :**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) : 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.

Le modèle de prédiction PatchTST.

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.PatchTSTForPrediction.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1590)

**Paramètres :**

past_values (`torch.Tensor` de forme `(bs, sequence_length, num_input_channels)`, *obligatoire*) : Séquence d'entrée du modèle

past_observed_mask (`torch.BoolTensor` 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 comprises 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 `(bs, forecast_len, num_input_channels)`, *facultatif*) : Valeurs cibles futures associées aux `past_values`

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches

output_attentions (`bool`, *facultatif*) : Indique s'il faut renvoyer l'attention de sortie de toutes les couches

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un `ModelOutput` plutôt qu'un simple tuple.

**Retourne :**

`PatchTSTForPredictionOutput` ou tuple de `torch.Tensor` (si `return_dict`=False ou `config.return_dict`=False)

Exemples :

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTConfig, PatchTSTForPrediction

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> # Prediction task with 7 input channels and prediction length is 96
>>> model = PatchTSTForPrediction.from_pretrained("namctin/patchtst_etth1_forecast")

>>> # during training, one provides both past and future values
>>> outputs = model(
...     past_values=batch["past_values"],
...     future_values=batch["future_values"],
... )

>>> loss = outputs.loss
>>> loss.backward()

>>> # during inference, one only provides past values, the model outputs future values
>>> outputs = model(past_values=batch["past_values"])
>>> prediction_outputs = outputs.prediction_outputs
```

## PatchTSTForClassification[[transformers.PatchTSTForClassification]]

#### transformers.PatchTSTForClassification[[transformers.PatchTSTForClassification]]

```python
transformers.PatchTSTForClassification(config: PatchTSTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1366)

**Paramètres :**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) : 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.

Le modèle PatchTST pour la classification.

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.PatchTSTForClassification.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1381)

**Paramètres :**

past_values (`torch.Tensor` de forme `(bs, sequence_length, num_input_channels)`, *obligatoire*) : Séquence d'entrée du modèle

target_values (`torch.Tensor`, *facultatif*) : Étiquettes associées aux `past_values`

past_observed_mask (`torch.BoolTensor` 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 comprises 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.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un `PatchTSTForClassificationOutput` 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 ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) et les entrées.

La méthode forward de [PatchTSTForClassification](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTForClassification) 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 `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Perte totale, définie comme la somme de la perte de modélisation de langage masquée et de la perte de prédiction de la séquence suivante (classification).
- **prediction_logits** (`torch.Tensor` de forme `(batch_size, num_targets)`) -- Scores de prédiction de la tête de modélisation PatchTST (scores avant SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

```python
>>> from transformers import PatchTSTConfig, PatchTSTForClassification

>>> # classification task with two input channel2 and 3 classes
>>> config = PatchTSTConfig(
...     num_input_channels=2,
...     num_targets=3,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     use_cls_token=True,
... )
>>> model = PatchTSTForClassification(config=config)

>>> # during inference, one only provides past values
>>> past_values = torch.randn(20, 512, 2)
>>> outputs = model(past_values=past_values)
>>> labels = outputs.prediction_logits
```

## PatchTSTForPretraining[[transformers.PatchTSTForPretraining]]

#### transformers.PatchTSTForPretraining[[transformers.PatchTSTForPretraining]]

```python
transformers.PatchTSTForPretraining(config: PatchTSTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1212)

**Paramètres :**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) : 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.

Le modèle de pré-entraînement PatchTST.

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.PatchTSTForPretraining.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1223)

**Paramètres :**

past_values (`torch.Tensor` de forme `(bs, sequence_length, num_input_channels)`, *obligatoire*) : Séquence d'entrée du modèle

past_observed_mask (`torch.BoolTensor` 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 comprises 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

output_attentions (`bool`, *facultatif*) : Indique s'il faut renvoyer l'attention de sortie de toutes les couches

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un `ModelOutput` plutôt qu'un simple tuple.

**Retourne :**

`PatchTSTForPretrainingOutput` ou tuple de `torch.Tensor` (si `return_dict`=False ou `config.return_dict`=False)

Exemples :

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTConfig, PatchTSTForPretraining

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> # Config for random mask pretraining
>>> config = PatchTSTConfig(
...     num_input_channels=7,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     mask_type='random',
...     random_mask_ratio=0.4,
...     use_cls_token=True,
... )
>>> # Config for forecast mask pretraining
>>> config = PatchTSTConfig(
...     num_input_channels=7,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     mask_type='forecast',
...     num_forecast_mask_patches=5,
...     use_cls_token=True,
... )
>>> model = PatchTSTForPretraining(config)

>>> # during training, one provides both past and future values
>>> outputs = model(past_values=batch["past_values"])

>>> loss = outputs.loss
>>> loss.backward()
```

## PatchTSTForRegression[[transformers.PatchTSTForRegression]]

#### transformers.PatchTSTForRegression[[transformers.PatchTSTForRegression]]

```python
transformers.PatchTSTForRegression(config: PatchTSTConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1809)

**Paramètres :**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) : 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.

Le modèle PatchTST pour la 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.PatchTSTForRegression.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtst/modeling_patchtst.py#L1836)

**Paramètres :**

past_values (`torch.Tensor` de forme `(bs, sequence_length, num_input_channels)`, *obligatoire*) : Séquence d'entrée du modèle

target_values (`torch.Tensor` de forme `(bs, num_input_channels)`) : Valeurs cibles associées aux `past_values`

past_observed_mask (`torch.BoolTensor` 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). Indique s'il faut retourner un `ModelOutput` plutôt qu'un simple tuple.

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.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

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

Un `PatchTSTForRegressionOutput` 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 ([PatchTSTConfig](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTConfig)) et les entrées.

La méthode forward de [PatchTSTForRegression](/docs/transformers/v5.23.0/fr/model_doc/patchtst#transformers.PatchTSTForRegression) 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 `labels` is provided, `torch.Tensor` of shape `(1,)`) -- MSE loss.
- **regression_outputs** (`torch.Tensor` de forme `(batch_size, num_targets)`) -- Sorties de régression des têtes de modélisation de séries temporelles.
- **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

```python
>>> from transformers import PatchTSTConfig, PatchTSTForRegression

>>> # Regression task with 6 input channels and regress 2 targets
>>> model = PatchTSTForRegression.from_pretrained("namctin/patchtst_etth1_regression")

>>> # during inference, one only provides past values, the model outputs future values
>>> past_values = torch.randn(20, 512, 6)
>>> outputs = model(past_values=past_values)
>>> regression_outputs = outputs.regression_outputs
```

