# Time Series Transformer

## Aperçu

Le modèle Time Series Transformer est un Transformer encodeur-décodeur standard pour la prévision de séries temporelles. Ce modèle a été contribué par [kashif](https://huggingface.co/kashif).

## Conseils d'utilisation

- Comme pour les autres modèles de la bibliothèque, [TimeSeriesTransformerModel](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerModel) est le Transformer brut, sans aucune tête au sommet, et [TimeSeriesTransformerForPrediction](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerForPrediction)
ajoute une tête de distribution au-dessus de la précédente, qui peut être utilisée pour la prévision de séries temporelles. Notez qu'il s'agit d'un modèle de prévision probabiliste, et non d'un modèle de prévision ponctuelle. Cela signifie que le modèle apprend une distribution, à partir de laquelle on peut effectuer des tirages. Le modèle ne produit pas directement des valeurs.
- [TimeSeriesTransformerForPrediction](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerForPrediction) est composé de deux blocs : un encodeur, qui prend en entrée une série temporelle de `context_length` valeurs (appelées `past_values`),
et un décodeur, qui prédit une `prediction_length` de valeurs de séries temporelles dans le futur (appelées `future_values`). Lors de l’entraînement, il faut fournir au modèle des paires de (`past_values` et `future_values`).
- En plus des valeurs brutes (`past_values` et `future_values`), on fournit généralement des caractéristiques supplémentaires au modèle. Il peut s’agir des éléments suivants :
  - `past_time_features` : caractéristiques temporelles que le modèle ajoutera à `past_values`. Elles servent de « codages positionnels » pour l’encodeur Transformer. Il peut s’agir, par exemple, du « jour du mois », du « mois de l’année », etc., sous forme de valeurs scalaires (puis empilées en un vecteur). Par exemple, si une valeur de la série temporelle a été obtenue le 11 août, le vecteur de caractéristiques temporelles pourrait être [11, 8] (11 représentant le « jour du mois » et 8 le « mois de l’année »).
  - `future_time_features` : caractéristiques temporelles que le modèle ajoutera à `future_values`. Elles servent d'« encodages positionnels » pour le décodeur Transformer. Des exemples sont « jour du mois », « mois de l'année », etc., sous forme de valeurs scalaires (puis empilées en un vecteur). Par exemple, si une valeur de série temporelle a été obtenue le 11 août, on peut avoir [11, 8] comme vecteur de caractéristiques temporelles (11 étant le « jour du mois » et 8 le « mois de l'année »).
  - `static_categorical_features` : variables catégorielles qui sont statiques dans le temps (c'est-à-dire qui ont la même valeur pour toutes les `past_values` et les `future_values`). Un exemple est l'identifiant de magasin ou l'identifiant de région qui identifie une série temporelle donnée. Notez que ces variables doivent être connues pour TOUS les points de données (y compris ceux dans le futur).
  - `static_real_features` : des caractéristiques à valeurs réelles qui sont statiques dans le temps (c'est-à-dire qui ont la même valeur pour toutes les `past_values` et les `future_values`). Un exemple est la représentation d'image du produit pour lequel vous avez les valeurs de la série temporelle (comme l'embedding [ResNet](resnet) d'une photo de "chaussure", si votre série temporelle concerne les ventes de chaussures). Notez que ces caractéristiques doivent être connues pour TOUS les points de données (y compris ceux dans le futur).
- Le modèle est entraîné à l'aide du « teacher-forcing », de manière similaire à l'entraînement d'un Transformer pour la traduction automatique. Cela signifie que, pendant l'entraînement, on décale
`future_values` d’une position vers la droite en entrée du décodeur, précédées de la dernière valeur de `past_values`. À chaque pas de temps, le modèle doit prédire la cible suivante. La configuration de l’entraînement est donc similaire à celle d’un modèle GPT pour le langage, à l’exception de l’absence de notion de `decoder_start_token_id` (on utilise simplement la dernière valeur du contexte comme entrée initiale du décodeur).
- Lors de l'inférence, nous fournissons la valeur finale de `past_values` en entrée du décodeur. Ensuite, nous pouvons échantillonner à partir du modèle pour effectuer une prédiction à l'étape temporelle suivante,
qui est ensuite transmis au décodeur afin de produire la prédiction suivante (également appelée génération autorégressive).

## Ressources

Une liste de ressources officielles de Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer. Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.

- Découvrez l’article de blog Time Series Transformer sur le blog HuggingFace : [Probabilistic Time Series Forecasting with 🤗 Transformers](https://huggingface.co/blog/time-series-transformers)

## TimeSeriesTransformerConfig[[transformers.TimeSeriesTransformerConfig]]

#### transformers.TimeSeriesTransformerConfig[[transformers.TimeSeriesTransformerConfig]]

```python
transformers.TimeSeriesTransformerConfig(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, 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, is_encoder_decoder: bool = True, prediction_length: int | None = None, context_length: int | None = None, distribution_output: str = 'student_t', loss: str = 'nll', input_size: int = 1, lags_sequence: list[int] | tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7), scaling: str | bool | None = 'mean', num_dynamic_real_features: int = 0, num_static_categorical_features: int = 0, num_static_real_features: int = 0, num_time_features: int = 0, cardinality: list[int] | None = None, embedding_dimension: list[int] | None = None, encoder_ffn_dim: int = 32, decoder_ffn_dim: int = 32, encoder_attention_heads: int = 2, decoder_attention_heads: int = 2, encoder_layers: int = 2, decoder_layers: int = 2, activation_function: str = 'gelu', d_model: int = 64, dropout: float | int = 0.1, encoder_layerdrop: float | int = 0.1, decoder_layerdrop: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, num_parallel_samples: int = 100, init_std: float = 0.02, use_cache: bool = True)
```

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

**Paramètres :**

is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non.

prediction_length (`int`, *facultatif*) : La longueur de prédiction pour le décodeur. Autrement dit, l'horizon de prédiction du modèle. Cette valeur est généralement dictée par le jeu de données et nous recommandons de la définir en conséquence.

context_length (`int`, *facultatif*, par défaut `prediction_length`) : La longueur de contexte pour l'encodeur. Si `None`, la longueur de contexte sera identique à `prediction_length`.

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

loss (`string`, *facultatif*, par défaut `"nll"`) : 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) - qui est actuellement la seule prise en charge.

input_size (`int`, *facultatif*, valeur par défaut : 1) : La taille de la variable cible, qui est de 1 par défaut pour les cibles univariées. Elle est supérieure à 1 dans le cas de cibles multivariées.

lags_sequence (`list[int]`, *facultatif*, par défaut `[1, 2, 3, 4, 5, 6, 7]`) : Les retards de la série temporelle d'entrée en tant que covariables, souvent dictés par la fréquence des données. La valeur par défaut est `[1, 2, 3, 4, 5, 6, 7]`, mais nous recommandons de la modifier en fonction du jeu de données.

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

num_dynamic_real_features (`int`, *facultatif*, valeur par défaut 0) : Le nombre de caractéristiques dynamiques à valeurs réelles.

num_static_categorical_features (`int`, *facultatif*, valeur par défaut 0) : Le nombre de caractéristiques catégorielles statiques.

num_static_real_features (`int`, *facultatif*, valeur par défaut 0) : Le nombre de caractéristiques réelles statiques.

num_time_features (`int`, *facultatif*, valeur par défaut 0) : Le nombre de caractéristiques temporelles dans la série temporelle d'entrée.

cardinality (`list[int]`, *facultatif*) : La cardinalité (nombre de valeurs distinctes) pour chacune des caractéristiques catégorielles statiques. Doit être une liste d'entiers, de même longueur que `num_static_categorical_features`. Ne peut pas être `None` si `num_static_categorical_features` est > 0.

embedding_dimension (`list[int]`, *facultatif*) : Dimension des embeddings et des états cachés.

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

decoder_ffn_dim (`int`, *facultatif*, valeur par défaut `32`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.

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

decoder_attention_heads (`int`, *facultatif*, valeur par défaut `2`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

encoder_layers (`int`, *facultatif*, valeur par défaut `2`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

decoder_layers (`int`, *facultatif*, valeur par défaut `2`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

activation_function (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

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

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

encoder_layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Probabilité de LayerDrop pour l'encodeur. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails.

decoder_layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de LayerDrop pour le décodeur. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails.

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

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

num_parallel_samples (`int`, *facultatif*, valeur par défaut : 100) : Le nombre d'échantillons à générer en parallèle pour chaque pas de temps de l'inférence.

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.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

Ceci est la classe de configuration destinée à stocker la configuration d'un TimeSeriesTransformerModel. Elle est utilisée pour instancier un modèle Time Series Transformer selon les 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 [huggingface/time-series-transformer-tourism-monthly](https://huggingface.co/huggingface/time-series-transformer-tourism-monthly)

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 TimeSeriesTransformerConfig, TimeSeriesTransformerModel

>>> # Initializing a Time Series Transformer configuration with 12 time steps for prediction
>>> configuration = TimeSeriesTransformerConfig(prediction_length=12)

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

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

## TimeSeriesTransformerModel[[transformers.TimeSeriesTransformerModel]]

#### transformers.TimeSeriesTransformerModel[[transformers.TimeSeriesTransformerModel]]

```python
transformers.TimeSeriesTransformerModel(config: TimeSeriesTransformerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/time_series_transformer/modeling_time_series_transformer.py#L782)

**Paramètres :**

config ([TimeSeriesTransformerConfig](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerConfig)) : 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 Time Series Transformer 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.TimeSeriesTransformerModel.forward]]

```python
forward(past_values: Tensor, past_time_features: Tensor, past_observed_mask: Tensor, static_categorical_features: typing.Optional[torch.Tensor] = None, static_real_features: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, future_time_features: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/time_series_transformer/modeling_time_series_transformer.py#L920)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, sequence_length)` ou `(batch_size, sequence_length, input_size)`) : Valeurs passées de la série temporelle, servant de contexte afin de prédire l’avenir. La taille de séquence de ce tenseur doit être supérieure à la `context_length` du modèle, car le modèle utilise la taille plus grande pour construire des caractéristiques de retard, c’est-à-dire des valeurs supplémentaires du passé qui sont ajoutées afin de servir de « contexte supplémentaire ». La `sequence_length` ici est égale à `config.context_length` + `max(config.lags_sequence)`, ce qui, si aucune `lags_sequence` n’est configurée, est égal à `config.context_length` + 7 (car par défaut, l’indice de retour en arrière le plus grand dans `config.lags_sequence` est 7). La propriété `_past_length` renvoie la longueur réelle du passé. Le `past_values` est ce que l’encodeur Transformer reçoit en entrée (avec des caractéristiques supplémentaires facultatives, telles que `static_categorical_features`, `static_real_features`, `past_time_features` et les retards). Facultativement, les valeurs manquantes doivent être remplacées par des zéros et indiquées via le `past_observed_mask`. Pour les séries temporelles multivariées, la dimension `input_size` > 1 est requise et correspond au nombre de variables dans la série temporelle par pas de temps.

past_time_features (`torch.Tensor` de forme `(batch_size, sequence_length, num_features)`) : Fonctionnalités temporelles requises, que le modèle ajoutera en interne à `past_values`. Il peut s’agir d’éléments tels que le « mois de l’année », le « jour du mois », etc., encodés sous forme de vecteurs (par exemple en tant que caractéristiques de Fourier). Il peut également s’agir de ce que l’on appelle des fonctionnalités « d’âge », qui aident essentiellement le modèle à savoir « à quel stade de sa vie » se trouve une série temporelle. Les fonctionnalités d’âge ont des valeurs faibles pour les pas de temps éloignés dans le passé et augmentent de manière monotone à mesure que l’on approche du pas de temps actuel. Les fonctionnalités de jours fériés sont également un bon exemple de fonctionnalités temporelles. Ces fonctionnalités servent d’« encodages positionnels » pour les entrées. Contrairement à un modèle comme BERT, où les encodages de position sont appris de zéro en interne en tant que paramètres du modèle, le Time Series Transformer nécessite de fournir des fonctionnalités temporelles supplémentaires. Le Time Series Transformer n’apprend des plongements supplémentaires que pour `static_categorical_features`. Des covariables dynamiques réelles supplémentaires peuvent être concaténées à ce tenseur, sous réserve que ces fonctionnalités soient connues au moment de la prédiction. Le `num_features` ici est égal à `config.`num_time_features` + `config.num_dynamic_real_features`.

past_observed_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)` ou `(batch_size, sequence_length, input_size)`, *facultatif*) : masque booléen indiquant quels `past_values` ont été observés et lesquels étaient 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).

static_categorical_features (`torch.LongTensor` de forme `(batch_size, number of static categorical features)`, *facultatif*) : Caractéristiques catégorielles statiques facultatives pour lesquelles le modèle apprendra un embedding, qu'il ajoutera aux valeurs de la série temporelle. Les caractéristiques catégorielles statiques sont des caractéristiques qui ont la même valeur pour toutes les étapes temporelles (statiques dans le temps). Un exemple typique de caractéristique catégorielle statique est un identifiant de série temporelle.

static_real_features (`torch.Tensor` de forme `(batch_size, number of static real features)`, *facultatif*) : Caractéristiques statiques réelles facultatives que le modèle ajoutera aux valeurs de la série temporelle. Les caractéristiques statiques réelles sont des caractéristiques qui ont la même valeur pour toutes les étapes temporelles (statiques dans le temps). Un exemple typique de caractéristique statique réelle est l'information de promotion.

future_values (`torch.Tensor` de forme `(batch_size, prediction_length)` ou `(batch_size, prediction_length, input_size)`, *facultatif*) : Valeurs futures de la série temporelle, servant d'étiquettes pour le modèle. `future_values` est ce dont le Transformer a besoin pendant l'entraînement pour apprendre à produire une sortie, étant donné `past_values`. La longueur de la séquence ici est égale à `prediction_length`. Consultez le notebook de démonstration et les extraits de code pour plus de détails. Facultativement, pendant l'entraînement, toute valeur manquante doit être remplacée par zéro et indiquée via `future_observed_mask`. Pour les séries temporelles multivariées, la dimension `input_size` > 1 est requise et correspond au nombre de variables de la série temporelle par pas de temps.

future_time_features (`torch.Tensor` de forme `(batch_size, prediction_length, num_features)`) : Fonctionnalités temporelles requises pour la fenêtre de prédiction, que le modèle ajoutera en interne à `future_values`. Il peut s’agir d’éléments tels que « mois de l’année », « jour du mois », etc., encodés sous forme de vecteurs (par exemple en tant que caractéristiques de Fourier). Il peut également s’agir de ce que l’on appelle des fonctionnalités « d’âge », qui aident essentiellement le modèle à savoir « à quel stade de sa vie » se trouve une série temporelle. Les fonctionnalités d’âge ont des valeurs faibles pour les pas de temps éloignés dans le passé et augmentent de manière monotone à mesure que l’on approche du pas de temps actuel. Les fonctionnalités de jours fériés sont également un bon exemple de fonctionnalités temporelles. Ces fonctionnalités servent d’« encodages positionnels » pour les entrées. Contrairement à un modèle comme BERT, où les encodages de position sont appris de zéro en interne en tant que paramètres du modèle, le Time Series Transformer nécessite de fournir des fonctionnalités temporelles supplémentaires. Le Time Series Transformer n’apprend des plongements supplémentaires que pour `static_categorical_features`. Des covariables dynamiques réelles supplémentaires peuvent être concaténées à ce tenseur, sous réserve que ces fonctionnalités soient connues au moment de la prédiction. Le `num_features` ici est égal à `config.`num_time_features` + `config.num_dynamic_real_features`.

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention à certains indices de jetons. Par défaut, un masque causal est utilisé afin de s'assurer que le modèle ne peut consulter que les entrées précédentes pour prédire le futur.

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optionnel*) : Le Tuple est composé de `last_hidden_state`, `hidden_states` (*optionnel*) et `attentions` (*optionnel*) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)` (*optionnel*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [Seq2SeqTSModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) ou `tuple(torch.Tensor)`

Un [Seq2SeqTSModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) 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 ([TimeSeriesTransformerConfig](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerConfig)) et les entrées.

La méthode forward du modèle [TimeSeriesTransformerModel](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerModel) 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, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **decoder_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 décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.
- **decoder_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)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.
- **encoder_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)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **loc** (`torch.Tensor` de forme `(batch_size,)` ou `(batch_size, input_size)`, *facultatif*) -- Décale les valeurs de la fenêtre de contexte de chaque série temporelle, ce qui permet de fournir au modèle des entrées de même ampleur, puis de les ramener à l'ampleur d'origine.
- **scale** (`torch.Tensor` de forme `(batch_size,)` ou `(batch_size, input_size)`, *facultatif*) -- Valeurs d'échelle de la fenêtre de contexte de chaque série temporelle, utilisées pour fournir au modèle des entrées de même magnitude, puis pour rétablir la magnitude d'origine.
- **static_features** (`torch.Tensor` de forme `(batch_size, feature size)`, *facultatif*) -- Caractéristiques statiques de chaque série temporelle d'un lot, copiées dans les covariables lors de l'inférence.

Exemples :

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

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

>>> model = TimeSeriesTransformerModel.from_pretrained("huggingface/time-series-transformer-tourism-monthly")

>>> # during training, one provides both past and future values
>>> # as well as possible additional features
>>> outputs = model(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_values=batch["future_values"],
...     future_time_features=batch["future_time_features"],
... )

>>> last_hidden_state = outputs.last_hidden_state
```

## TimeSeriesTransformerForPrediction[[transformers.TimeSeriesTransformerForPrediction]]

#### transformers.TimeSeriesTransformerForPrediction[[transformers.TimeSeriesTransformerForPrediction]]

```python
transformers.TimeSeriesTransformerForPrediction(config: TimeSeriesTransformerConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/time_series_transformer/modeling_time_series_transformer.py#L1114)

**Paramètres :**

config ([TimeSeriesTransformerConfig](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerConfig)) : 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 Time Series Transformer avec une tête de distribution en tête 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.TimeSeriesTransformerForPrediction.forward]]

```python
forward(past_values: Tensor, past_time_features: Tensor, past_observed_mask: Tensor, static_categorical_features: typing.Optional[torch.Tensor] = None, static_real_features: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, future_time_features: typing.Optional[torch.Tensor] = None, future_observed_mask: typing.Optional[torch.Tensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/time_series_transformer/modeling_time_series_transformer.py#L1148)

**Paramètres :**

past_values (`torch.Tensor` de forme `(batch_size, sequence_length)` ou `(batch_size, sequence_length, input_size)`) : Valeurs passées de la série temporelle, servant de contexte afin de prédire l’avenir. La taille de séquence de ce tenseur doit être supérieure à la `context_length` du modèle, car le modèle utilise la taille plus grande pour construire des caractéristiques de retard, c’est-à-dire des valeurs supplémentaires du passé qui sont ajoutées afin de servir de « contexte supplémentaire ». La `sequence_length` ici est égale à `config.context_length` + `max(config.lags_sequence)`, ce qui, si aucune `lags_sequence` n’est configurée, est égal à `config.context_length` + 7 (car par défaut, l’indice de retour en arrière le plus grand dans `config.lags_sequence` est 7). La propriété `_past_length` renvoie la longueur réelle du passé. Le `past_values` est ce que l’encodeur Transformer reçoit en entrée (avec des caractéristiques supplémentaires facultatives, telles que `static_categorical_features`, `static_real_features`, `past_time_features` et les retards). Facultativement, les valeurs manquantes doivent être remplacées par des zéros et indiquées via le `past_observed_mask`. Pour les séries temporelles multivariées, la dimension `input_size` > 1 est requise et correspond au nombre de variables dans la série temporelle par pas de temps.

past_time_features (`torch.Tensor` de forme `(batch_size, sequence_length, num_features)`) : Fonctionnalités temporelles requises, que le modèle ajoutera en interne à `past_values`. Il peut s’agir d’éléments tels que le « mois de l’année », le « jour du mois », etc., encodés sous forme de vecteurs (par exemple en tant que caractéristiques de Fourier). Il peut également s’agir de ce que l’on appelle des fonctionnalités « d’âge », qui aident essentiellement le modèle à savoir « à quel stade de sa vie » se trouve une série temporelle. Les fonctionnalités d’âge ont des valeurs faibles pour les pas de temps éloignés dans le passé et augmentent de manière monotone à mesure que l’on approche du pas de temps actuel. Les fonctionnalités de jours fériés sont également un bon exemple de fonctionnalités temporelles. Ces fonctionnalités servent d’« encodages positionnels » pour les entrées. Contrairement à un modèle comme BERT, où les encodages de position sont appris de zéro en interne en tant que paramètres du modèle, le Time Series Transformer nécessite de fournir des fonctionnalités temporelles supplémentaires. Le Time Series Transformer n’apprend des plongements supplémentaires que pour `static_categorical_features`. Des covariables dynamiques réelles supplémentaires peuvent être concaténées à ce tenseur, sous réserve que ces fonctionnalités soient connues au moment de la prédiction. Le `num_features` ici est égal à `config.`num_time_features` + `config.num_dynamic_real_features`.

past_observed_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)` ou `(batch_size, sequence_length, input_size)`, *facultatif*) : masque booléen indiquant quels `past_values` ont été observés et lesquels étaient 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).

static_categorical_features (`torch.LongTensor` de forme `(batch_size, number of static categorical features)`, *facultatif*) : Caractéristiques catégorielles statiques facultatives pour lesquelles le modèle apprendra un embedding, qu'il ajoutera aux valeurs de la série temporelle. Les caractéristiques catégorielles statiques sont des caractéristiques qui ont la même valeur pour toutes les étapes temporelles (statiques dans le temps). Un exemple typique de caractéristique catégorielle statique est un identifiant de série temporelle.

static_real_features (`torch.Tensor` de forme `(batch_size, number of static real features)`, *facultatif*) : Caractéristiques statiques réelles facultatives que le modèle ajoutera aux valeurs de la série temporelle. Les caractéristiques statiques réelles sont des caractéristiques qui ont la même valeur pour toutes les étapes temporelles (statiques dans le temps). Un exemple typique de caractéristique statique réelle est l'information de promotion.

future_values (`torch.Tensor` de forme `(batch_size, prediction_length)` ou `(batch_size, prediction_length, input_size)`, *facultatif*) : Valeurs futures de la série temporelle, servant d'étiquettes pour le modèle. `future_values` est ce dont le Transformer a besoin pendant l'entraînement pour apprendre à produire une sortie, étant donné `past_values`. La longueur de la séquence ici est égale à `prediction_length`. Consultez le notebook de démonstration et les extraits de code pour plus de détails. Facultativement, pendant l'entraînement, toute valeur manquante doit être remplacée par zéro et indiquée via `future_observed_mask`. Pour les séries temporelles multivariées, la dimension `input_size` > 1 est requise et correspond au nombre de variables de la série temporelle par pas de temps.

future_time_features (`torch.Tensor` de forme `(batch_size, prediction_length, num_features)`) : Fonctionnalités temporelles requises pour la fenêtre de prédiction, que le modèle ajoutera en interne à `future_values`. Il peut s’agir d’éléments tels que « mois de l’année », « jour du mois », etc., encodés sous forme de vecteurs (par exemple en tant que caractéristiques de Fourier). Il peut également s’agir de ce que l’on appelle des fonctionnalités « d’âge », qui aident essentiellement le modèle à savoir « à quel stade de sa vie » se trouve une série temporelle. Les fonctionnalités d’âge ont des valeurs faibles pour les pas de temps éloignés dans le passé et augmentent de manière monotone à mesure que l’on approche du pas de temps actuel. Les fonctionnalités de jours fériés sont également un bon exemple de fonctionnalités temporelles. Ces fonctionnalités servent d’« encodages positionnels » pour les entrées. Contrairement à un modèle comme BERT, où les encodages de position sont appris de zéro en interne en tant que paramètres du modèle, le Time Series Transformer nécessite de fournir des fonctionnalités temporelles supplémentaires. Le Time Series Transformer n’apprend des plongements supplémentaires que pour `static_categorical_features`. Des covariables dynamiques réelles supplémentaires peuvent être concaténées à ce tenseur, sous réserve que ces fonctionnalités soient connues au moment de la prédiction. Le `num_features` ici est égal à `config.`num_time_features` + `config.num_dynamic_real_features`.

future_observed_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)` ou `(batch_size, sequence_length, input_size)`, *facultatif*) : masque booléen indiquant quels `future_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'est-à-dire les NaN remplacés par des zéros). Ce masque est utilisé pour exclure les valeurs manquantes lors du calcul de la perte finale.

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention à certains indices de jetons. Par défaut, un masque causal est utilisé afin de s'assurer que le modèle ne peut consulter que les entrées précédentes pour prédire le futur.

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optionnel*) : Le Tuple est composé de `last_hidden_state`, `hidden_states` (*optionnel*) et `attentions` (*optionnel*) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)` (*optionnel*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [Seq2SeqTSModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) ou `tuple(torch.Tensor)`

Un [Seq2SeqTSModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) 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 ([TimeSeriesTransformerConfig](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerConfig)) et les entrées.

La méthode forward de [TimeSeriesTransformerForPrediction](/docs/transformers/v5.23.0/fr/model_doc/time_series_transformer#transformers.TimeSeriesTransformerForPrediction) 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, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **decoder_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 décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.
- **decoder_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)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.
- **encoder_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)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **loc** (`torch.Tensor` de forme `(batch_size,)` ou `(batch_size, input_size)`, *facultatif*) -- Décale les valeurs de la fenêtre de contexte de chaque série temporelle, ce qui permet de fournir au modèle des entrées de même ampleur, puis de les ramener à l'ampleur d'origine.
- **scale** (`torch.Tensor` de forme `(batch_size,)` ou `(batch_size, input_size)`, *facultatif*) -- Valeurs d'échelle de la fenêtre de contexte de chaque série temporelle, utilisées pour fournir au modèle des entrées de même magnitude, puis pour rétablir la magnitude d'origine.
- **static_features** (`torch.Tensor` de forme `(batch_size, feature size)`, *facultatif*) -- Caractéristiques statiques de chaque série temporelle d'un lot, copiées dans les covariables lors de l'inférence.

Exemples :

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

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

>>> model = TimeSeriesTransformerForPrediction.from_pretrained(
...     "huggingface/time-series-transformer-tourism-monthly"
... )

>>> # during training, one provides both past and future values
>>> # as well as possible additional features
>>> outputs = model(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_values=batch["future_values"],
...     future_time_features=batch["future_time_features"],
... )

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

>>> # during inference, one only provides past values
>>> # as well as possible additional features
>>> # the model autoregressively generates future values
>>> outputs = model.generate(
...     past_values=batch["past_values"],
...     past_time_features=batch["past_time_features"],
...     past_observed_mask=batch["past_observed_mask"],
...     static_categorical_features=batch["static_categorical_features"],
...     static_real_features=batch["static_real_features"],
...     future_time_features=batch["future_time_features"],
... )

>>> mean_prediction = outputs.sequences.mean(dim=1)
```

