Ce modèle a été publié dans HF papers le 2023-06-14 et ajouté à Hugging Face Transformers le 2023-12-05.

PatchTSMixer

Aperçu

Le modèle PatchTSMixer a été proposé dans TSMixer: Lightweight MLP-Mixer Model for Multivariate Time Series Forecasting par Vijay Ekambaram, Arindam Jati, Nam Nguyen, Phanwadee Sinthong et Jayant Kalagnanam.

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

L'abstract de l'article est le suivant :

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

Ce modèle a été contribué par ajati, vijaye12, gsinthong, namctin, wmgifford, kashif.

Exemple d'utilisation

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


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


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

Conseils d'utilisation

Le modèle peut également être utilisé pour la classification de séries temporelles et la régression de séries temporelles. Consultez les classes respectives PatchTSMixerForTimeSeriesClassification et PatchTSMixerForRegression.

Ressources

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

PatchTSMixerConfig

classe transformers.PatchTSMixerConfig

< 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 = Nonecontext_length: int = 32patch_length: int = 8num_input_channels: int = 1patch_stride: int = 8num_parallel_samples: int = 100d_model: int = 8expansion_factor: int = 2num_layers: int = 3dropout: float | int = 0.2mode: str = 'common_channel'gated_attn: bool = Truenorm_mlp: str = 'LayerNorm'self_attn: bool = Falseself_attn_heads: int = 1use_positional_encoding: bool = Falsepositional_encoding_type: str = 'sincos'scaling: str | bool | None = 'std'loss: str = 'mse'init_std: float = 0.02norm_eps: float = 1e-05mask_type: str = 'random'random_mask_ratio: float = 0.5num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,)mask_value: int = 0masked_loss: bool = Truechannel_consistent_masking: bool = Trueunmasked_channel_indices: list[int] | None = Nonehead_dropout: float | int = 0.2distribution_output: str = 'student_t'prediction_length: int = 16prediction_channel_indices: list | None = Nonenum_targets: int = 3output_range: list | None = Nonehead_aggregation: str | None = 'max_pool' )

Paramètres

context_length (int, facultatif, valeur par défaut 32) — La longueur du contexte/historique pour la séquence d'entrée.
patch_length (int, facultatif, par défaut 8) — La longueur des patches pour la séquence d'entrée.
num_input_channels (int, facultatif, par défaut 1) — Le nombre de canaux d'entrée.
patch_stride (int, facultatif, par défaut 8) — Détermine le chevauchement entre deux patches consécutifs. Définissez-le sur patch_length (ou une valeur supérieure) si vous souhaitez des patches non chevauchants.
num_parallel_samples (int, facultatif, valeur par défaut 100) — Le nombre d'échantillons à générer en parallèle pour la prévision probabiliste.
d_model (int, facultatif, par défaut 8) — Taille des couches encodeur et de la couche pooler.
expansion_factor (int, facultatif, valeur par défaut 2) — Facteur d'expansion à utiliser dans le MLP. La plage recommandée est de 2 à 5. Une valeur plus élevée indique un modèle plus complexe.
num_layers (int, facultatif, par défaut 3) — Nombre de couches cachées dans le décodeur Transformer.
dropout (Union[float, int], facultatif, par défaut 0.2) — Le taux appliqué à toutes les couches de dropout.
mode (str, facultatif, par défaut "common_channel") — Mode du mélangeur. Détermine la manière de traiter les canaux. Valeurs autorisées : « common_channel », « mix_channel ». En mode « common_channel », nous suivons un modèle indépendant des canaux, sans mélange explicite des canaux. Le mélange des canaux se produit de manière implicite via des poids partagés entre les canaux. (approche recommandée en premier lieu) En mode « mix_channel », nous suivons un mélange explicite des canaux en plus du mélangeur de patches et de caractéristiques. (approche recommandée lorsque les corrélations entre canaux sont très importantes à modéliser)
gated_attn (bool, facultatif, par défaut True) — Active Gated Attention.
norm_mlp (str, facultatif, par défaut "LayerNorm") — Couche de normalisation (BatchNorm ou LayerNorm).
self_attn (bool, facultatif, par défaut False) — Active l'auto-attention Tiny entre les patches. Cette option peut être activée lorsque la sortie de Vanilla PatchTSMixer avec attention à porte n'est pas satisfaisante. L'activation de cette option conduit à une attention explicite par paires et à un modélisation entre les patches.
self_attn_heads (int, facultatif, par défaut 1) — Nombre de têtes d'auto-attention. Fonctionne uniquement lorsque self_attn est défini sur True.
use_positional_encoding (bool, facultatif, par défaut False) — Active l'utilisation de l'encodage positionnel pour les couches d'auto-attention minuscules. Fonctionne uniquement lorsque self_attn est défini sur True.
positional_encoding_type (str, facultatif, par défaut "sincos") — Encodages positionnels. Les options "random" et "sincos" sont prises en charge. Fonctionne uniquement lorsque use_positional_encoding est défini sur True
scaling (string ou bool, facultatif, par défaut "std") — Indique s'il faut mettre à l'échelle les cibles d'entrée via un scaler « mean », un scaler « std » ou aucun scaler si None. Si True, le scaler est défini sur « mean ».
loss (string, 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 ».
init_std (float, facultatif, valeur par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
norm_eps (float, facultatif, valeur par défaut 1e-05) — Valeur ajoutée au dénominateur pour la stabilité numérique de la normalisation.
mask_type (str, facultatif, par défaut "random") — Type de masquage à utiliser pour le mode Masked Pretraining. Les valeurs autorisées sont « random » et « forecast ». Dans le masquage aléatoire, les points sont masqués de manière aléatoire. Dans le masquage de prévision, les points sont masqués vers la fin.
random_mask_ratio (float, facultatif, valeur par défaut 0.5) — Taux de masquage à utiliser lorsque mask_type est random. Une valeur plus élevée indique un masquage plus important.
num_forecast_mask_patches (int ou list, facultatif, par défaut [2]) — Nombre de patches à masquer à la fin de chaque échantillon du lot. S'il s'agit d'un entier, tous les échantillons du lot auront le même nombre de patches masqués. S'il s'agit d'une liste, les échantillons du lot seront masqués aléatoirement selon les nombres définis dans la liste. Cet argument n'est utilisé que pour le pré-entraînement de prévision.
mask_value (float, facultatif, par défaut 0.0) — Valeur de masque à utiliser.
masked_loss (bool, facultatif, valeur par défaut True) — Indique si la perte de pré-entraînement doit être calculée uniquement sur les portions masquées ou sur l’ensemble de la sortie.
channel_consistent_masking (bool, facultatif, valeur par défaut True) — Si la valeur est true, le masquage sera identique sur tous les canaux d'une série temporelle. Sinon, les positions de masquage varieront d'un canal à l'autre.
unmasked_channel_indices (list, facultatif) — Canaux qui ne sont pas masqués pendant la préformation.
head_dropout (float, facultatif, valeur par défaut 0.2) — Probabilité de dropout de la tête PatchTSMixer.
distribution_output (string, 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 ».
prediction_length (int, facultatif, valeur par défaut 16) — Nombre d’étapes temporelles à prévoir pour une tâche de prévision. Également connu sous le nom d’horizon de prévision.
prediction_channel_indices (list, facultatif) — Liste des indices de canaux à prédire. Si None, tous les canaux sont prédits. Les données cibles sont censées contenir tous les canaux et nous filtrons explicitement les canaux dans la prédiction et la cible avant le calcul de la perte.
num_targets (int, facultatif, valeur par défaut 3) — Nombre de cibles (dimension de la variable régressée) pour une tâche de régression.
output_range (list, facultatif) — Plage de sortie à laquelle restreindre la tâche de régression. Valeur par défaut : None.
head_aggregation (str, facultatif, par défaut "max_pool") — Mode d’agrégation à activer pour une tâche de classification ou de régression. Les valeurs autorisées sont None, “use_last”, “max_pool”, “avg_pool”.

Ceci est la classe de configuration destinée à stocker la configuration d'un PatchTSMixerModel. Elle est utilisée pour instancier un modèle Patchtsmixer en fonction des arguments spécifiés, 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/patchtsmixer-etth1-pretrain

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.

Exemple :

>>> from transformers import PatchTSMixerConfig, PatchTSMixerModel

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

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

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

PatchTSMixerModel

classe transformers.PatchTSMixerModel

< source >

( config: PatchTSMixerConfigmask_input: bool = False )

Paramètres

config (PatchTSMixerConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
mask_input (bool, facultatif, par défaut False) — Indique s'il faut masquer l'entrée à l'aide du module PatchTSMixerMasking.

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

Ce modèle hérite de PreTrainedModel. 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: Tensorobserved_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = None**kwargs ) → PatchTSMixerModelOutput or tuple(torch.Tensor)

Paramètres

past_values (torch.Tensor de forme (batch_size, seq_length, num_input_channels)) — Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée à partir de laquelle prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle.
Pour les séries temporelles univariées, la dimension num_input_channels doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.
observed_mask (torch.Tensor de forme (batch_size, sequence_length, num_input_channels), facultatif) — Masque booléen indiquant quels past_values ont été observés et lesquels é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.

Retourne

PatchTSMixerModelOutput ou tuple(torch.Tensor)

Un PatchTSMixerModelOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PatchTSMixerConfig) et des entrées.

La méthode forward du modèle PatchTSMixerModel redéfinit la méthode spéciale __call__.

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

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

PatchTSMixerForPrediction

classe transformers.PatchTSMixerForPrediction

< source >

( config: PatchTSMixerConfig )

Paramètres

config (PatchTSMixerConfig) — Configuration.

PatchTSMixer pour les applications de prévision.

forward

< source >

( past_values: Tensorobserved_mask: typing.Optional[torch.Tensor] = Nonefuture_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_loss: bool = True**kwargs ) → PatchTSMixerForPredictionOutput or tuple(torch.Tensor)

Paramètres

past_values (torch.Tensor de forme (batch_size, seq_length, num_input_channels)) — Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée à partir de laquelle prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle.
Pour les séries temporelles univariées, la dimension num_input_channels doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.
observed_mask (torch.Tensor de forme (batch_size, sequence_length, num_input_channels), facultatif) — Masque booléen indiquant quels past_values ont été observés et lesquels é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 (batch_size, target_len, num_input_channels) pour la prévision, — (batch_size, num_targets) pour la régression, ou (batch_size,) pour la classification, facultatif): Valeurs cibles de la série temporelle, servant d'étiquettes pour le modèle. Les future_values sont ce que le Transformer doit apprendre à produire pendant l'entraînement, étant donné les past_values. Notez que ce n'est PAS nécessaire pour une tâche de pré-entraînement.
Pour une tâche de prévision, la forme est (batch_size, target_len, num_input_channels). Même si nous voulons ne prédire que des canaux spécifiques en définissant les indices dans le paramètre prediction_channel_indices, il faut transmettre les données cibles avec tous les canaux, car le filtrage des canaux pour la prédiction et la cible sera appliqué manuellement avant le calcul de la perte.
output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
return_loss (bool, facultatif) — Indique s'il faut retourner la perte lors de l'appel forward.

Retourne

PatchTSMixerForPredictionOutput ou tuple(torch.Tensor)

Un PatchTSMixerForPredictionOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PatchTSMixerConfig) et des entrées.

La méthode forward de PatchTSMixerForPrediction redéfinit la méthode spéciale __call__.

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

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

PatchTSMixerForTimeSeriesClassification

classe transformers.PatchTSMixerForTimeSeriesClassification

< source >

( config: PatchTSMixerConfig )

Paramètres

config (PatchTSMixerConfig) — Configuration.

PatchTSMixer pour une application de classification.

forward

< source >

( past_values: Tensortarget_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_loss: bool = True**kwargs ) → PatchTSMixerForTimeSeriesClassificationOutput or tuple(torch.Tensor)

Paramètres

past_values (torch.Tensor de forme (batch_size, seq_length, num_input_channels)) — Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée à partir de laquelle prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle.
Pour les séries temporelles univariées, la dimension num_input_channels doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.
target_values (torch.Tensor de forme (batch_size, target_len, num_input_channels) pour la prévision, — (batch_size, num_targets) pour la régression, ou (batch_size,) pour la classification, facultatif): Valeurs cibles de la série temporelle, qui servent d'étiquettes pour le modèle. Les target_values sont ce que le past_values. Notez que ce n'est PAS requis pour une tâche de pré-entraînement.
Pour une tâche de prévision, la forme est (batch_size, target_len, num_input_channels). Même si nous voulons ne prédire que des canaux spécifiques en définissant les indices dans le paramètre prediction_channel_indices, il faut transmettre les données cibles avec tous les canaux, car le filtrage des canaux pour la prédiction et la cible sera appliqué manuellement avant le calcul de la perte.

Pour une tâche de classification, elle a une forme de (batch_size,).

Pour une tâche de régression, elle a une forme de (batch_size, num_targets).
output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
return_loss (bool, facultatif) — Indique s'il faut retourner la perte lors de l'appel forward.

Retourne

PatchTSMixerForTimeSeriesClassificationOutput ou tuple(torch.Tensor)

Un PatchTSMixerForTimeSeriesClassificationOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PatchTSMixerConfig) et des entrées.

La méthode forward de PatchTSMixerForTimeSeriesClassification redéfinit la méthode spéciale __call__.

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

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

PatchTSMixerForPretraining

classe transformers.PatchTSMixerForPretraining

< source >

( config: PatchTSMixerConfig )

Paramètres

config (PatchTSMixerConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

PatchTSMixer pour la préformation par masquage.

forward

< source >

( past_values: Tensorobserved_mask: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_loss: bool = True**kwargs ) → PatchTSMixerForPreTrainingOutput or tuple(torch.Tensor)

Paramètres

past_values (torch.Tensor de forme (batch_size, seq_length, num_input_channels)) — Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée à partir de laquelle prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle.
Pour les séries temporelles univariées, la dimension num_input_channels doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.
observed_mask (torch.Tensor de forme (batch_size, sequence_length, num_input_channels), facultatif) — Masque booléen indiquant quels past_values ont été observés et lesquels é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.
return_loss (bool, facultatif) — Indique s'il faut retourner la perte lors de l'appel forward.

Retourne

PatchTSMixerForPreTrainingOutput ou tuple(torch.Tensor)

Un PatchTSMixerForPreTrainingOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PatchTSMixerConfig) et des entrées.

La méthode forward de PatchTSMixerForPretraining redéfinit la méthode spéciale __call__.

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

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

PatchTSMixerForRegression

classe transformers.PatchTSMixerForRegression

< source >

( config: PatchTSMixerConfig )

Paramètres

config (PatchTSMixerConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

PatchTSMixer pour une application de régression.

forward

< source >

( past_values: Tensortarget_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_loss: bool = True**kwargs ) → PatchTSMixerForRegressionOutput or tuple(torch.Tensor)

Paramètres

past_values (torch.Tensor de forme (batch_size, seq_length, num_input_channels)) — Valeurs de contexte de la série temporelle. Pour une tâche de pré-entraînement, cela désigne la série temporelle d'entrée à partir de laquelle prédire la portion masquée. Pour une tâche de prévision, cela désigne les valeurs historiques/passées de la série temporelle. De même, pour les tâches de classification ou de régression, cela désigne les valeurs de contexte appropriées de la série temporelle.
Pour les séries temporelles univariées, la dimension num_input_channels doit être 1. Pour les séries temporelles multivariées, elle est supérieure à 1.
target_values (torch.Tensor de forme (batch_size, target_len, num_input_channels) pour la prévision, — (batch_size, num_targets) pour la régression, ou (batch_size,) pour la classification, facultatif): Valeurs cibles de la série temporelle, servant d'étiquettes pour le modèle. Les target_values sont ce que le Transformer doit apprendre à produire pendant l'entraînement, étant donné les past_values. Notez que ce n'est PAS nécessaire pour une tâche de pré-entraînement.
Pour une tâche de prévision, la forme est (batch_size, target_len, num_input_channels). Même si nous voulons ne prédire que des canaux spécifiques en définissant les indices dans le paramètre prediction_channel_indices, il faut transmettre les données cibles avec tous les canaux, car le filtrage des canaux pour la prédiction et la cible sera appliqué manuellement avant le calcul de la perte.

Pour une tâche de classification, elle a une forme de (batch_size,).

Pour une tâche de régression, elle a une forme de (batch_size, num_targets).
output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
return_loss (bool, facultatif) — Indique s'il faut retourner la perte lors de l'appel forward.

Retourne

PatchTSMixerForRegressionOutput ou tuple(torch.Tensor)

Un PatchTSMixerForRegressionOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (PatchTSMixerConfig) et des entrées.

La méthode forward de PatchTSMixerForRegression redéfinit la méthode spéciale __call__.

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

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

Update on GitHub