# Informer

## Resumen

El modelo Informer fue propuesto en [Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting](https://huggingface.co/papers/2012.07436) por Haoyi Zhou, Shanghang Zhang, Jieqi Peng, Shuai Zhang, Jianxin Li, Hui Xiong y Wancai Zhang.

Este método introduce un mecanismo de Atención Probabilística para seleccionar las consultas "activas" en lugar de las consultas "perezosas" y proporciona un Transformer disperso, lo que mitiga los requisitos de cómputo y memoria cuadráticos de la atención estándar.

El resumen del artículo es el siguiente:

*Muchas aplicaciones del mundo real requieren la predicción de series temporales de secuencias largas, como la planificación del consumo eléctrico. La predicción de series temporales de secuencias largas (LSTF) exige una alta capacidad de predicción del modelo, es decir, la capacidad de capturar de manera eficiente el acoplamiento de dependencias de largo alcance entre la salida y la entrada. Estudios recientes han demostrado el potencial de Transformer para aumentar la capacidad de predicción. Sin embargo, existen varios problemas graves con Transformer que impiden su aplicación directa a LSTF, entre ellos la complejidad temporal cuadrática, el alto uso de memoria y la limitación inherente de la arquitectura encoder-decoder. Para abordar estos problemas, diseñamos un modelo eficiente basado en transformer para LSTF, denominado Informer, con tres características distintivas: (i) un mecanismo de autoatención ProbSparse, que logra O(L logL) en complejidad temporal y uso de memoria, y presenta un rendimiento comparable en la alineación de dependencias de las secuencias. (ii) la destilación de autoatención resalta la atención dominante al reducir a la mitad la entrada de la capa en cascada, y maneja de manera eficiente secuencias de entrada extremadamente largas. (iii) el decodificador de estilo generativo, aunque conceptualmente simple, predice las secuencias de series temporales largas en una sola operación de propagación hacia adelante, en lugar de hacerlo de manera paso a paso, lo que mejora drásticamente la velocidad de inferencia de las predicciones de secuencias largas. Experimentos extensos en cuatro conjuntos de datos a gran escala demuestran que Informer supera significativamente a los métodos existentes y ofrece una nueva solución al problema de LSTF.*

Este modelo fue aportado por [elisim](https://huggingface.co/elisim) y [kashif](https://huggingface.co/kashif). El código original se puede encontrar [aquí](https://github.com/zhouhaoyi/Informer2020).

## Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente.

- Echa un vistazo al artículo de blog de Informer en el blog de HuggingFace: [Pronóstico probabilista de series temporales multivariadas con Informer](https://huggingface.co/blog/informer)

## InformerConfig[[transformers.InformerConfig]]

#### transformers.InformerConfig[[transformers.InformerConfig]]

```python
transformers.InformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, prediction_length: int | None = None, context_length: int | None = None, distribution_output: str = 'student_t', loss: str = 'nll', input_size: int = 1, lags_sequence: list[int] | None = None, scaling: str | bool | None = 'mean', num_dynamic_real_features: int = 0, num_static_real_features: int = 0, num_static_categorical_features: int = 0, num_time_features: int = 0, cardinality: list[int] | None = None, embedding_dimension: list[int] | None = None, d_model: int = 64, encoder_ffn_dim: int = 32, decoder_ffn_dim: int = 32, encoder_attention_heads: int = 2, decoder_attention_heads: int = 2, encoder_layers: int = 2, decoder_layers: int = 2, activation_function: str = 'gelu', dropout: float | int = 0.05, encoder_layerdrop: float | int = 0.1, decoder_layerdrop: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, num_parallel_samples: int = 100, init_std: float = 0.02, use_cache: bool = True, attention_type: str = 'prob', sampling_factor: int = 5, distil: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/informer/configuration_informer.py#L24)

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

prediction_length (`int`, *opcional*) : La longitud de predicción para el decodificador. En otras palabras, el horizonte de predicción del modelo. Este valor suele estar determinado por el conjunto de datos y recomendamos configurarlo de manera adecuada.

context_length (`int`, *opcional*, valor predeterminado `prediction_length`) : La longitud de contexto para el codificador. Si es `None`, la longitud de contexto será la misma que la `prediction_length`.

distribution_output (`string`, *opcional*, valor predeterminado `"student_t"`) : La cabeza de emisión de distribución del modelo. Puede ser "student_t", "normal" o "negative_binomial".

loss (`string`, *opcional*, valor predeterminado `"nll"`) : La función de pérdida del modelo correspondiente a la cabecera `distribution_output`. Para distribuciones paramétricas, es la verosimilitud negativa (nll), que actualmente es la única admitida.

input_size (`int`, *opcional*, valor predeterminado 1) : El tamaño de la variable objetivo, que por defecto es 1 para objetivos univariados. Sería > 1 en el caso de objetivos multivariados.

lags_sequence (`list[int]`, *opcional*, valor predeterminado `[1, 2, 3, 4, 5, 6, 7]`) : Los rezagos de la serie temporal de entrada como covariables, a menudo dictados por la frecuencia de los datos. El valor predeterminado es `[1, 2, 3, 4, 5, 6, 7]`, pero recomendamos modificarlo según corresponda en función del conjunto de datos.

scaling (`string` o `bool`, *opcional* con valor predeterminado `"mean"`) : Si se debe escalar las etiquetas de entrada mediante el escalador "mean", el escalador "std" o sin escalador si es `None`. Si es `True`, el escalador se establece en "mean".

num_dynamic_real_features (`int`, *opcional*, valor predeterminado 0) : El número de características dinámicas de valor real.

num_static_real_features (`int`, *opcional*, valor predeterminado 0) : El número de características estáticas de valor real.

num_static_categorical_features (`int`, *opcional*, valor predeterminado 0) : El número de características categóricas estáticas.

num_time_features (`int`, *opcional*, valor predeterminado 0) : El número de características temporales en la serie temporal de entrada.

cardinality (`list[int]`, *opcional*) : La cardinalidad (número de valores distintos) para cada una de las características categóricas estáticas. Debe ser una lista de enteros, con la misma longitud que `num_static_categorical_features`. No puede ser `None` si `num_static_categorical_features` es > 0.

embedding_dimension (`list[int]`, *opcional*) : La dimensión del embedding para cada una de las características categóricas estáticas. Debe ser una lista de enteros, con la misma longitud que `num_static_categorical_features`. No puede ser `None` si `num_static_categorical_features` es > 0.

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

encoder_ffn_dim (`int`, *opcional*, valor predeterminado `32`) : Dimensionalidad de la capa "intermedia" (a menudo denominada feed-forward) en el codificador.

decoder_ffn_dim (`int`, *opcional*, valor predeterminado `32`) : Dimensionalidad de la capa "intermedia" (a menudo denominada feed-forward) en el decodificador.

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

decoder_attention_heads (`int`, *opcional*, valor predeterminado `2`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

encoder_layers (`int`, *opcional*, valor predeterminado `2`) : Número de capas ocultas en el codificador Transformer. Usará el mismo valor que `num_layers` si no se establece.

decoder_layers (`int`, *opcional*, valor predeterminado `2`) : Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor que `num_layers`.

activation_function (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

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

encoder_layerdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de LayerDrop para el codificador. Consulte el [artículo de LayerDrop](see https://huggingface.co/papers/1909.11556) para obtener más detalles.

decoder_layerdrop (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de LayerDrop para el decodificador. Consulte el [artículo de LayerDrop](see https://huggingface.co/papers/1909.11556) para obtener más detalles.

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

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

num_parallel_samples (`int`, *opcional*, valor predeterminado: 100) : El número de muestras que se generan en paralelo para cada paso de tiempo de la inferencia.

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

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

attention_type (`str`, *opcional*, valor predeterminado "prob") : Atención utilizada en el codificador. Se puede establecer en "prob" (ProbAttention de Informer) o en "full" (autoatención canónica del transformer estándar).

sampling_factor (`int`, *opcional*, valor predeterminado: 5) : Factor de muestreo de ProbSparse (solo tiene efecto cuando `attention_type`="prob"). Se utiliza para controlar la longitud de entrada de la matriz de consulta reducida (Q_reduce).

distil (`bool`, *opcional*, valor predeterminado `True`) : Si se usa destilación en el codificador.

Esta es la clase de configuración para almacenar la configuración de un InformerModel. Se utiliza para instanciar un modelo Informer 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 [huggingface/informer-tourism-monthly](https://huggingface.co/huggingface/informer-tourism-monthly)

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

Ejemplo:

```python
>>> from transformers import InformerConfig, InformerModel

>>> # Initializing an Informer configuration with 12 time steps for prediction
>>> configuration = InformerConfig(prediction_length=12)

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

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

## InformerModel[[transformers.InformerModel]]

#### transformers.InformerModel[[transformers.InformerModel]]

```python
transformers.InformerModel(config: InformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/informer/modeling_informer.py#L994)

**Parámetros:**

config ([InformerConfig](/docs/transformers/main/es/model_doc/informer#transformers.InformerConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

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

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.InformerModel.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/informer/modeling_informer.py#L1132)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, sequence_length)` o `(batch_size, sequence_length, input_size)`) : Valores pasados de la serie temporal, que sirven como contexto para predecir el futuro. El tamaño de la secuencia de este tensor debe ser mayor que el `context_length` del modelo, ya que el modelo utilizará el tamaño mayor para construir características de rezago, es decir, valores adicionales del pasado que se añaden para servir como "contexto extra".  El `sequence_length` aquí es igual a `config.context_length` + `max(config.lags_sequence)`, lo cual, si no se configura `lags_sequence`, es igual a `config.context_length` + 7 (ya que, por defecto, el índice de retroceso más grande en `config.lags_sequence` es 7). La propiedad `_past_length` devuelve la longitud real del pasado.  El `past_values` es lo que el codificador Transformer recibe como entrada (con características adicionales opcionales, como `static_categorical_features`, `static_real_features`, `past_time_features` y rezagos).  Opcionalmente, los valores faltantes deben reemplazarse con ceros e indicarse mediante la `past_observed_mask`.  Para series temporales multivariadas, se requiere la dimensión `input_size` > 1, que corresponde al número de variables en la serie temporal por paso de tiempo.

past_time_features (`torch.Tensor` de forma `(batch_size, sequence_length, num_features)`) : Características temporales requeridas, que el modelo añadirá internamente a `past_values`. Estas pueden ser cosas como "mes del año", "día del mes", etc., codificadas como vectores (por ejemplo, como características de Fourier). También pueden ser las llamadas características de "edad", que básicamente ayudan al modelo a saber "en qué punto de su vida" se encuentra una serie temporal. Las características de edad tienen valores pequeños para los pasos de tiempo del pasado lejano y aumentan de forma monótona a medida que nos acercamos al paso de tiempo actual. Las características de festivos también son un buen ejemplo de características temporales. Estas características sirven como las "codificaciones posicionales" de las entradas. Por lo tanto, a diferencia de un modelo como BERT, donde las codificaciones de posición se aprenden desde cero internamente como parámetros del modelo, el Time Series Transformer requiere proporcionar características temporales adicionales. El Time Series Transformer solo aprende incrustaciones adicionales para `static_categorical_features`. Se pueden concatenar covariables dinámicas reales adicionales a este tensor, con la salvedad de que estas características deben ser conocidas en el momento de la predicción. El `num_features` aquí es igual a `config.`num_time_features` + `config.num_dynamic_real_features`.

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)` o `(batch_size, sequence_length, input_size)`, *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).

static_categorical_features (`torch.LongTensor` de forma `(batch_size, number of static categorical features)`, *opcional*) : Características categóricas estáticas opcionales para las que el modelo aprenderá un embedding, que añadirá a los valores de la serie temporal. Las características categóricas estáticas son aquellas que tienen el mismo valor para todos los pasos de tiempo (estáticas en el tiempo). Un ejemplo típico de una característica categórica estática es un ID de serie temporal.

static_real_features (`torch.Tensor` de forma `(batch_size, number of static real features)`, *opcional*) : Características reales estáticas opcionales que el modelo añadirá a los valores de la serie temporal. Las características reales estáticas son aquellas que tienen el mismo valor para todos los pasos de tiempo (estáticas en el tiempo). Un ejemplo típico de una característica real estática es la información de promociones.

future_values (`torch.Tensor` de forma `(batch_size, prediction_length)` o `(batch_size, prediction_length, input_size)`, *opcional*) : Valores futuros 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 generar, dado `past_values`. La longitud de la secuencia aquí es igual a `prediction_length`. Consulte el cuaderno de demostración y los fragmentos de código para obtener más detalles. Opcionalmente, durante el entrenamiento, cualquier valor faltante debe reemplazarse con ceros e indicarse mediante `future_observed_mask`. Para series temporales multivariadas, se requiere la dimensión `input_size` > 1, que corresponde al número de variables en la serie temporal por paso de tiempo.

future_time_features (`torch.Tensor` de forma `(batch_size, prediction_length, num_features)`) : Características temporales requeridas para la ventana de predicción, que el modelo añadirá internamente a `future_values`. Estas pueden ser cosas como "mes del año", "día del mes", etc., codificadas como vectores (por ejemplo, como características de Fourier). También pueden ser las llamadas características de "edad", que básicamente ayudan al modelo a saber "en qué punto de su vida" se encuentra una serie temporal. Las características de edad tienen valores pequeños para los pasos de tiempo del pasado lejano y aumentan de forma monótona a medida que nos acercamos al paso de tiempo actual. Las características de festivos también son un buen ejemplo de características temporales. Estas características sirven como las "codificaciones posicionales" de las entradas. Por lo tanto, a diferencia de un modelo como BERT, donde las codificaciones de posición se aprenden desde cero internamente como parámetros del modelo, el Time Series Transformer requiere proporcionar características temporales adicionales. El Time Series Transformer solo aprende incrustaciones adicionales para `static_categorical_features`. Se pueden concatenar covariables dinámicas reales adicionales a este tensor, con la salvedad de que estas características deben ser conocidas en el momento de la predicción. El `num_features` aquí es igual a `config.num_time_features` + `config.num_dynamic_real_features`.

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Máscara para evitar realizar atención en ciertos índices de tokens. De forma predeterminada, se utilizará una máscara causal para asegurarse de que el modelo solo pueda ver las entradas anteriores para predecir el futuro.

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optional*) : La tupla consiste en `last_hidden_state`, `hidden_states` (*optional*) y `attentions` (*optional*) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)` (*optional*) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la cross-attention del decodificador.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

**Devuelve:** [Seq2SeqTSModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) o `tuple(torch.Tensor)`

Un [Seq2SeqTSModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) 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 ([InformerConfig](/docs/transformers/main/es/model_doc/informer#transformers.InformerConfig)) y las entradas.

El método forward de [InformerModel](/docs/transformers/main/es/model_doc/informer#transformers.InformerModel) 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, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del decodificador del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_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 los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del decodificador en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto 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 codificador en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **loc** (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) -- Desplaza los valores de la ventana de contexto de cada serie temporal, lo que se utiliza para proporcionar al modelo entradas de la misma magnitud y luego se utiliza para desplazar de vuelta a la magnitud original.
- **scale** (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) -- Valores de escalado de la ventana de contexto de cada serie temporal, que se utilizan para proporcionar al modelo entradas de la misma magnitud y luego para reescalar de vuelta a la magnitud original.
- **static_features** (`torch.Tensor` de forma `(batch_size, feature size)`, *opcional*) -- Características estáticas de cada serie temporal en un lote que se copian en las covariables durante la inferencia.

Ejemplos:

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

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

>>> model = InformerModel.from_pretrained("huggingface/informer-tourism-monthly")

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

>>> last_hidden_state = outputs.last_hidden_state
```

## InformerForPrediction[[transformers.InformerForPrediction]]

#### transformers.InformerForPrediction[[transformers.InformerForPrediction]]

```python
transformers.InformerForPrediction(config: InformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/informer/modeling_informer.py#L1357)

**Parámetros:**

config ([InformerConfig](/docs/transformers/main/es/model_doc/informer#transformers.InformerConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Informer con una cabeza de distribución en la parte superior para el pronóstico de series temporales.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.InformerForPrediction.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/informer/modeling_informer.py#L1392)

**Parámetros:**

past_values (`torch.Tensor` de forma `(batch_size, sequence_length)` o `(batch_size, sequence_length, input_size)`) : Valores pasados de la serie temporal, que sirven como contexto para predecir el futuro. El tamaño de la secuencia de este tensor debe ser mayor que el `context_length` del modelo, ya que el modelo utilizará el tamaño mayor para construir características de rezago, es decir, valores adicionales del pasado que se añaden para servir como "contexto extra".  El `sequence_length` aquí es igual a `config.context_length` + `max(config.lags_sequence)`, lo cual, si no se configura `lags_sequence`, es igual a `config.context_length` + 7 (ya que, por defecto, el índice de retroceso más grande en `config.lags_sequence` es 7). La propiedad `_past_length` devuelve la longitud real del pasado.  El `past_values` es lo que el codificador Transformer recibe como entrada (con características adicionales opcionales, como `static_categorical_features`, `static_real_features`, `past_time_features` y rezagos).  Opcionalmente, los valores faltantes deben reemplazarse con ceros e indicarse mediante la `past_observed_mask`.  Para series temporales multivariadas, se requiere la dimensión `input_size` > 1, que corresponde al número de variables en la serie temporal por paso de tiempo.

past_time_features (`torch.Tensor` de forma `(batch_size, sequence_length, num_features)`) : Características temporales requeridas, que el modelo añadirá internamente a `past_values`. Estas pueden ser cosas como "mes del año", "día del mes", etc., codificadas como vectores (por ejemplo, como características de Fourier). También pueden ser las llamadas características de "edad", que básicamente ayudan al modelo a saber "en qué punto de su vida" se encuentra una serie temporal. Las características de edad tienen valores pequeños para los pasos de tiempo del pasado lejano y aumentan de forma monótona a medida que nos acercamos al paso de tiempo actual. Las características de festivos también son un buen ejemplo de características temporales. Estas características sirven como las "codificaciones posicionales" de las entradas. Por lo tanto, a diferencia de un modelo como BERT, donde las codificaciones de posición se aprenden desde cero internamente como parámetros del modelo, el Time Series Transformer requiere proporcionar características temporales adicionales. El Time Series Transformer solo aprende incrustaciones adicionales para `static_categorical_features`. Se pueden concatenar covariables dinámicas reales adicionales a este tensor, con la salvedad de que estas características deben ser conocidas en el momento de la predicción. El `num_features` aquí es igual a `config.`num_time_features` + `config.num_dynamic_real_features`.

past_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)` o `(batch_size, sequence_length, input_size)`, *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).

static_categorical_features (`torch.LongTensor` de forma `(batch_size, number of static categorical features)`, *opcional*) : Características categóricas estáticas opcionales para las que el modelo aprenderá un embedding, que añadirá a los valores de la serie temporal. Las características categóricas estáticas son aquellas que tienen el mismo valor para todos los pasos de tiempo (estáticas en el tiempo). Un ejemplo típico de una característica categórica estática es un ID de serie temporal.

static_real_features (`torch.Tensor` de forma `(batch_size, number of static real features)`, *opcional*) : Características reales estáticas opcionales que el modelo añadirá a los valores de la serie temporal. Las características reales estáticas son aquellas que tienen el mismo valor para todos los pasos de tiempo (estáticas en el tiempo). Un ejemplo típico de una característica real estática es la información de promociones.

future_values (`torch.Tensor` de forma `(batch_size, prediction_length)` o `(batch_size, prediction_length, input_size)`, *opcional*) : Valores futuros 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 generar, dado `past_values`. La longitud de la secuencia aquí es igual a `prediction_length`. Consulte el cuaderno de demostración y los fragmentos de código para obtener más detalles. Opcionalmente, durante el entrenamiento, cualquier valor faltante debe reemplazarse con ceros e indicarse mediante `future_observed_mask`. Para series temporales multivariadas, se requiere la dimensión `input_size` > 1, que corresponde al número de variables en la serie temporal por paso de tiempo.

future_time_features (`torch.Tensor` de forma `(batch_size, prediction_length, num_features)`) : Características temporales requeridas para la ventana de predicción, que el modelo añadirá internamente a `future_values`. Estas pueden ser cosas como "mes del año", "día del mes", etc., codificadas como vectores (por ejemplo, como características de Fourier). También pueden ser las llamadas características de "edad", que básicamente ayudan al modelo a saber "en qué punto de su vida" se encuentra una serie temporal. Las características de edad tienen valores pequeños para los pasos de tiempo del pasado lejano y aumentan de forma monótona a medida que nos acercamos al paso de tiempo actual. Las características de festivos también son un buen ejemplo de características temporales. Estas características sirven como las "codificaciones posicionales" de las entradas. Por lo tanto, a diferencia de un modelo como BERT, donde las codificaciones de posición se aprenden desde cero internamente como parámetros del modelo, el Time Series Transformer requiere proporcionar características temporales adicionales. El Time Series Transformer solo aprende incrustaciones adicionales para `static_categorical_features`. Se pueden concatenar covariables dinámicas reales adicionales a este tensor, con la salvedad de que estas características deben ser conocidas en el momento de la predicción. El `num_features` aquí es igual a `config.num_time_features` + `config.num_dynamic_real_features`.

future_observed_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)` o `(batch_size, sequence_length, input_size)`, *opcional*) : Máscara booleana para indicar qué `future_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).  Esta máscara se utiliza para filtrar los valores faltantes en el cálculo final de la pérdida.

decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Máscara para evitar realizar atención en ciertos índices de tokens. De forma predeterminada, se utilizará una máscara causal para asegurarse de que el modelo solo pueda ver las entradas anteriores para predecir el futuro.

encoder_outputs (`tuple(tuple(torch.Tensor)`, *optional*) : La tupla consiste en `last_hidden_state`, `hidden_states` (*optional*) y `attentions` (*optional*) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)` (*optional*) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la cross-attention del decodificador.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

**Devuelve:** [Seq2SeqTSModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) o `tuple(torch.Tensor)`

Un [Seq2SeqTSModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.Seq2SeqTSModelOutput) 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 ([InformerConfig](/docs/transformers/main/es/model_doc/informer#transformers.InformerConfig)) y las entradas.

El método forward de [InformerForPrediction](/docs/transformers/main/es/model_doc/informer#transformers.InformerForPrediction) 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.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del decodificador del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_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 los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del decodificador en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto 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 codificador en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **loc** (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) -- Desplaza los valores de la ventana de contexto de cada serie temporal, lo que se utiliza para proporcionar al modelo entradas de la misma magnitud y luego se utiliza para desplazar de vuelta a la magnitud original.
- **scale** (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) -- Valores de escalado de la ventana de contexto de cada serie temporal, que se utilizan para proporcionar al modelo entradas de la misma magnitud y luego para reescalar de vuelta a la magnitud original.
- **static_features** (`torch.Tensor` de forma `(batch_size, feature size)`, *opcional*) -- Características estáticas de cada serie temporal en un lote que se copian en las covariables durante la inferencia.

Ejemplos:

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

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

>>> model = InformerForPrediction.from_pretrained(
...     "huggingface/informer-tourism-monthly"
... )

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

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

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

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