# xLSTM ## Resumen El modelo xLSTM fue propuesto en [xLSTM: Extended Long Short-Term Memory](https://huggingface.co/papers/2405.04517) por Maximilian Beck*, Korbinian Pöppel*, Markus Spanring, Andreas Auer, Oleksandra Prudnikova, Michael Kopp, Günter Klambauer, Johannes Brandstetter y Sepp Hochreiter. xLSTM actualiza la arquitectura original de LSTM para ser competitiva con los modelos Transformer mediante la introducción de un control exponencial, la expansión de la memoria matricial y un entrenamiento y una ingesta paralelizables. La variante [modelo 7B](https://huggingface.co/NX-AI/xLSTM-7b) fue entrenada por el equipo de xLSTM: Maximilian Beck, Korbinian Pöppel, Phillip Lippe, Richard Kurle, Patrick Blies, Sebastian Böck y Sepp Hochreiter, de NXAI. El resumen del artículo es el siguiente: *En la década de 1990, el carrusel de error constante y el gating se introdujeron como las ideas centrales de la memoria a largo y corto plazo (LSTM). Desde entonces, las LSTM han superado la prueba del tiempo y han contribuido a numerosos éxitos en el aprendizaje profundo; en particular, constituyeron los primeros modelos de lenguaje de gran escala (LLM). Sin embargo, el surgimiento de la tecnología Transformer, con su autoatención paralelizable como núcleo, marcó el alba de una nueva era, superando a las LSTM a gran escala. Ahora planteamos una pregunta sencilla: ¿Hasta dónde llegamos en el modelado de lenguaje al escalar las LSTM a miles de millones de parámetros, aprovechando las técnicas más recientes de los LLM modernos, pero mitigando las limitaciones conocidas de las LSTM? En primer lugar, introducimos un gating exponencial con técnicas adecuadas de normalización y estabilización. En segundo lugar, modificamos la estructura de memoria de la LSTM, obteniendo: (i) sLSTM con una memoria escalar, una actualización escalar y una nueva mezcla de memoria, (ii) mLSTM, que es totalmente paralelizable con una memoria matricial y una regla de actualización de covarianza. La integración de estas extensiones de LSTM en esqueletos de bloques residuales produce bloques xLSTM, que luego se apilan de forma residual en arquitecturas xLSTM. El gating exponencial y las estructuras de memoria modificadas potencian las capacidades de xLSTM para realizar un desempeño favorable en comparación con los Transformers y los modelos de espacio de estado más avanzados, tanto en rendimiento como en escalado.* Este modelo fue aportado por [NX-AI](https://huggingface.co/NX-AI). El código original se puede encontrar [aquí](https://github.com/NX-AI/xlstm). ## Notas - Use padding izquierdo para la generación por lotes. Consulte [Lado de relleno](../llm_tutorial#padding-side). ## xLSTMConfig[[transformers.xLSTMConfig]] #### transformers.xLSTMConfig[[transformers.xLSTMConfig]] ```python transformers.xLSTMConfig(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, vocab_size: int = 50304, hidden_size: int = 4096, embedding_dim: int | None = None, num_hidden_layers: int = 32, num_blocks: int | None = None, num_heads: int = 8, use_bias: bool = False, norm_reduction_force_float32: bool = True, tie_word_embeddings: bool = False, add_out_norm: bool = True, norm_eps: float = 1e-06, qk_dim_factor: float = 0.5, v_dim_factor: float = 1.0, chunkwise_kernel: typing.Literal['chunkwise--native_autograd', 'parallel--native_autograd'] = 'chunkwise--native_autograd', sequence_kernel: typing.Literal['native_sequence__native'] = 'native_sequence__native', step_kernel: typing.Literal['native'] = 'native', mode: typing.Literal['train', 'train_with_padding', 'inference'] = 'inference', chunk_size: int = 64, return_last_states: bool = True, autocast_kernel_dtype: typing.Literal['float32', 'bfloat16', 'float16'] = 'bfloat16', eps: float = 1e-06, inference_state_dtype: typing.Literal['float32', 'bfloat16', 'float16'] = 'float32', ffn_proj_factor: float = 2.667, ffn_round_up_to_multiple_of: int = 64, gate_soft_cap: float = 15.0, output_logit_soft_cap: float = 30.0, weight_mode: typing.Literal['single', 'fused'] = 'single', use_cache: bool = True, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, max_inference_chunksize: int = 16384) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/configuration_xlstm.py#L58) **Parámetros:** vocab_size (`int`, *opcional*, valor predeterminado `50304`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`. hidden_size (`int`, *opcional*, valor predeterminado `4096`) : Dimensión de las representaciones ocultas. embedding_dim (`int`, *opcional*) : Dimensionalidad de los embeddings y los estados ocultos. num_hidden_layers (`int`, *opcional*, valor predeterminado `32`) : Número de capas ocultas en el decodificador del Transformer. num_blocks (`int`, opcional, *optional*, valor predeterminado: 32) : Número de bloques del modelo xLSTM; si es None, se utiliza num_hidden_layers. num_heads (`int`, opcional, *optional*, valor predeterminado: 8) : Número de cabezas para la capa/celda xLSTM. use_bias (`bool`, opcional, *opcional*, valor predeterminado `False`) : Indica si se deben usar sesgos en el modelo xLSTM. norm_reduction_force_float32 (`bool`, opcional, *opcional*, valor predeterminado `True`) : Indica si se debe forzar que la operación de reducción de la norma en float32 se realice con precisión fp32. tie_word_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo. add_out_norm (`bool`, opcional, *opcional*, valor predeterminado `True`) : Si se debe añadir una normalización de salida después de los bloques y antes del LMHead. norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. qk_dim_factor (`float`, opcional, *opcional*, valor predeterminado 0.5) : Factor de escala para la dimensión de la consulta y la clave. v_dim_factor (`float`, opcional, *opcional*, valor predeterminado 1.0) : Factor de escala para la dimensión de valor. chunkwise_kernel (`ChunkwiseKernelType`, opcional, *opcional*, valor predeterminado `"chunkwise--native_autograd"`) : Tipo de kernel para el modo de procesamiento por bloques. sequence_kernel (`SequenceKernelType`, opcional, *optional*, valor predeterminado `"native_sequence__native"`) : Tipo de kernel para el modo de procesamiento de secuencias. step_kernel (`StepKernelType`, opcional, *optional*, valor predeterminado `"native"`) : Tipo de kernel para el modo de procesamiento por pasos. mode (`BackendModeType`, opcional, *opcional*, valor predeterminado `"inference"`) : Modo de operación (se necesita inferencia para la generación). chunk_size (`int`, opcional, *optional*, valor predeterminado: 64) : Tamaño de bloque interno. return_last_states (`bool`, opcional, *optional*, valor predeterminado `True`) : Si se deben devolver los últimos estados / caché internamente. Debe ser True para la generación. autocast_kernel_dtype (`DtypeType`, opcional, *optional*, valor predeterminado `"bfloat16"`) : Dtype del kernel para los estados. eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. inference_state_dtype (`DtypeType`, opcional, *optional*, valor predeterminado `"float32"`) : Dtype del kernel para los estados durante la inferencia. ffn_proj_factor (`float`, opcional, *opcional*, valor predeterminado 2.667) : Factor de tamaño de la red Feed Forward con puerta de proyección posterior al aumento. ffn_round_up_to_multiple_of (`int`, opcional, *optional*, valor predeterminado: 64) : Factor de tamaño del valor redondeado de la red Feed Forward con puerta de proyección posterior. gate_soft_cap (`float`, opcional, *opcional*, valor predeterminado 15.0) : Escala del límite suave de la compuerta. output_logit_soft_cap (`float`, opcional, *opcional*, valor predeterminado 30.0) : Escala de la limitación suave de los logits de salida. weight_mode (`Literal`, *opcional*, valor predeterminado `"single"`) : Indica si las capas lineales paralelas están separadas o fusionadas (single). 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. pad_token_id (`int`, *opcional*, valor predeterminado `1`) : Id de token utilizado para el relleno en el vocabulario. bos_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el inicio de la secuencia en el vocabulario. eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `2`) : Identificador de token utilizado para el fin de la secuencia en el vocabulario. max_inference_chunksize (`int`, opcional, *opcional*, valor predeterminado: 16384) : Limita el tamaño de los bloques para la inferencia y ahorrar memoria. Esta es la clase de configuración para almacenar la configuración de un xLSTMModel. Se utiliza para instanciar un modelo Xlstm 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 [NX-AI/xLSTM-7b](https://huggingface.co/NX-AI/xLSTM-7b) 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 xLSTMConfig, xLSTMModel >>> # Initializing a xLSTM configuration >>> configuration = xLSTMConfig() >>> # Initializing a model (with random weights) from the configuration >>> model = xLSTMModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## xLSTMModel[[transformers.xLSTMModel]] #### transformers.xLSTMModel[[transformers.xLSTMModel]] ```python transformers.xLSTMModel(config: xLSTMConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1394) **Parámetros:** config ([xLSTMConfig](/docs/transformers/main/es/model_doc/xlstm#transformers.xLSTMConfig)) : 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 Xlstm sin procesar que genera 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.xLSTMModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, cache_params: transformers.models.xlstm.modeling_xlstm.xLSTMCache | None = None, use_cache: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1411) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) inputs_embeds (`torch.LongTensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. cache_params (`xLSTMCache`, *opcional*) : El xLSTMCache que transporta los estados del RNN. 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:** `xLSTMOutput` o `tuple(torch.Tensor)` Un `xLSTMOutput` 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 ([xLSTMConfig](/docs/transformers/main/es/model_doc/xlstm#transformers.xLSTMConfig)) y las entradas. El método forward de [xLSTMModel](/docs/transformers/main/es/model_doc/xlstm#transformers.xLSTMModel) 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)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **cache_params** (`~models.xlstm.modeling_xlstm.xLSTMCache`, *opcional*) -- El estado del modelo en el último paso de tiempo. Puede usarse en un método forward con los siguientes `input_ids` para evitar proporcionar los `input_ids` anteriores. - **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. ## xLSTMLMHeadModel[[transformers.xLSTMForCausalLM]] #### transformers.xLSTMForCausalLM[[transformers.xLSTMForCausalLM]] ```python transformers.xLSTMForCausalLM(config: xLSTMConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1517) **Parámetros:** config ([xLSTMConfig](/docs/transformers/main/es/model_doc/xlstm#transformers.xLSTMConfig)) : 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 Xlstm para el modelado causal de lenguaje. 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.xLSTMForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, cache_params: transformers.models.xlstm.modeling_xlstm.xLSTMCache | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlstm/modeling_xlstm.py#L1537) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. cache_params (`xLSTMCache`, *opcional*) : El xLSTMCache que transporta los estados del RNN. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`. 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:** `xLSTMCausalLMOutput` o `tuple(torch.Tensor)` Un `xLSTMCausalLMOutput` 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 ([xLSTMConfig](/docs/transformers/main/es/model_doc/xlstm#transformers.xLSTMConfig)) y las entradas. El método forward de [xLSTMForCausalLM](/docs/transformers/main/es/model_doc/xlstm#transformers.xLSTMForCausalLM) 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** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax). - **cache_params** (`xLSTMCache`, *opcional*, que contiene los estados del RNN) -- El estado del modelo en el último paso de tiempo. Puede utilizarse en un método de propagación hacia adelante junto con los siguientes `input_ids` para evitar proporcionar los `input_ids` anteriores. - **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. Ejemplo: ```python ```