# PatchTSMixer

## Resumen

El modelo PatchTSMixer fue propuesto en [TSMixer: Lightweight MLP-Mixer Model for Multivariate Time Series Forecasting](https://huggingface.co/papers/2306.09364) por Vijay Ekambaram, Arindam Jati, Nam Nguyen, Phanwadee Sinthong y Jayant Kalagnanam.

PatchTSMixer es un enfoque ligero de modelado de series temporales basado en la arquitectura MLP-Mixer. En esta implementación de HuggingFace, proporcionamos las capacidades de PatchTSMixer para facilitar sin esfuerzo el mezclado ligero entre parches, canales y características ocultas, con el fin de lograr un modelado efectivo de series temporales multivariadas. También admite diversos mecanismos de atención, desde una atención con puerta simple hasta bloques de autoatención más complejos que pueden personalizarse en consecuencia. El modelo puede preentrenarse y, a continuación, utilizarse para diversas tareas de nivel inferior, como predicción, clasificación y regresión.

El resumen del artículo es el siguiente:

*TSMixer es una arquitectura neuronal ligera compuesta exclusivamente por módulos de perceptrones multicapa (MLP), diseñada para la predicción multivariante y el aprendizaje de representaciones en series temporales con parches. Nuestro modelo se inspira en el éxito de los modelos MLP-Mixer en visión por computadora. Demostramos los desafíos implicados en adaptar el Vision MLP-Mixer para series temporales e introducimos componentes validados empíricamente para mejorar la precisión. Esto incluye un nuevo paradigma de diseño que consiste en adjuntar cabezas de reconciliación en línea al esqueleto MLP-Mixer, para modelar explícitamente las propiedades de las series temporales, como la jerarquía y las correlaciones entre canales. También proponemos un enfoque de modelado híbrido de canales para manejar eficazmente las interacciones ruidosas entre canales y la generalización en conjuntos de datos diversos, un desafío común en los métodos existentes de mezcla de canales por parches. Además, se introduce un mecanismo de atención con puerta simple en el esqueleto para priorizar las características importantes. Al incorporar estos componentes ligeros, mejoramos significativamente la capacidad de aprendizaje de las estructuras MLP simples, superando a los modelos Transformer complejos con un uso mínimo de cómputo. Además, el diseño modular de TSMixer permite la compatibilidad con métodos de aprendizaje supervisado y auto-supervisado enmascarado, lo que lo convierte en un bloque de construcción prometedor para los Modelos Fundacionales de series temporales. TSMixer supera a los modelos MLP y Transformer de última generación en predicción con un margen considerable del 8 al 60 %. También supera a los últimos benchmarks fuertes de los modelos Patch-Transformer (por un 1-2 %) con una reducción significativa en memoria y tiempo de ejecución (2-3X).*

Este modelo fue aportado por [ajati](https://huggingface.co/ajati), [vijaye12](https://huggingface.co/vijaye12), [gsinthong](https://huggingface.co/gsinthong), [namctin](https://huggingface.co/namctin), [wmgifford](https://huggingface.co/wmgifford), [kashif](https://huggingface.co/kashif).

## Ejemplo de uso

El fragmento de código siguiente muestra cómo inicializar aleatoriamente un modelo PatchTSMixer. El modelo es compatible con la [Trainer API](../trainer).

```python

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

## 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 [PatchTSMixerForTimeSeriesClassification](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerForTimeSeriesClassification) y [PatchTSMixerForRegression](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerForRegression) correspondientes.

## Recursos

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

## PatchTSMixerConfig[[transformers.PatchTSMixerConfig]]

#### transformers.PatchTSMixerConfig[[transformers.PatchTSMixerConfig]]

```python
transformers.PatchTSMixerConfig(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, context_length: int = 32, patch_length: int = 8, num_input_channels: int = 1, patch_stride: int = 8, num_parallel_samples: int = 100, d_model: int = 8, expansion_factor: int = 2, num_layers: int = 3, dropout: float | int = 0.2, mode: str = 'common_channel', gated_attn: bool = True, norm_mlp: str = 'LayerNorm', self_attn: bool = False, self_attn_heads: int = 1, use_positional_encoding: bool = False, positional_encoding_type: str = 'sincos', scaling: str | bool | None = 'std', loss: str = 'mse', init_std: float = 0.02, norm_eps: float = 1e-05, mask_type: str = 'random', random_mask_ratio: float = 0.5, num_forecast_mask_patches: list[int] | tuple[int, ...] | int | None = (2,), mask_value: int = 0, masked_loss: bool = True, channel_consistent_masking: bool = True, unmasked_channel_indices: list[int] | None = None, head_dropout: float | int = 0.2, distribution_output: str = 'student_t', prediction_length: int = 16, prediction_channel_indices: list | None = None, num_targets: int = 3, output_range: list | None = None, head_aggregation: str | None = 'max_pool')
```

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

**Parámetros:**

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

patch_length (`int`, *opcional*, valor predeterminado 8) : La longitud del parche para la secuencia de entrada.

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

patch_stride (`int`, *opcional*, valor predeterminado 8) : Determina la superposición entre dos parches consecutivos. Establézcalo en patch_length (o mayor) si se desean parches sin superposición.

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

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

expansion_factor (`int`, *opcional*, valor predeterminado 2) : Factor de expansión que se utiliza dentro del MLP. El rango recomendado es de 2 a 5. Un valor mayor indica un modelo más complejo.

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

dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.2`) : La proporción para todas las capas de dropout.

mode (`str`, *opcional*, valor predeterminado `"common_channel"`) : Modo de mezclador. Determina cómo procesar los canales. Valores permitidos: "common_channel", "mix_channel". En el modo "common_channel", seguimos un modelado independiente de canales sin mezcla de canales explícita. La mezcla de canales ocurre de manera implícita a través de pesos compartidos entre canales. (primer enfoque preferido) En el modo "mix_channel", seguimos una mezcla de canales explícita además del mezclador de parches y de características. (enfoque preferido cuando las correlaciones entre canales son muy importantes para el modelo)

gated_attn (`bool`, *opcional*, valor predeterminado `True`) : Habilita la atención con compuerta.

norm_mlp (`str`, *opcional*, valor predeterminado `"LayerNorm"`) : Capa de normalización (BatchNorm o LayerNorm).

self_attn (`bool`, *opcional*, valor predeterminado `False`) : Habilita la autoatención Tiny entre parches. Esto se puede habilitar cuando la salida de Vanilla PatchTSMixer con atención con puerta no es satisfactoria. Habilitar esto conduce a una atención explícita por pares y modelado entre parches.

self_attn_heads (`int`, *opcional*, valor predeterminado 1) : Número de cabezas de autoatención. Solo funciona cuando `self_attn` se establece en `True`.

use_positional_encoding (`bool`, *opcional*, valor predeterminado `False`) : Habilita el uso de incrustaciones posicionales para las capas de autoatención diminutas. Solo funciona cuando `self_attn` se establece en `True`.

positional_encoding_type (`str`, *opcional*, por defecto `"sincos"`) : Codificaciones posicionales. Se admiten las opciones `"random"` y `"sincos"`. Solo funciona cuando `use_positional_encoding` está establecido en `True`

scaling (`string` o `bool`, *opcional*, valor predeterminado `"std"`) : Si se deben 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".

loss (`string`, *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".

init_std (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

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

mask_type (`str`, *opcional*, valor predeterminado `"random"`) : Tipo de enmascaramiento a utilizar en el modo de preentrenamiento con enmascaramiento. Los valores permitidos son "random" y "forecast". En el enmascaramiento aleatorio, los puntos se enmascaran de forma aleatoria. En el enmascaramiento de pronóstico, los puntos se enmascaran hacia el final.

random_mask_ratio (`float`, *opcional*, valor predeterminado 0.5) : Proporción de enmascaramiento a utilizar cuando `mask_type` es `random`. Un valor más alto indica más enmascaramiento.

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.

mask_value (`float`, *opcional*, valor predeterminado `0.0`) : Valor de la máscara a utilizar.

masked_loss (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe calcular la pérdida de preentrenamiento solo en las porciones enmascaradas o en toda la salida.

channel_consistent_masking (`bool`, *opcional*, valor predeterminado `True`) : Si es true, la máscara será la misma en todos los canales de una serie temporal. De lo contrario, las posiciones de la máscara variarán entre canales.

unmasked_channel_indices (`list`, *opcional*) : Canales que no se enmascaran durante el preentrenamiento.

head_dropout (`float`, *opcional*, valor predeterminado 0.2) : La probabilidad de dropout de la cabeza `PatchTSMixer`.

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

prediction_length (`int`, *opcional*, valor predeterminado 16) : Número de pasos de tiempo para predecir en una tarea de pronóstico. También conocido como Horizonte de Pronóstico.

prediction_channel_indices (`list`, *opcional*) : Lista de índices de canales a predecir. Si es None, se predice todos los canales. Se espera que los datos de destino tengan todos los canales y se filtran explícitamente los canales en la predicción y el destino antes de calcular la pérdida.

num_targets (`int`, *opcional*, valor predeterminado 3) : Número de objetivos (dimensionalidad de la variable regresada) para una tarea de regresión.

output_range (`list`, *opcional*) : Rango de salida para restringir la tarea de regresión. El valor predeterminado es None.

head_aggregation (`str`, *opcional*, valor predeterminado `"max_pool"`) : Modo de agregación para habilitar en una tarea de clasificación o regresión. Los valores permitidos son `None`, "use_last", "max_pool", "avg_pool".

Esta es la clase de configuración para almacenar la configuración de un PatchTSMixerModel. Se utiliza para instanciar un modelo Patchtsmixer 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/patchtsmixer-etth1-pretrain](https://huggingface.co/ibm/patchtsmixer-etth1-pretrain)

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.

Ejemplo:

```python
>>> 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[[transformers.PatchTSMixerModel]]

#### transformers.PatchTSMixerModel[[transformers.PatchTSMixerModel]]

```python
transformers.PatchTSMixerModel(config: PatchTSMixerConfig, mask_input: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1200)

**Parámetros:**

config ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : 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.

mask_input (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe enmascarar la entrada usando el módulo `PatchTSMixerMasking`.

El modelo PatchTSMixer para el pronóstico de series temporales.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1226)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto de la serie temporal. Para una tarea de preentrenamiento, esto denota la serie temporal de entrada para predecir la porción enmascarada. Para una tarea de pronóstico, esto denota los valores históricos/pasados de la serie temporal. De manera similar, para tareas de clasificación o regresión, denota los valores de contexto apropiados de la serie temporal. Para series temporales univariadas, la dimensión `num_input_channels` debe ser 1. Para series temporales multivariadas, es mayor que 1.

observed_mask (`torch.Tensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` fueron observados y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`: - 1 para valores que son **observados**, - 0 para valores que son **faltantes** (es decir, NaNs que fueron reemplazados 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.

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

Un `PatchTSMixerModelOutput` 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 ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) y las entradas.

El método forward de [PatchTSMixerModel](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerModel) 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.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, num_patches, d_model)`) -- Estado oculto en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos del modelo en la salida de cada capa.
- **patch_input** (`torch.Tensor` de forma `(batch_size, num_channels, num_patches, patch_length)`) -- Datos de entrada con parches para el modelo.
- **mask** (`torch.Tensor` de forma `(batch_size, num_channels, num_patches)`, *opcional*) -- Tensor booleano que indica True en los parches enmascarados y False en los demás.
- **loc** (`torch.Tensor` de forma `(batch_size, 1, num_channels)`, *opcional*) -- Proporciona la media de la ventana de contexto por canal. Se utiliza para la denormalización de revin fuera del modelo, si revin está habilitado.
- **scale** (`torch.Tensor` de forma `(batch_size, 1, num_channels)`, *opcional*) -- Proporciona la desviación estándar de la ventana de contexto por canal. Se utiliza para la denormalización de revin fuera del modelo, si revin está habilitado.

## PatchTSMixerForPrediction[[transformers.PatchTSMixerForPrediction]]

#### transformers.PatchTSMixerForPrediction[[transformers.PatchTSMixerForPrediction]]

```python
transformers.PatchTSMixerForPrediction(config: PatchTSMixerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1481)

**Parámetros:**

config (`PatchTSMixerConfig`) : Configuración.

**Devuelve:**

`None`.

`PatchTSMixer` para aplicaciones de predicción.

#### forward[[transformers.PatchTSMixerForPrediction.forward]]

```python
forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, future_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1523)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto de la serie temporal. Para una tarea de preentrenamiento, esto denota la serie temporal de entrada para predecir la porción enmascarada. Para una tarea de pronóstico, esto denota los valores históricos/pasados de la serie temporal. De manera similar, para tareas de clasificación o regresión, denota los valores de contexto apropiados de la serie temporal. Para series temporales univariadas, la dimensión `num_input_channels` debe ser 1. Para series temporales multivariadas, es mayor que 1.

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

future_values (`torch.Tensor` de forma `(batch_size, target_len, num_input_channels)` para predicción, : `(batch_size, num_targets)` para regresión, o `(batch_size,)` para clasificación, *opcional*): Valores objetivo de la serie temporal, que sirven como etiquetas para el modelo. `future_values` es lo que el Transformer necesita durante el entrenamiento para aprender a producir, dado `past_values`. Tenga en cuenta que esto NO es necesario para una tarea de preentrenamiento. Para una tarea de predicción, la forma debe ser `(batch_size, target_len, num_input_channels)`. Incluso si queremos predecir solo canales específicos estableciendo los índices en el parámetro `prediction_channel_indices`, pase los datos objetivo con todos los canales, ya que el filtrado de canales tanto para la predicción como para el objetivo se aplicará manualmente antes del cálculo de la pérdida.

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.

return_loss (`bool`,  *opcional*) : Indica si se debe devolver la pérdida en la llamada a `forward`.

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

Un `PatchTSMixerForPredictionOutput` 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 ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) y las entradas.

El método forward de [PatchTSMixerForPrediction](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerForPrediction) 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss.
- **prediction_outputs** (`torch.Tensor` de forma `(batch_size, prediction_length, num_input_channels)`) -- Salida de predicción de la cabeza de pronóstico.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings del backbone antes de pasar por la cabeza.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos del modelo en la salida de cada capa, más las salidas opcionales de la incrustación inicial.
- **loc** (`torch.Tensor`, *opcional* de forma `(batch_size, 1, num_input_channels)`) -- Media de entrada
- **scale** (`torch.Tensor`, *opcional* de forma `(batch_size, 1, num_input_channels)`) -- Desviación estándar de la entrada

## PatchTSMixerForTimeSeriesClassification[[transformers.PatchTSMixerForTimeSeriesClassification]]

#### transformers.PatchTSMixerForTimeSeriesClassification[[transformers.PatchTSMixerForTimeSeriesClassification]]

```python
transformers.PatchTSMixerForTimeSeriesClassification(config: PatchTSMixerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1707)

**Parámetros:**

config (`PatchTSMixerConfig`) : Configuración.

**Devuelve:**

`None`.

`PatchTSMixer` para aplicaciones de clasificación.

#### forward[[transformers.PatchTSMixerForTimeSeriesClassification.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1734)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto de la serie temporal. Para una tarea de preentrenamiento, esto denota la serie temporal de entrada para predecir la porción enmascarada. Para una tarea de pronóstico, esto denota los valores históricos/pasados de la serie temporal. De manera similar, para tareas de clasificación o regresión, denota los valores de contexto apropiados de la serie temporal. Para series temporales univariadas, la dimensión `num_input_channels` debe ser 1. Para series temporales multivariadas, es mayor que 1.

target_values (`torch.Tensor` de forma `(batch_size, target_len, num_input_channels)` para predicción, : `(batch_size, num_targets)` para regresión, o `(batch_size,)` para clasificación, *opcional*): Valores objetivo de la serie temporal, que sirven como etiquetas para el modelo. `target_values` es lo que el Transformer necesita durante el entrenamiento para aprender a producir, dado `past_values`. Tenga en cuenta que esto NO es necesario para una tarea de preentrenamiento. Para una tarea de predicción, la forma debe ser `(batch_size, target_len, num_input_channels)`. Incluso si queremos predecir solo canales específicos estableciendo los índices en el parámetro `prediction_channel_indices`, pase los datos objetivo con todos los canales, ya que el filtrado de canales para ambas la predicción y el objetivo se aplicará manualmente antes del cálculo de la pérdida. Para una tarea de clasificación, tiene una forma de `(batch_size,)`. Para una tarea de regresión, tiene una forma de `(batch_size, num_targets)`.

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.

return_loss (`bool`, *opcional*) : Indica si se debe devolver la pérdida en la llamada a `forward`.

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

Un `PatchTSMixerForTimeSeriesClassificationOutput` 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 ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) y las entradas.

El método forward de [PatchTSMixerForTimeSeriesClassification](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerForTimeSeriesClassification) sobrescribe 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss.
- **prediction_outputs** (`torch.Tensor` de forma `(batch_size, num_labels)`) -- Salida de predicción de la cabeza de clasificación.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings del backbone antes de pasar por la cabeza.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos del modelo en la salida de cada capa, más las salidas opcionales de la incrustación inicial.

## PatchTSMixerForPretraining[[transformers.PatchTSMixerForPretraining]]

#### transformers.PatchTSMixerForPretraining[[transformers.PatchTSMixerForPretraining]]

```python
transformers.PatchTSMixerForPretraining(config: PatchTSMixerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1313)

**Parámetros:**

config ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : 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.

`PatchTSMixer` para el preentrenamiento con máscaras.

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

```python
forward(past_values: Tensor, observed_mask: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_loss: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1323)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto de la serie temporal. Para una tarea de preentrenamiento, esto denota la serie temporal de entrada para predecir la porción enmascarada. Para una tarea de pronóstico, esto denota los valores históricos/pasados de la serie temporal. De manera similar, para tareas de clasificación o regresión, denota los valores de contexto apropiados de la serie temporal. Para series temporales univariadas, la dimensión `num_input_channels` debe ser 1. Para series temporales multivariadas, es mayor que 1.

observed_mask (`torch.Tensor` de forma `(batch_size, sequence_length, num_input_channels)`, *opcional*) : Máscara booleana para indicar qué `past_values` fueron observados y cuáles faltaron. Valores de la máscara seleccionados en `[0, 1]`: - 1 para valores que son **observados**, - 0 para valores que son **faltantes** (es decir, NaNs que fueron reemplazados 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.

return_loss (`bool`,  *opcional*) : Indica si se debe devolver la pérdida en la llamada a `forward`.

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

Un `PatchTSMixerForPreTrainingOutput` 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 ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) y las entradas.

El método forward de [PatchTSMixerForPretraining](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerForPretraining) 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss
- **prediction_outputs** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, patch_length)`) -- Salida de predicción de la cabeza de preentrenamiento.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings del backbone antes de pasar por la cabeza.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos del modelo en la salida de cada capa.

## PatchTSMixerForRegression[[transformers.PatchTSMixerForRegression]]

#### transformers.PatchTSMixerForRegression[[transformers.PatchTSMixerForRegression]]

```python
transformers.PatchTSMixerForRegression(config: PatchTSMixerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1875)

**Parámetros:**

config ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) : 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.

`PatchTSMixer` para aplicaciones de 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.PatchTSMixerForRegression.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/patchtsmixer/modeling_patchtsmixer.py#L1913)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, seq_length, num_input_channels)`) : Valores de contexto de la serie temporal. Para una tarea de preentrenamiento, esto denota la serie temporal de entrada para predecir la porción enmascarada. Para una tarea de pronóstico, esto denota los valores históricos/pasados de la serie temporal. De manera similar, para tareas de clasificación o regresión, denota los valores de contexto apropiados de la serie temporal. Para series temporales univariadas, la dimensión `num_input_channels` debe ser 1. Para series temporales multivariadas, es mayor que 1.

target_values (`torch.Tensor` de forma `(batch_size, target_len, num_input_channels)` para predicción, : `(batch_size, num_targets)` para regresión, o `(batch_size,)` para clasificación, *opcional*): Valores objetivo de la serie temporal, que sirven como etiquetas para el modelo. `target_values` es lo que el Transformer necesita durante el entrenamiento para aprender a producir, dado `past_values`. Tenga en cuenta que esto NO es necesario para una tarea de preentrenamiento. Para una tarea de predicción, la forma debe ser `(batch_size, target_len, num_input_channels)`. Incluso si queremos predecir solo canales específicos estableciendo los índices en el parámetro `prediction_channel_indices`, pase los datos objetivo con todos los canales, ya que el filtrado de canales para ambas la predicción y el objetivo se aplicará manualmente antes del cálculo de la pérdida. Para una tarea de clasificación, tiene una forma de `(batch_size,)`. Para una tarea de regresión, tiene una forma de `(batch_size, num_targets)`.

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.

return_loss (`bool`, *opcional*) : Indica si se debe devolver la pérdida en la llamada a `forward`.

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

Un `PatchTSMixerForRegressionOutput` 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 ([PatchTSMixerConfig](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerConfig)) y las entradas.

El método forward de [PatchTSMixerForRegression](/docs/transformers/v5.23.0/es/model_doc/patchtsmixer#transformers.PatchTSMixerForRegression) 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 `y` is provided, `torch.Tensor` of shape `()`) -- Total loss.
- **regression_outputs** (`torch.Tensor` de forma `(batch_size, num_targets)`) -- Salida de predicción de la cabeza de regresión.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_input_channels, num_patches, d_model)`) -- Embeddings del backbone antes de pasar por la cabeza.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Estados ocultos del modelo en la salida de cada capa, más las salidas opcionales de la incrustación inicial.

