# PatchTST

## Resumen

El modelo PatchTST fue propuesto en [A Time Series is Worth 64 Words: Long-term Forecasting with Transformers](https://huggingface.co/papers/2211.14730) por Yuqi Nie, Nam H. Nguyen, Phanwadee Sinthong y Jayant Kalagnanam.

A alto nivel, el modelo vectoriza las series temporales en parches de un tamaño dado y codifica la secuencia resultante de vectores mediante un Transformer, que luego genera la predicción de la longitud especificada a través de una cabeza adecuada. El modelo se ilustra en la siguiente figura:

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

El resumen del artículo es el siguiente:

*Proponemos un diseño eficiente de modelos basados en Transformer para la predicción de series temporales multivariadas y el aprendizaje de representaciones auto-supervisadas. Se basa en dos componentes clave: (i) la segmentación de las series temporales en parches a nivel de subseries que se sirven como tokens de entrada al Transformer; (ii) la independencia de canal, donde cada canal contiene una única serie temporal univariada que comparte la misma incrustación y los mismos pesos del Transformer en todas las series. El diseño de parches tiene naturalmente un triple beneficio: se conserva la información semántica local en la incrustación; el uso de cómputo y memoria de los mapas de atención se reduce cuadráticamente dado el mismo ventana de retroceso; y el modelo puede atender a un historial más largo. Nuestro Transformer de series temporales por parches con independencia de canal (PatchTST) puede mejorar significativamente la precisión de la predicción a largo plazo en comparación con la de los modelos basados en Transformer del estado del arte. También aplicamos nuestro modelo a tareas de pre-entrenamiento auto-supervisado y obtenemos un excelente rendimiento de ajuste fino, que supera al entrenamiento supervisado en grandes conjuntos de datos. La transferencia de representaciones pre-entrenadas con enmascarado de un conjunto de datos a otros también produce una precisión de predicción del estado del arte.*

Este modelo fue aportado por [namctin](https://huggingface.co/namctin), [gsinthong](https://huggingface.co/gsinthong), [diepi](https://huggingface.co/diepi), [vijaye12](https://huggingface.co/vijaye12), [wmgifford](https://huggingface.co/wmgifford) y [kashif](https://huggingface.co/kashif). El código original se puede encontrar [aquí](https://github.com/yuqinie98/PatchTST).

## Consejos de uso

El modelo también puede utilizarse para la clasificación de series temporales y la regresión de series temporales. Consulte las clases [PatchTSTForClassification](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTForClassification) y [PatchTSTForRegression](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTForRegression) correspondientes.

## Recursos

- Se puede encontrar un artículo de blog que explica PatchTST a fondo [aquí](https://huggingface.co/blog/patchtst). El blog también se puede abrir en Google Colab.

## PatchTSTConfig[[transformers.PatchTSTConfig]]

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

```python
transformers.PatchTSTConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_input_channels: int = 1, context_length: int = 32, distribution_output: str = 'student_t', loss: str | None = 'mse', patch_length: int = 1, patch_stride: int = 1, num_hidden_layers: int = 3, d_model: int = 128, num_attention_heads: int = 4, share_embedding: bool = True, channel_attention: bool = False, ffn_dim: int = 512, norm_type: str = 'batchnorm', norm_eps: float = 1e-05, attention_dropout: float | int = 0.0, positional_dropout: float | int = 0.0, path_dropout: float | int = 0.0, ff_dropout: float | int = 0.0, bias: bool = True, activation_function: str = 'gelu', pre_norm: bool = True, positional_encoding_type: str = 'sincos', use_cls_token: bool = False, init_std: float = 0.02, share_projection: bool = True, scaling: str | bool | None = 'std', do_mask_input: bool | None = None, mask_type: str = 'random', random_mask_ratio: float = 0.5, num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,), channel_consistent_masking: bool | None = False, unmasked_channel_indices: list[int] | None = None, mask_value: int = 0, pooling_type: str | None = 'mean', head_dropout: float | int = 0.0, prediction_length: int = 24, num_targets: int = 1, output_range: list | None = None, num_parallel_samples: int = 100)
```

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

**Parámetros:**

num_input_channels (`int`, *opcional*, valor predeterminado `1`) : El número de canales de entrada.

context_length (`int`, *opcional*, valor predeterminado 32) : La longitud de contexto de la secuencia de entrada.

distribution_output (`str`, *opcional*, valor predeterminado `"student_t"`) : La cabeza de emisión de distribución del modelo cuando la pérdida es "nll". Puede ser "student_t", "normal" o "negative_binomial".

loss (`str`, *opcional*, valor predeterminado `"mse"`) : La función de pérdida del modelo correspondiente a la cabecera `distribution_output`. Para distribuciones paramétricas es la verosimilitud negativa ("nll") y para estimaciones puntuales es el error cuadrático medio "mse".

patch_length (`int`, *opcional*, valor predeterminado 1) : Define la longitud del parche del proceso de parchificación.

patch_stride (`int`, *opcional*, valor predeterminado 1) : Define el paso del proceso de parcheado.

num_hidden_layers (`int`, *opcional*, valor predeterminado `3`) : Número de capas ocultas en el decodificador del Transformer.

d_model (`int`, *opcional*, valor predeterminado `128`) : Tamaño de las capas del codificador y de la capa pooler.

num_attention_heads (`int`, *opcional*, valor predeterminado 4) : Número de cabezas de atención para cada capa de atención en el codificador Transformer.

share_embedding (`bool`, *opcional*, valor predeterminado `True`) : Compartir el embedding de entrada entre todos los canales.

channel_attention (`bool`, *opcional*, valor predeterminado `False`) : Activa el bloque de atención de canal en el Transformer para permitir que los canales presten atención entre sí.

ffn_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de la capa "intermedia" (a menudo denominada feed-forward) en el codificador Transformer.

norm_type (`str` , *opcional*, valor predeterminado `"batchnorm"`) : Normalización en cada capa de Transformer. Puede ser `"batchnorm"` o `"layernorm"`.

norm_eps (`float`, *opcional*, valor predeterminado 1e-05) : Un valor que se suma al denominador para la estabilidad numérica de la normalización.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

positional_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout en la capa de incrustación posicional.

path_dropout (`float`, *opcional*, valor predeterminado 0.0) : La ruta de dropout en el bloque residual.

ff_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout utilizada entre las dos capas de las redes feed-forward.

bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir sesgo en las redes feed-forward.

activation_function (`str`, *opcional*, valor predeterminado `"gelu"`) : La función de activación no lineal (cadena) en el Transformer. Se admiten `"gelu"` y `"relu"`.

pre_norm (`bool`, *opcional*, valor predeterminado `True`) : Se aplica la normalización antes de la autoatención si pre_norm está establecido en `True`. En caso contrario, la normalización se aplica después del bloque residual.

positional_encoding_type (`str`, *opcional*, valor predeterminado `"sincos"`) : Codificaciones posicionales. Se admiten las opciones `"random"` y `"sincos"`.

use_cls_token (`bool`, *opcional*, valor predeterminado `False`) : Indica si se utiliza el token cls.

init_std (`float`, *opcional*, valor predeterminado 0.02) : La desviación estándar de la distribución de inicialización de pesos normal truncada.

share_projection (`bool`, *opcional*, valor predeterminado `True`) : Compartir la capa de proyección entre diferentes canales en la cabeza de predicción.

scaling (`Union`, *opcional*, valor predeterminado `"std"`) : Indica si se debe escalar los objetivos de entrada mediante el escalador "mean", el escalador "std" o sin escalador si es `None`. Si es `True`, el escalador se establece en "mean".

do_mask_input (`bool`, *opcional*) : Aplicar enmascaramiento durante el preentrenamiento.

mask_type (`str`, *opcional*, valor predeterminado `"random"`) : Tipo de enmascaramiento. Actualmente solo se admiten `"random"` y `"forecast"`.

random_mask_ratio (`float`, *opcional*, valor predeterminado 0.5) : Proporción de enmascaramiento aplicada para enmascarar los datos de entrada durante el preentrenamiento aleatorio.

num_forecast_mask_patches (`int` o `list`, *opcional*, valor predeterminado `[2]`) : Número de parches que se van a enmascarar al final de cada muestra del lote. Si es un entero, todas las muestras del lote tendrán el mismo número de parches enmascarados. Si es una lista, las muestras del lote se enmascararán aleatoriamente según los números definidos en la lista. Este argumento solo se utiliza para el preentrenamiento de predicción.

channel_consistent_masking (`bool`, *opcional*, valor predeterminado `False`) : Si el enmascaramiento consistente por canal es True, todos los canales tendrán el mismo patrón de enmascaramiento.

unmasked_channel_indices (`list`, *opcional*) : Índices de los canales que no se enmascaran durante el preentrenamiento. Los valores de la lista son números entre 1 y `num_input_channels`

mask_value (`int`, *opcional*, valor predeterminado 0) : Los valores en los parches enmascarados se rellenarán con `mask_value`.

pooling_type (`str`, *opcional*, valor predeterminado `"mean"`) : Pooling del embedding. Se admiten `"mean"`, `"max"` y `None`.

head_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout para la cabecera.

prediction_length (`int`, *opcional*, valor predeterminado 24) : El horizonte de predicción que el modelo generará como salida.

num_targets (`int`, *opcional*, valor predeterminado: 1) : Número de objetivos para tareas de regresión y clasificación. En el caso de clasificación, es el número de clases.

output_range (`list`, *opcional*) : Rango de salida para la tarea de regresión. El rango de los valores de salida se puede establecer para forzar al modelo a producir valores dentro de un rango.

num_parallel_samples (`int`, *opcional*, valor predeterminado 100) : El número de muestras que se generan en paralelo para la predicción probabilística.

Esta es la clase de configuración para almacenar la configuración de un PatchTSTModel. Se utiliza para instanciar un modelo Patchtst según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [ibm-granite/granite-timeseries-patchtst](https://huggingface.co/ibm-granite/granite-timeseries-patchtst)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

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

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

## PatchTSTModel[[transformers.PatchTSTModel]]

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

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

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

**Parámetros:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Patchtst básico que emite estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obligatorio*) : Secuencia de entrada para el modelo

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` se observaron y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para valores **observados**, - 0 para valores **faltantes** (es decir, NaNs que se reemplazaron por ceros).

future_values (`torch.BoolTensor` de forma `(batch_size, prediction_length, num_input_channels)`, *opcional*) : Valores objetivo futuros asociados a `past_values`

output_hidden_states (`bool`, *opcional*) : Si se deben devolver o no los estados ocultos de todas las capas

output_attentions (`bool`, *opcional*) : Si se devuelve o no la atención de salida de todas las capas

return_dict (`bool`, *opcional*) : Indica si se debe devolver un `ModelOutput` en lugar de una tupla simple.

**Devuelve:**

`PatchTSTModelOutput` o tupla de `torch.Tensor` (si `return_dict`=False o `config.return_dict`=False)

Ejemplos:

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

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

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

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

>>> last_hidden_state = outputs.last_hidden_state
```

## PatchTSTForPrediction[[transformers.PatchTSTForPrediction]]

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

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

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

**Parámetros:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo de predicción PatchTST.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obligatorio*) : Secuencia de entrada para el modelo

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` se observaron y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para valores **observados**, - 0 para valores **faltantes** (es decir, NaNs que se reemplazaron por ceros).

future_values (`torch.Tensor` de forma `(bs, forecast_len, num_input_channels)`, *opcional*) : Valores objetivo futuros asociados con `past_values`

output_hidden_states (`bool`, *opcional*) : Si se deben devolver o no los estados ocultos de todas las capas

output_attentions (`bool`, *opcional*) : Si se devuelve o no la atención de salida de todas las capas

return_dict (`bool`, *opcional*) : Indica si se debe devolver un `ModelOutput` en lugar de una tupla simple.

**Devuelve:**

`PatchTSTForPredictionOutput` o tupla de `torch.Tensor` (si `return_dict`=False o `config.return_dict`=False)

Ejemplos:

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

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

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

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

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

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

## PatchTSTForClassification[[transformers.PatchTSTForClassification]]

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

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

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

**Parámetros:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo PatchTST para clasificación.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obligatorio*) : Secuencia de entrada para el modelo

target_values (`torch.Tensor`, *opcional*) : Etiquetas asociadas a `past_values`

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` se observaron y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para valores **observados**, - 0 para valores **faltantes** (es decir, NaNs que se reemplazaron por ceros).

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** `PatchTSTForClassificationOutput` o `tuple(torch.Tensor)`

Un `PatchTSTForClassificationOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) y las entradas.

El método forward de [PatchTSTForClassification](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTForClassification) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`*optional*`, se devuelve cuando se proporciona `labels`, `torch.Tensor` de forma `(1,)`) -- Pérdida total como la suma de la pérdida de modelado de lenguaje enmascarado y la pérdida de predicción de la siguiente secuencia (clasificación).
- **prediction_logits** (`torch.Tensor` de forma `(batch_size, num_targets)`) -- Puntuaciones de predicción de la cabeza de modelado de PatchTST (puntuaciones antes de SoftMax).
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

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

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

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

## PatchTSTForPretraining[[transformers.PatchTSTForPretraining]]

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

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

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

**Parámetros:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo PatchTST para preentrenamiento.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obligatorio*) : Secuencia de entrada para el modelo

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` se observaron y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para valores **observados**, - 0 para valores **faltantes** (es decir, NaNs que se reemplazaron por ceros).

output_hidden_states (`bool`, *opcional*) : Si se deben devolver o no los estados ocultos de todas las capas

output_attentions (`bool`, *opcional*) : Si se devuelve o no la atención de salida de todas las capas

return_dict (`bool`, *opcional*) : Indica si se debe devolver un `ModelOutput` en lugar de una tupla simple.

**Devuelve:**

`PatchTSTForPretrainingOutput` o tupla de `torch.Tensor` (si `return_dict`=False o `config.return_dict`=False)

Ejemplos:

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

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

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

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

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

## PatchTSTForRegression[[transformers.PatchTSTForRegression]]

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

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

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

**Parámetros:**

config ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo PatchTST para regresión.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

past_values (`torch.Tensor` de forma `(bs, sequence_length, num_input_channels)`, *obligatorio*) : Secuencia de entrada para el modelo

target_values (`torch.Tensor` de forma `(bs, num_input_channels)`) : Valores objetivo asociados a `past_values`

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` se observaron y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para valores **observados**, - 0 para valores **faltantes** (es decir, NaNs que se reemplazaron por ceros). Si se devuelve un `ModelOutput` en lugar de una tupla simple.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** `PatchTSTForRegressionOutput` o `tuple(torch.Tensor)`

Un `PatchTSTForRegressionOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([PatchTSTConfig](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTConfig)) y las entradas.

El método forward de [PatchTSTForRegression](/docs/transformers/v5.23.0/es/model_doc/patchtst#transformers.PatchTSTForRegression) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- MSE loss.
- **regression_outputs** (`torch.Tensor` de forma `(batch_size, num_targets)`) -- Salidas de regresión de las cabezas de modelado de series temporales.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

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

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

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

