Ce modèle a été publié dans HF papers le 2022-11-27 et ajouté à Hugging Face Transformers le 2023-11-13.

PatchTST

Aperçu

Le modèle PatchTST a été proposé dans A Time Series is Worth 64 Words: Long-term Forecasting with Transformers 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

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, gsinthong, diepi, vijaye12, wmgifford et kashif. Le code d'origine peut être trouvé ici.

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 et PatchTSTForRegression.

Ressources

Un article de blogue expliquant PatchTST en profondeur est disponible ici. Le blog peut également être ouvert dans Google Colab.

PatchTSTConfig

classe transformers.PatchTSTConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_input_channels: int = 1context_length: int = 32distribution_output: str = 'student_t'loss: str | None = 'mse'patch_length: int = 1patch_stride: int = 1num_hidden_layers: int = 3d_model: int = 128num_attention_heads: int = 4share_embedding: bool = Truechannel_attention: bool = Falseffn_dim: int = 512norm_type: str = 'batchnorm'norm_eps: float = 1e-05attention_dropout: float | int = 0.0positional_dropout: float | int = 0.0path_dropout: float | int = 0.0ff_dropout: float | int = 0.0bias: bool = Trueactivation_function: str = 'gelu'pre_norm: bool = Truepositional_encoding_type: str = 'sincos'use_cls_token: bool = Falseinit_std: float = 0.02share_projection: bool = Truescaling: str | bool | None = 'std'do_mask_input: bool | None = Nonemask_type: str = 'random'random_mask_ratio: float = 0.5num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,)channel_consistent_masking: bool | None = Falseunmasked_channel_indices: list[int] | None = Nonemask_value: int = 0pooling_type: str | None = 'mean'head_dropout: float | int = 0.0prediction_length: int = 24num_targets: int = 1output_range: list | None = Nonenum_parallel_samples: int = 100 )

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, 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, 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, de l’erreur quadratique moyenne « mse ».
patch_length (int, facultatif, par défaut 1) — Définit la longueur des patches 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, 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 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, 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 sur les canaux dans le Transformer pour permettre aux canaux de s'attendre mutuellement.
ffn_dim (int, facultatif, par défaut 512) — Dimension de la couche « intermédiaire » (souvent nommé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) — Valeur ajoutée au dénominateur pour 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'encodage positionnel.
path_dropout (float, facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué au chemin résiduel du bloc.
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, par défaut "gelu") — La 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, par défaut "sincos") — Encodages positionnels. Les options "random" et "sincos" sont prises en charge.
use_cls_token (bool, facultatif, 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 d'initialisation des poids normale tronquée.
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, 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 la préformation.
mask_type (str, facultatif, 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 lors de la préformation. 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, par défaut "mean") — Mise en pool des embeddings. "mean", "max" et None sont pris en charge.
head_dropout (float, facultatif, valeur par défaut 0.0) — 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, valeur par défaut 100) — Le nombre d'échantillons générés en parallèle pour la prédiction probabiliste.

Ceci est 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, définissant ainsi 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

>>> 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

classe transformers.PatchTSTModel

< source >

( config: PatchTSTConfig )

Paramètres

config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< source >

( past_values: Tensorpast_observed_mask: typing.Optional[torch.Tensor] = Nonefuture_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs )

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 étaient 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.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 ou non retourner les attentions de sortie de toutes les couches
return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Exemples :

>>> 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

classe transformers.PatchTSTForPrediction

< source >

( config: PatchTSTConfig )

Paramètres

config (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() pour charger les poids du modèle.

Le modèle de prédiction PatchTST.

forward

< source >

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 étaient 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 (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 ou non retourner les attentions de sortie de toutes les couches
return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Exemples :

>>> 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

classe transformers.PatchTSTForClassification

< source >

( config: PatchTSTConfig )

Paramètres

config (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() pour charger les poids du modèle.

Le modèle PatchTST pour la classification.

forward

< source >

( past_values: Tensortarget_values: typing.Optional[torch.Tensor] = Nonepast_observed_mask: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → PatchTSTForClassificationOutput or tuple(torch.Tensor)

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 étaient 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 sous 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. Consultez attentions sous les tenseurs retournés pour plus de détails.
return_dict (bool, facultatif) — Indique s'il faut retourner un 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 en fonction de la configuration (PatchTSTConfig) et des entrées.

La méthode forward de 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).

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

Exemples :

>>> 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

classe transformers.PatchTSTForPretraining

< source >

( config: PatchTSTConfig )

Paramètres

config (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() pour charger les poids du modèle.

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

forward

< source >

( past_values: Tensorpast_observed_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs )

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 étaient 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
output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les attentions de sortie de toutes les couches
return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Exemples :

>>> 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

classe transformers.PatchTSTForRegression

< source >

( config: PatchTSTConfig )

Paramètres

config (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() pour charger les poids du modèle.

Le modèle PatchTST pour la régression.

forward

< source >

( past_values: Tensortarget_values: typing.Optional[torch.Tensor] = Nonepast_observed_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → PatchTSTForRegressionOutput or tuple(torch.Tensor)

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 étaient 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 sous 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. Consultez attentions sous les tenseurs retournés pour plus de détails.
return_dict (bool, facultatif) — Indique s'il faut retourner un 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 en fonction de la configuration (PatchTSTConfig) et des entrées.

La méthode forward de 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).

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

Exemples :

>>> 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

Update on GitHub