Hugging Face's logo

Transformers documentation

Reformer

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 13-01-2020 y se contribuyó a Hugging Face Transformers el 16-11-2020.

Reformer

Resumen

El modelo Reformer fue propuesto en el artículo Reformer: The Efficient Transformer 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. Introducimos 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, siendo mucho más eficiente en memoria y mucho más rápido en secuencias largas.

Este modelo fue aportado por patrickvonplaten. El código de los autores se puede encontrar aquí.

Consejos de uso

  • Reformer no funciona con torch.nn.DataParallel debido a un error en PyTorch, consulte issue #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) (vea más detalles a continuación). 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 de Google y fueron desarrollados por los autores del artículo de este modelo. En modelos que tratan secuencias de entrada muy largas, los codificados de id de posición convencionales almacenan un vector de embeddings de tamaño dd siendo config.hidden_size para cada posición $i, \ldots, n_s$, con nsn_s siendo config.max_embedding_size. Esto significa que tener una longitud de secuencia de ns=219≈0.5Mn_s = 2^{19} \approx 0.5M y un config.hidden_size de d=210≈1000d = 2^{10} \approx 1000 daría como resultado una matriz de codificación de posición: Xi,j, with i∈[1,…,d] and j∈[1,…,ns]X_{i,j}, \text{ with } i \in \left[1,\ldots, d\right] \text{ and } j \in \left[1,\ldots, n_s\right]

que por sí solo tiene más de 500M parámetros para almacenar. Las codificaciones posicionales axiales factorizan Xi,jX_{i,j} en dos matrices: Xi,j1, with i∈[1,…,d1] and j∈[1,…,ns1]X^{1}_{i,j}, \text{ with } i \in \left[1,\ldots, d^1\right] \text{ and } j \in \left[1,\ldots, n_s^1\right]

y Xi,j2, with i∈[1,…,d2] and j∈[1,…,ns2]X^{2}_{i,j}, \text{ with } i \in \left[1,\ldots, d^2\right] \text{ and } j \in \left[1,\ldots, n_s^2\right]

con: d=d1+d2 and ns=ns1×ns2.d = d^1 + d^2 \text{ and } n_s = n_s^1 \times n_s^2 .

Por lo tanto, se cumple lo siguiente: Xi,j={Xi,k1,if  i<d1 with k=jmod  ns1Xi−d1,l2,if i≥d1 with l=⌊jns1⌋X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{if }\ i < d^1 \text{ with } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{if } i \ge d^1 \text{ with } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}

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

Usando el ejemplo anterior, la codificación de posición axial con d1=29,d2=29,ns1=29,ns2=210d^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 218+219≈7800002^{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 (d1,d2)(d^1, d^2) cuya suma debe ser igual a config.hidden_size y config.axial_pos_shape se establece como una tupla (ns1,ns2)(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 los input_ids.

LSH Self Attention

En la autoatención con hashing sensible a la localidad (LSH), los pesos de proyección de la clave y la consulta 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 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 cosine similarity), 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 consulta y clave, cada uno de longitud config.lsh_chunk_length. Para cada fragmento, los vectores de incrustación de consulta atienden a sus vectores de clave (que están vinculados a sí mismos) y a los vectores de incrustación de clave 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 o esta gran entrada de blog.

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 las claves 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, dependiendo 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 usar la autoatención LSH, la complejidad de memoria y tiempo de la operación de multiplicación de matrices query-key puede reducirse de O(ns×ns)\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, con nsn_s siendo 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 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 usar Local self attention, la complejidad de memoria y tiempo de la operación de multiplicación de matrices query-key puede reducirse de O(ns×ns)\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, con nsn_s siendo 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, 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 de la siguiente manera:

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

ReformerConfig

clase transformers.ReformerConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneattention_head_size: int = 64attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh')axial_norm_std: float = 1.0axial_pos_embds: bool = Trueaxial_pos_shape: list[int] | tuple[int, ...] = (64, 64)axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192)chunk_size_lm_head: int = 0eos_token_id: int | list[int] | None = 2feed_forward_size: int = 512hash_seed: int | None = Nonehidden_act: str = 'relu'hidden_dropout_prob: float | int = 0.05hidden_size: int = 256initializer_range: float = 0.02is_decoder: bool = Falselayer_norm_eps: float = 1e-12local_num_chunks_before: int = 1local_num_chunks_after: int = 0local_attention_probs_dropout_prob: float | int = 0.05local_attn_chunk_length: int = 64lsh_attn_chunk_length: int | None = 64lsh_attention_probs_dropout_prob: float | None = 0.0lsh_num_chunks_before: int | None = 1lsh_num_chunks_after: int | None = 0max_position_embeddings: int = 4096num_attention_heads: int = 12num_buckets: int | list[int] | None = Nonenum_hashes: int = 1vocab_size: int = 320tie_word_embeddings: bool = Falseuse_cache: bool = Trueclassifier_dropout: float | int | None = Nonebos_token_id: int | None = Nonepad_token_id: int | None = 0 )

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. Para obtener más información sobre la capa LocalSelfAttention, consulte 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.
  • 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.
  • axial_pos_embds_dim (list[int], opcional, valor predeterminado [64, 192]) — Las dimensiones de los embeddings de las codificaciones de posición axial. La suma de las dimensiones de los embeddings debe ser igual al tamaño oculto. Para obtener más información sobre cómo funcionan los embeddings de posición axial, consulte Codificaciones de posición axial.
  • chunk_size_lm_head (int, opcional, valor predeterminado 0) — El tamaño de bloque de la capa final de la red neuronal feed forward de la cabeza del modelo de lenguaje. Un tamaño de bloque de 0 significa que la capa feed forward no se divide en bloques. Un tamaño de bloque de n significa que la capa feed forward procesa n < sequence_length embeddings a la vez. Para obtener más información sobre la división en bloques de la red feed forward, consulte ¿Cómo funciona la división en bloques de la red feed forward?.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 2) — Identificador de token utilizado para el fin de 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 el hash sensible local en LSHSelfAttention determinista. Esto solo debe configurarse con fines de prueba. Para fines de evaluación y entrenamiento, hash_seed debe dejarse como None para asegurar 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 del 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 o no. 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 capa.
  • local_num_chunks_before (int, opcional, valor predeterminado 1) — Número de bloques vecinos anteriores a los que prestar atención en la capa LocalSelfAttention hacia 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 bloque que atiende a sí mismo en LSHSelfAttention. El uso de bloques reduce la complejidad de memoria de longitud de secuencia x longitud de secuencia (autoatención) a longitud de bloque x longitud de bloque x longitud de secuencia / longitud de bloque (autoatención por bloques).
  • 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 prestar atención en la capa LSHSelfAttention hacia sí misma.
  • lsh_num_chunks_after (int, opcional, valor predeterminado 0) — Número de bloques vecinos posteriores a los que prestar atención en la capa LSHSelfAttention hacia 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 clave de consulta pueden “hasharse” mediante el esquema de hashing sensible a la localidad. Cada vector clave de consulta se hash 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 clave de consulta se hash 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 hash (p. ej., número de rotaciones aleatorias) en el esquema de Local Sensitive Hashing. A mayor valor de num_hashes, más precisa se vuelve la LSHSelfAttention, pero también más intensivo en memoria y tiempo se vuelve el proceso de hash.
  • 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 matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.
  • use_cache (bool, opcional, valor predeterminado True) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por 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 del token utilizado para el inicio de la secuencia en el vocabulario.
  • pad_token_id (int, opcional, valor predeterminado 0) — Id del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplos:

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

clase transformers.ReformerTokenizer

< >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneeos_token: str = '</s>'unk_token: str = '<unk>'_spm_precompiled_charsmap: str | None = Noneadditional_special_tokens: list | None = None**kwargs )

Parámetros

  • vocab_file (str) — archivo de SentencePiece (generalmente tiene la extensión .spm) que contiene el vocabulario necesario para instanciar un tokenizador.
  • eos_token (str, opcional, por defecto es "</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 la secuencia. El token que se utiliza es sep_token.

    Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el final de la 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.

Este tokenizador hereda de 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

< >

( save_directory: strfilename_prefix: str | None = None )

ReformerModel

clase transformers.ReformerModel

< >

( config: ReformerConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonepast_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ReformerModelOutput or tuple(torch.Tensor)

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 chunk relevantes del modelo (lsh, local o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud del chunk.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 deben realizarse 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.

  • past_buckets_states (ReformerDynamicCache, opcional) — Lista de tuple(torch.LongTensor, torch.Tensor de longitud config.n_layers, cuyo primer elemento son los buckets de forma (batch_size, num_heads, num_hashes, sequence_length)) y el segundo son los hidden_states de forma (batch_size, sequence_length, hidden_size)).

    Contiene estados ocultos precalculados y cubos (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 clave-valor de 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 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, cuyo primer elemento son los buckets anteriores de forma (batch_size, num_heads, num_hashes, sequence_length)) y cuyo 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

clase transformers.ReformerModelWithLMHead

< >

( config: ReformerConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

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

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonepast_buckets_states: list[tuple[torch.Tensor]] | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = Nonelabels: typing.Optional[torch.Tensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → CausalLMOutput or tuple(torch.Tensor)

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 chunk relevantes del modelo (lsh, local o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud del chunk.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 deben realizarse 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.

  • past_buckets_states (list[tuple(torch.LongTensor, torch.Tensor)], opcional) — Lista de tuple(torch.LongTensor, torch.Tensor de longitud config.n_layers, cuyo primer elemento es los buckets de forma (batch_size, num_heads, num_hashes, sequence_length)) y el segundo es los hidden_states de forma (batch_size, sequence_length, hidden_size)).

    Contiene estados ocultos precalculados y cubos (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 clave-valor de 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 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 etiquetas en [0, ..., config.vocab_size]
  • logits_to_keep (Union[int, torch.Tensor], opcional, valor predeterminado 0) — Si es un int, calcula los logits para los últimos logits_to_keep tokens. Si es 0, calcula los logits para todos los input_ids (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo 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 o tuple(torch.Tensor)

Un 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, 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 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:

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

clase transformers.ReformerForMaskedLM

< >

( config: ReformerConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

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

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

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 chunk relevantes del modelo (lsh, local o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud del chunk.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 deben realizarse 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.

  • 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 input_ids docstring) Los tokens con índices establecidos en -100 se ignoran (enmascarados), la pérdida solo se calcula para los tokens con etiquetas

    Este ejemplo utiliza un punto de control falso, ya que no disponemos de 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 en lugar de una tupla simple.

Devuelve

MaskedLMOutput o tuple(torch.Tensor)

Un 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, 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 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:

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

clase transformers.ReformerForSequenceClassification

< >

( config: ReformerConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

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 chunk relevantes del modelo (lsh, local o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud del chunk.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 deben realizarse 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.

  • 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 en lugar de una tupla simple.

Devuelve

SequenceClassifierOutput o tuple(torch.Tensor)

Un 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, 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 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:

>>> 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]
>>> # 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

clase transformers.ReformerForQuestionAnswering

< >

( config: ReformerConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonenum_hashes: int | None = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Noneoutput_attentions: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

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 chunk relevantes del modelo (lsh, local o ambas). Durante la evaluación, los índices se rellenan automáticamente para ser un múltiplo de la longitud del chunk.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • position_ids (torch.Tensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • 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 deben realizarse 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.

  • start_positions (torch.Tensor de forma (batch_size,), opcional) — Etiquetas para la posición (índice) del inicio del span 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 span 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 en lugar de una tupla simple.

Devuelve

QuestionAnsweringModelOutput o tuple(torch.Tensor)

Un 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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, 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 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:

>>> 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)
...
Update on GitHub

←RecurrentGemma RemBERT→