# Reformer

## Resumen

El modelo Reformer fue propuesto en el artículo [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451) de Nikita Kitaev, Łukasz Kaiser y Anselm Levskaya.

El resumen del artículo es el siguiente:

*Los modelos Transformer de gran tamaño alcanzan rutinariamente resultados de última generación en una serie de tareas, pero el entrenamiento de estos modelos puede ser prohibitivamente costoso, especialmente en secuencias largas. Presentamos dos técnicas para mejorar la eficiencia de los Transformers. Por un lado, reemplazamos la atención de producto punto por una que utiliza hashing sensible a la localidad, cambiando su complejidad de O(L^2) a O(Llog(L)), donde L es la longitud de la secuencia. Además, utilizamos capas residuales reversibles en lugar de las residuales estándar, lo que permite almacenar las activaciones solo una vez en el proceso de entrenamiento en lugar de N veces, donde N es el número de capas. El modelo resultante, el Reformer, rinde a la par de los modelos Transformer, pero es mucho más eficiente en memoria y mucho más rápido en secuencias largas.*

Este modelo fue aportado por [patrickvonplaten](https://huggingface.co/patrickvonplaten). El código de los autores se puede encontrar [aquí](https://github.com/google/trax/tree/master/trax/models/reformer).

## Consejos de uso

- Reformer **no** funciona con *torch.nn.DataParallel* debido a un error en PyTorch, consulte [issue #36035](https://github.com/pytorch/pytorch/issues/36035).
- Use la codificación de posición axial (consulte más detalles a continuación). Es un mecanismo para evitar tener una matriz de codificación de posición enorme (cuando la longitud de la secuencia es muy grande) factorizándola en matrices más pequeñas.
- Reemplace la atención tradicional por la atención LSH (local-sensitive hashing) (consulte a continuación para obtener más detalles). Es una técnica para evitar el cálculo del producto completo query-key en las capas de atención.
- Evite almacenar los resultados intermedios de cada capa utilizando capas de transformador reversibles para obtenerlos durante la pasada hacia atrás (restar los residuos de la entrada de la capa siguiente los recupera) o recálculándolos para los resultados dentro de una capa dada (menos eficiente que almacenarlos, pero ahorra memoria).
- Calcule las operaciones de red feedforward por lotes y no en el lote completo.

### Codificaciones posicionales axiales

Los codificados posicionales axiales se implementaron por primera vez en la [biblioteca trax](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29) de Google y fueron desarrollados por los autores del artículo de este modelo. En los modelos que tratan secuencias de entrada muy largas, los codificados de id de posición convencionales almacenan un vector de embeddings de tamaño $d$, que es `config.hidden_size`, para cada posición $i, \ldots, n_s$, donde $n_s$ es `config.max_embedding_size`. Esto significa que tener una longitud de secuencia de $n_s = 2^{19} \approx 0.5M$ y un `config.hidden_size` de $d = 2^{10} \approx 1000$ resultaría en una matriz de codificación posicional:

$$X_{i,j}, \text{ con } i \in \left[1,\ldots, d\right] \text{ y } j \in \left[1,\ldots, n_s\right]$$

que por sí solo tiene más de 500M de parámetros que almacenar. Las codificaciones posicionales axiales factorizan $X_{i,j}$ en dos matrices:

$$X^{1}_{i,j}, \text{ con } i \in \left[1,\ldots, d^1\right] \text{ y } j \in \left[1,\ldots, n_s^1\right]$$

y

$$X^{2}_{i,j}, \text{ con } i \in \left[1,\ldots, d^2\right] \text{ y } j \in \left[1,\ldots, n_s^2\right]$$

con:

$$d = d^1 + d^2 \text{ y } n_s = n_s^1 \times n_s^2 .$$

Por lo tanto, se cumple lo siguiente:

$$X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{si }\ i < d^1 \text{ con } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{si } i \ge d^1 \text{ con } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}$$

Intuitivamente, esto significa que un vector de incrustación de posición $x_j \in \mathbb{R}^{d}$ es ahora la composición de dos vectores de incrustación factorizados: $x^1_{k, l} + x^2_{l, k}$, donde la dimensión $j$ de `config.max_embedding_size` se factoriza en $k \text{ y } l$. Este diseño garantiza que cada vector de incrustación de posición $x_j$ sea único.

Usando de nuevo el ejemplo anterior, la codificación de posición axial con $d^1 = 2^9, d^2 = 2^9, n_s^1 = 2^9, n_s^2 = 2^{10}$ puede reducir drásticamente el número de parámetros de 500 000 000 a $2^{18} + 2^{19} \approx 780 000$ parámetros, lo que significa un 85% menos de uso de memoria.

En la práctica, el parámetro `config.axial_pos_embds_dim` se establece como una tupla $(d^1, d^2)$ cuya suma debe ser igual a `config.hidden_size` y `config.axial_pos_shape` se establece como una tupla $(n_s^1, n_s^2)$ cuyo producto debe ser igual a `config.max_embedding_size`, que durante el entrenamiento debe ser igual a la *longitud de la secuencia* de `input_ids`.

### LSH Self Attention

En la autoatención con hashing sensible a la localidad (LSH), los pesos de proyección de las claves y las consultas están vinculados. Por lo tanto, los vectores de incrustación de clave y consulta también están vinculados. La autoatención LSH utiliza el mecanismo de hashing sensible a la localidad propuesto en [Practical and Optimal LSH for Angular Distance](https://huggingface.co/papers/1509.02897) para asignar cada uno de los vectores de incrustación de clave y consulta vinculados a uno de los `config.num_buckets` cubos posibles. La premisa es que cuanto más "similares" sean entre sí los vectores de incrustación de clave y consulta (en términos de *similitud coseno*), más probable es que se asignen al mismo cubo.

La precisión del mecanismo LSH puede mejorarse aumentando `config.num_hashes` o directamente el argumento `num_hashes` de la función forward, de modo que la salida de la autoatención LSH aproxime mejor la salida de la autoatención completa "normal". A continuación, los buckets se ordenan y se dividen en fragmentos de vectores de incrustación de query y key, cada uno de longitud `config.lsh_chunk_length`. Para cada fragmento, los vectores de incrustación de query atienden a sus vectores de key (que están vinculados a sí mismos) y a los vectores de incrustación de key de `config.lsh_num_chunks_before` fragmentos vecinos anteriores y `config.lsh_num_chunks_after` fragmentos vecinos posteriores.

Para obtener más información, consulte el [artículo original](https://huggingface.co/papers/2001.04451) o esta gran [entrada de blog](https://www.pragmatic.ml/reformer-deep-dive/).

Tenga en cuenta que `config.num_buckets` también se puede factorizar en una lista $(n_{\text{buckets}}^1, n_{\text{buckets}}^2)). De esta manera, en lugar de asignar los vectores de incrustación de la clave de consulta a uno de $(1,\ldots, n_{\text{buckets}})$, se asignan a uno de $(1-1,\ldots, n_{\text{buckets}}^1-1, \ldots, 1-n_{\text{buckets}}^2, \ldots, n_{\text{buckets}}^1-n_{\text{buckets}}^2)$. Esto es crucial para secuencias muy largas para ahorrar memoria.

Al entrenar un modelo desde cero, se recomienda dejar `config.num_buckets=None`, de modo que, en función de la longitud de la secuencia, se calcule sobre la marcha un buen valor para `num_buckets`. Este valor se guardará automáticamente en la configuración y debe reutilizarse para la inferencia.

Al utilizar la autoatención LSH, la complejidad de memoria y tiempo de la operación de multiplicación de matrices query-key puede reducirse de $\mathcal{O}(n_s \times n_s)$ a $\mathcal{O}(n_s \times \log(n_s))$, lo que generalmente representa el cuello de botella de memoria y tiempo en un modelo transformer, donde $n_s$ es la longitud de la secuencia.

### Atención local

La autoatención local es esencialmente una capa de autoatención "normal" con proyecciones de clave, consulta y valor, pero se divide en fragmentos de modo que, en cada fragmento de longitud `config.local_chunk_length`, los vectores de incrustación de consulta solo atienden a los vectores de incrustación de clave de su propio fragmento y a los vectores de incrustación de clave de `config.local_num_chunks_before` fragmentos vecinos anteriores y `config.local_num_chunks_after` fragmentos vecinos posteriores.

Al utilizar Local self attention, la complejidad de memoria y tiempo de la operación de multiplicación de matrices query-key puede reducirse de $\mathcal{O}(n_s \times n_s)$ a $\mathcal{O}(n_s \times \log(n_s))$, lo que suele representar el cuello de botella de memoria y tiempo en un modelo transformer, donde $n_s$ es la longitud de la secuencia.

### Entrenamiento

Durante el entrenamiento, debemos asegurarnos de que la longitud de la secuencia se establezca en un valor divisible por el mínimo común múltiplo de `config.lsh_chunk_length` y `config.local_chunk_length`, y de que los parámetros de las codificaciones posicionales axiales se configuren correctamente, tal como se describió anteriormente. Reformer es muy eficiente en memoria, por lo que el modelo puede entrenarse fácilmente en secuencias de hasta 64000 tokens.

Para el entrenamiento, se debe utilizar [ReformerModelWithLMHead](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerModelWithLMHead) de la siguiente manera:

```python
input_ids = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device)
loss = model(input_ids, labels=input_ids)[0]
```

## Recursos

- [Guía de la tarea de clasificación de texto](../tasks/sequence_classification)
- [Guía de la tarea de respuesta a preguntas](../tasks/question_answering)
- [Guía de la tarea de modelado de lenguaje causal](../tasks/language_modeling)
- [Guía de la tarea de modelado de lenguaje enmascarado](../tasks/masked_language_modeling)

## ReformerConfig[[transformers.ReformerConfig]]

#### transformers.ReformerConfig[[transformers.ReformerConfig]]

```python
transformers.ReformerConfig(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, attention_head_size: int = 64, attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh'), axial_norm_std: float = 1.0, axial_pos_embds: bool = True, axial_pos_shape: list[int] | tuple[int, ...] = (64, 64), axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192), chunk_size_lm_head: int = 0, eos_token_id: int | list[int] | None = 2, feed_forward_size: int = 512, hash_seed: int | None = None, hidden_act: str = 'relu', hidden_dropout_prob: float | int = 0.05, hidden_size: int = 256, initializer_range: float = 0.02, is_decoder: bool = False, layer_norm_eps: float = 1e-12, local_num_chunks_before: int = 1, local_num_chunks_after: int = 0, local_attention_probs_dropout_prob: float | int = 0.05, local_attn_chunk_length: int = 64, lsh_attn_chunk_length: int | None = 64, lsh_attention_probs_dropout_prob: float | None = 0.0, lsh_num_chunks_before: int | None = 1, lsh_num_chunks_after: int | None = 0, max_position_embeddings: int = 4096, num_attention_heads: int = 12, num_buckets: int | list[int] | None = None, num_hashes: int = 1, vocab_size: int = 320, tie_word_embeddings: bool = False, use_cache: bool = True, classifier_dropout: float | int | None = None, bos_token_id: int | None = None, pad_token_id: int | None = 0)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/configuration_reformer.py#L25)

**Parámetros:**

attention_head_size (`int`, *opcional*, valor predeterminado 64) : Dimensionalidad de los vectores de clave, consulta y valor proyectados

attn_layers (`list[str]`, *opcional*, valor predeterminado `["local", "lsh", "local", "lsh", "local", "lsh"]`) : Lista de tipos de capas de atención en orden ascendente. Puede elegirse entre una capa LSHSelfAttention (`"lsh"`) y una capa LocalSelfAttention (`"local"`). Para obtener más información sobre la capa LSHSelfAttention, consulte [LSH Self Attention](reformer#lsh-self-attention). Para obtener más información sobre la capa LocalSelfAttention, consulte [Local Self Attention](reformer#local-self-attention).

axial_norm_std (`float`, *opcional*, valor predeterminado 1.0) : La desviación estándar de normal_initializer para inicializar las matrices de pesos de las codificaciones posicionales axiales.

axial_pos_embds (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben usar o no embeddings de posición axial. Para obtener más información sobre cómo funcionan los embeddings de posición axial, consulte [Axial Position Encodings](reformer#axial-positional-encodings).

axial_pos_shape (`list[int]`, *opcional*, valor predeterminado `[64, 64]`) : Las dimensiones de posición de las codificaciones de posición axiales. Durante el entrenamiento, el producto de las dimensiones de posición debe ser igual a la longitud de la secuencia. Para obtener más información sobre cómo funcionan las incrustaciones de posición axiales, consulte [Axial Position Encodings](reformer#axial-positional-encodings).

axial_pos_embds_dim (`list[int]`, *opcional*, valor predeterminado `[64, 192]`) : Las dimensiones de incrustación de las codificaciones de posición axial. La suma de las dimensiones de incrustación debe ser igual al tamaño oculto. Para obtener más información sobre cómo funcionan las incrustaciones de posición axial, consulte [Axial Position Encodings](reformer#axial-positional-encodings).

chunk_size_lm_head (`int`, *opcional*, valor predeterminado 0) : El tamaño de bloque de la capa final de feed forward del modelo de lenguaje. Un tamaño de bloque de 0 significa que la capa de feed forward no se divide en bloques. Un tamaño de bloque de n significa que la capa de feed forward procesa n < sequence_length embeddings a la vez. Para obtener más información sobre la división en bloques de feed forward, consulte [¿Cómo funciona la división en bloques de feed forward?](../glossary#feed-forward-chunking).

eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `2`) : Identificador de token utilizado para el fin de la secuencia en el vocabulario.

feed_forward_size (`int`, *opcional*, valor predeterminado 512) : Dimensionalidad de la capa feed_forward en el bloque de atención residual.

hash_seed (`int`, *opcional*) : Semilla que se puede usar para hacer que el hash sensible local en `LSHSelfAttention` sea determinista. Esto solo debe configurarse con fines de prueba. Para fines de evaluación y entrenamiento, `hash_seed` debe dejarse como `None` para garantizar rotaciones completamente aleatorias en el esquema de hash sensible local.

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

hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.05`) : La probabilidad de dropout para todas las capas totalmente conectadas en las incrustaciones, el codificador y el pooler.

hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas.

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

is_decoder (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo se utiliza como decodificador. Si es `False`, el modelo se utiliza como codificador.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-12`) : El epsilon utilizado por las capas de normalización de capas.

local_num_chunks_before (`int`, *opcional*, valor predeterminado: 1) : Número de bloques vecinos anteriores a los que debe prestar atención la capa `LocalSelfAttention` a sí misma.

local_num_chunks_after (`int`, *opcional*, valor predeterminado 0) : Número de bloques vecinos siguientes a los que prestar atención en la capa `LocalSelfAttention`, además de sí mismo.

local_attention_probs_dropout_prob (`float`, *opcional*, valor predeterminado 0.1) : La proporción de dropout para las probabilidades de atención en `LocalSelfAttention`.

local_attn_chunk_length (`int`, *opcional*, valor predeterminado 64) : Longitud de cada bloque en las capas de atención local.

lsh_attn_chunk_length (`int`, *opcional*, valor predeterminado 64) : Longitud del fragmento que atiende a sí mismo en `LSHSelfAttention`. El fragmentado reduce la complejidad de memoria de longitud de secuencia x longitud de secuencia (autoatención) a longitud de fragmento x longitud de fragmento x longitud de secuencia / longitud de fragmento (autoatención por fragmentos).

lsh_attention_probs_dropout_prob (`float`, *opcional*, valor predeterminado 0.1) : La proporción de dropout para las probabilidades de atención en `LSHSelfAttention`.

lsh_num_chunks_before (`int`, *opcional*, valor predeterminado 1) : Número de bloques vecinos anteriores a los que debe prestar atención la capa `LSHSelfAttention` a sí misma.

lsh_num_chunks_after (`int`, *opcional*, valor predeterminado 0) : Número de bloques vecinos siguientes a los que debe prestar atención la capa `LSHSelfAttention` a sí misma.

max_position_embeddings (`int`, *opcional*, valor predeterminado `4096`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

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

num_buckets (`int` o `list[int]`, *opcional*) : Número de cubos en los que los vectores de consulta clave pueden ser "hasheados" mediante el esquema de hashing sensible a la localidad. Cada vector de consulta clave se hashea en un hash de `1, ..., num_buckets`. El número de cubos también puede factorizarse en una lista para mejorar la complejidad de memoria. En este caso, cada vector de consulta clave se hashea en un hash de `1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1]` si `num_buckets` se factoriza en dos factores. El número de cubos (o el producto de los factores) debe ser aproximadamente igual a longitud de la secuencia / lsh_chunk_length. Si `num_buckets` no se establece, se calcula un buen valor sobre la marcha.

num_hashes (`int`, *opcional*, valor predeterminado 1) : Número de rondas de hashing (p. ej., número de rotaciones aleatorias) en el esquema de Local Sensitive Hashing. A mayor `num_hashes`, más precisa se vuelve la `LSHSelfAttention`, pero también más intensivo en memoria y tiempo se vuelve el hashing.

vocab_size (`int`, *opcional*, valor predeterminado `320`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

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.

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.

classifier_dropout (`Union[float, int]`, *opcional*) : La proporción de dropout para el clasificador.

bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

pad_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el relleno en el vocabulario.

Esta es la clase de configuración para almacenar la configuración de un ReformerModel. Se utiliza para instanciar un modelo Reformer 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 [google/reformer-crime-and-punishment](https://huggingface.co/google/reformer-crime-and-punishment)

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.

Ejemplos:

```python
>>> from transformers import ReformerConfig, ReformerModel

>>> # Initializing a Reformer configuration
>>> configuration = ReformerConfig()

>>> # Initializing a Reformer model (with random weights)
>>> model = ReformerModel(configuration)

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

## ReformerTokenizer[[transformers.ReformerTokenizer]]

#### transformers.ReformerTokenizer[[transformers.ReformerTokenizer]]

```python
transformers.ReformerTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, eos_token: str = '</s>', unk_token: str = '<unk>', _spm_precompiled_charsmap: str | None = None, additional_special_tokens: list | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/tokenization_reformer.py#L31)

**Parámetros:**

vocab_file (`str`) : archivo [SentencePiece](https://github.com/google/sentencepiece) (generalmente con extensión *.spm*) que contiene el vocabulario necesario para instanciar un tokenizador.

eos_token (`str`, *opcional*, valor predeterminado `"</s>"`) : El token de fin de secuencia. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el fin de secuencia. El token que se utiliza es `sep_token`.

unk_token (`str`, *opcional*, valor predeterminado `"<unk>"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

pad_token (`str`, *opcional*, valor predeterminado `"<pad>"`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.

additional_special_tokens (`list[str]`, *opcional*) : Tokens especiales adicionales utilizados por el tokenizador.

vocab (`str` o `dict[str, int]`, *opcional*) : Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desde `vocab_file`.

merges (`str` o `list[str]`, *opcional*) : Lista de fusiones personalizada. Si no se proporciona, las fusiones se cargan desde `vocab_file`.

Construye un tokenizador Reformer (respaldado por la biblioteca tokenizers de HuggingFace). Basado en [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models).

Este tokenizador hereda de [TokenizersBackend](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### save_vocabulary[[transformers.ReformerTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## ReformerModel[[transformers.ReformerModel]]

#### transformers.ReformerModel[[transformers.ReformerModel]]

```python
transformers.ReformerModel(config: ReformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L1931)

**Parámetros:**

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

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

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

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

#### forward[[transformers.ReformerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L1951)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Durante el entrenamiento, la sequence_length de input_ids debe ser un múltiplo de las longitudes de bloque relevantes del modelo (lsh's, local's o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud de bloque. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-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.

num_hashes (`int`, *opcional*) : El número de rondas de hashing que se deben realizar durante el bucketing. Establecer este argumento sobrescribe el valor predeterminado definido en `config.num_hashes`. Para obtener más información, consulte `num_hashes` en [ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig).

past_buckets_states (`ReformerDynamicCache`, *opcional*) : Lista de `tuple(torch.LongTensor, torch.Tensor` de longitud `config.n_layers`, donde el primer elemento son los *buckets* anteriores de forma `(batch_size, num_heads, num_hashes, sequence_length)`) y el segundo son los *hidden_states* anteriores de forma `(batch_size, sequence_length, hidden_size)`). Contiene hidden-states y buckets precalculados (solo relevante para LSH Self-Attention). Se puede usar para acelerar la decodificación secuencial.

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

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

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

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

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

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

El método forward de [ReformerModel](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerModel) 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, num_predict, hidden_size)`) -- Secuencia de estados ocultos en la última capa del modelo.

  `num_predict` corresponde a `target_mapping.shape[1]`. Si `target_mapping` es `None`, entonces `num_predict` corresponde a `sequence_length`.
- **past_buckets_states** (`list[tuple(torch.LongTensor, torch.Tensor)]`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Lista de `tuple(torch.LongTensor, torch.Tensor` de longitud `config.n_layers`, donde el primer elemento son los *buckets* anteriores de forma `(batch_size, num_heads, num_hashes, sequence_length)`) y el segundo son los *hidden_states* anteriores de forma `(batch_size, sequence_length, hidden_size)`).

  Contiene cubos y estados ocultos precalculados que se pueden utilizar (consulte la entrada `past_buckets_states`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

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

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

## ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

#### transformers.ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

```python
transformers.ReformerModelWithLMHead(config: ReformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2150)

**Parámetros:**

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

Modelo Reformer con una cabeza de `language modeling` en la parte superior.

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

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

#### forward[[transformers.ReformerModelWithLMHead.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: list[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2176)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Durante el entrenamiento, la sequence_length de input_ids debe ser un múltiplo de las longitudes de bloque relevantes del modelo (lsh's, local's o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud de bloque. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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.

num_hashes (`int`, *opcional*) : El número de rondas de hashing que se deben realizar durante el bucketing. Establecer este argumento sobrescribe el valor predeterminado definido en `config.num_hashes`. Para obtener más información, consulte `num_hashes` en [ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig).

past_buckets_states (`list[tuple(torch.LongTensor, torch.Tensor)]`, *opcional*) : Lista de `tuple(torch.LongTensor, torch.Tensor` de longitud `config.n_layers`, donde el primer elemento son los *buckets* anteriores de forma `(batch_size, num_heads, num_hashes, sequence_length)`) y el segundo son los *hidden_states* anteriores de forma `(batch_size, sequence_length, hidden_size)`). Contiene hidden-states y buckets precalculados (solo relevante para LSH Self-Attention). Se puede usar para acelerar la decodificación secuencial.

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

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

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

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

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[-100, 0, ..., config.vocab_size - 1]`. Todas las etiquetas establecidas en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para las etiquetas en `[0, ..., config.vocab_size]`

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, valor predeterminado `0`) : Si es un `int`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un `torch.Tensor`, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).

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

Un [CausalLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutput) 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 ([ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig)) y las entradas.

El método forward de [ReformerModelWithLMHead](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerModelWithLMHead) 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** (`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).
- **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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Ejemplo:

```python
>>> import torch
>>> from transformers import AutoTokenizer, ReformerModelWithLMHead

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerModelWithLMHead.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

#### transformers.ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

```python
transformers.ReformerForMaskedLM(config: ReformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2287)

**Parámetros:**

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

El modelo Reformer con una cabeza de `language modeling` en la parte superior."

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

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

#### forward[[transformers.ReformerForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2307)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Durante el entrenamiento, la sequence_length de input_ids debe ser un múltiplo de las longitudes de bloque relevantes del modelo (lsh's, local's o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud de bloque. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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.

num_hashes (`int`, *opcional*) : El número de rondas de hashing que se deben realizar durante el bucketing. Establecer este argumento sobrescribe el valor predeterminado definido en `config.num_hashes`. Para obtener más información, consulte `num_hashes` en [ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig).

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 `[-100, 0, ..., config.vocab_size]` (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas. Este ejemplo utiliza un punto de control falso, ya que no hay ningún modelo preentrenado disponible para la tarea de modelado de lenguaje enmascarado con la arquitectura Reformer.

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

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

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

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

Un [MaskedLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 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 ([ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig)) y las entradas.

El método forward de [ReformerForMaskedLM](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerForMaskedLM) 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** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje enmascarado (MLM).
- **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).
- **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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Ejemplo:

```python
>>> import torch
>>> from transformers import AutoTokenizer, ReformerForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-reformer")
>>> model = ReformerForMaskedLM.from_pretrained("hf-internal-testing/tiny-random-reformer")

>>> # add mask_token
>>> tokenizer.add_special_tokens({"mask_token": "[MASK]"})
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> # resize model's embedding matrix
>>> model.resize_token_embeddings(new_num_tokens=model.config.vocab_size + 1)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> predicted_token = tokenizer.decode(predicted_token_id)
```

```python
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(
...     inputs.input_ids == tokenizer.mask_token_id, labels[:, : inputs["input_ids"].shape[-1]], -100
... )

>>> outputs = model(**inputs, labels=labels)
>>> loss = round(outputs.loss.item(), 2)
```

## ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

#### transformers.ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

```python
transformers.ReformerForSequenceClassification(config: ReformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2425)

**Parámetros:**

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

Modelo Reformer transformer con una cabeza de clasificación/regresión de secuencia en la parte superior (una capa lineal sobre la salida agrupada), por ejemplo, para tareas GLUE.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2439)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Durante el entrenamiento, la sequence_length de input_ids debe ser un múltiplo de las longitudes de bloque relevantes del modelo (lsh's, local's o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud de bloque. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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.

num_hashes (`int`, *opcional*) : El número de rondas de hashing que se deben realizar durante el bucketing. Establecer este argumento sobrescribe el valor predeterminado definido en `config.num_hashes`. Para obtener más información, consulte `num_hashes` en [ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig).

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1` se calcula una pérdida de regresión (pérdida de error cuadrático medio), si `config.num_labels > 1` se calcula una pérdida de clasificación (entropía cruzada).

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

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

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

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

Un [SequenceClassifierOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 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 ([ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig)) y las entradas.

El método forward de [ReformerForSequenceClassification](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerForSequenceClassification) 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** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de clasificación (o de regresión si config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de 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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Ejemplo de clasificación de una sola etiqueta:

```python
>>> import torch
>>> from transformers import AutoTokenizer, ReformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> label = model.config.id2label[predicted_class_id]
```

```python
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
```

## ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

#### transformers.ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

```python
transformers.ReformerForQuestionAnswering(config: ReformerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2572)

**Parámetros:**

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

El transformador Reformer con una cabeza de clasificación de tramos en la parte superior para tareas de respuesta a preguntas extractivas como SQuAD (una capa lineal sobre la salida de los estados ocultos para calcular `span start logits` y `span end logits`).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/reformer/modeling_reformer.py#L2584)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Durante el entrenamiento, la sequence_length de input_ids debe ser un múltiplo de las longitudes de bloque relevantes del modelo (lsh's, local's o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud de bloque. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

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.

num_hashes (`int`, *opcional*) : El número de rondas de hashing que se deben realizar durante el bucketing. Establecer este argumento sobrescribe el valor predeterminado definido en `config.num_hashes`. Para obtener más información, consulte `num_hashes` en [ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig).

start_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para la posición (índice) del inicio del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (`sequence_length`). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida.

end_positions (`torch.Tensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para la posición (índice) del final del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (`sequence_length`). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular 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.

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

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

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

Un [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 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 ([ReformerConfig](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerConfig)) y las entradas.

El método forward de [ReformerForQuestionAnswering](/docs/transformers/v5.23.0/es/model_doc/reformer#transformers.ReformerForQuestionAnswering) 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`) -- La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin.
- **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Puntuaciones de inicio de tramo (antes de SoftMax).
- **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Puntuaciones de fin de tramo (antes de SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de 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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Ejemplo:

```python
>>> from transformers import AutoTokenizer, ReformerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```