Transformers documentation

RWKV

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo fue aportado a Hugging Face Transformers el 2023-05-09.

RWKV

Resumen

El modelo RWKV (versión 4) se propuso en este repositorio

Sugiere un ajuste en la atención del Transformer tradicional para hacerla lineal. De esta manera, el modelo puede usarse como una red recurrente: pasar las entradas de la marca de tiempo 0 y la marca de tiempo 1 juntas es lo mismo que pasar las entradas en la marca de tiempo 0 y luego las entradas en la marca de tiempo 1 junto con el estado de la marca de tiempo 0 (vea el ejemplo a continuación).

Esto puede ser más eficiente que un Transformer regular y puede manejar oraciones de cualquier longitud (aunque el modelo utilice una longitud de contexto fija para el entrenamiento).

Este modelo fue aportado por sgugger. El código original se puede encontrar aquí.

Ejemplo de uso

import torch

from transformers import AutoTokenizer, RwkvModel


model = RwkvModel.from_pretrained("sgugger/rwkv-430M-pile", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("sgugger/rwkv-430M-pile")

inputs = tokenizer("This is an example.", return_tensors="pt").to(model.device)
# Feed everything to the model
outputs = model(inputs["input_ids"])
output_whole = outputs.last_hidden_state

outputs = model(inputs["input_ids"][:, :2])
output_one = outputs.last_hidden_state

# Using the state computed on the first inputs, we will get the same output
outputs = model(inputs["input_ids"][:, 2:], state=outputs.state)
output_two = outputs.last_hidden_state

torch.allclose(torch.cat([output_one, output_two], dim=1), output_whole, atol=1e-5)

Si desea asegurarse de que el modelo deje de generar cuando se detecta '\n\n', recomendamos usar los siguientes criterios de parada:

from transformers import StoppingCriteria


class RwkvStoppingCriteria(StoppingCriteria):
    def __init__(self, eos_sequence = [187,187], eos_token_id = 537):
        self.eos_sequence = eos_sequence
        self.eos_token_id = eos_token_id

    def __call__(self, input_ids: torch.LongTensor, scores: torch.Tensor, **kwargs) -> bool:
        last_2_ids = input_ids[:,-2:].tolist()
        return self.eos_sequence in last_2_ids


output = model.generate(inputs["input_ids"], max_new_tokens=64, stopping_criteria = [RwkvStoppingCriteria()])

Notas

Use padding izquierdo para la generación por lotes. Consulte Lado de relleno.

RwkvConfig

clase transformers.RwkvConfig

< source >

( 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 = Nonevocab_size: int = 50277context_length: int = 1024hidden_size: int = 4096num_hidden_layers: int = 32attention_hidden_size: int | None = Noneintermediate_size: int | None = Nonelayer_norm_epsilon: float = 1e-05bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 0rescale_every: int = 6tie_word_embeddings: bool = Falseuse_cache: bool = True )

Parámetros

vocab_size (int, opcional, valor predeterminado 50277) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
context_length (int, opcional, valor predeterminado 1024) — La longitud máxima de secuencia con la que se puede utilizar este modelo en una sola pasada hacia adelante (utilizarlo en modo RNN permite usar cualquier longitud de secuencia).
hidden_size (int, opcional, valor predeterminado 4096) — Dimensión de las representaciones ocultas.
num_hidden_layers (int, opcional, valor predeterminado 32) — Número de capas ocultas en el decodificador del Transformer.
attention_hidden_size (int, opcional) — Dimensionalidad de los estados ocultos de atención. Si no se establece, el valor predeterminado será hidden_size.
intermediate_size (int, opcional) — Dimensión de las representaciones del MLP.
layer_norm_epsilon (float, opcional, valor predeterminado 1e-05) — El epsilon utilizado por las capas de normalización de capa.
bos_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
eos_token_id (Union[int, list[int]], opcional, valor predeterminado 0) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
rescale_every (int, opcional, valor predeterminado 6) — Durante la inferencia, los estados ocultos (y los pesos de las capas de salida correspondientes) se dividen por 2 cada rescale_every capa. Si se establece en 0 o en un número negativo, no se realiza ningún reescalado.
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.

Esta es la clase de configuración para almacenar la configuración de un RwkvModel. Se utiliza para instanciar un modelo Rwkv 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 RWKV/rwkv-4-169m-pile

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.

Ejemplo:

>>> from transformers import RwkvConfig, RwkvModel

>>> # Initializing a Rwkv configuration
>>> configuration = RwkvConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = RwkvModel(configuration)

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

RwkvModel

clase transformers.RwkvModel

< source >

( config: RwkvConfig )

Parámetros

config (RwkvConfig) — 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 Rwkv básico que genera estados ocultos sin ninguna cabeza específica 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

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestate: list[torch.Tensor] | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → RwkvOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor de forma (batch_size, input_ids_length)) — input_ids_length = sequence_length si past_key_values es None en caso contrario past_key_values.get_seq_length() (sequence_length de los estados de clave y valor de entrada pasados). Índices de los tokens de la secuencia de entrada en el vocabulario.
Si se usa past_key_values, solo se deben pasar como input_ids los input_ids que no tengan su pasado calculado.

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.LongTensor 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.
state (tuple de cinco torch.Tensor de forma (batch_size, hidden_size, num_hidden_layers), opcional) — Si se pasa, el modelo utiliza el estado anterior en todos los bloques (lo que dará la salida para los input_ids proporcionados como si el modelo añadiera state_input_ids + input_ids como contexto).
use_cache (bool, opcional) — Si se establece en True, se devuelve el último estado y puede usarse para generar rápidamente los siguientes logits.
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.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

RwkvOutput o tuple(torch.Tensor)

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

El método forward de RwkvModel 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, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del modelo.
state (list de cinco torch.Tensor de forma (batch_size, hidden_size, num_hidden_layers)) — El estado del modelo en el último paso de tiempo. Se puede utilizar en un método forward con los siguientes input_ids para evitar proporcionar los input_ids anteriores.
hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
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.

RwkvLMHeadModel

clase transformers.RwkvForCausalLM

< source >

( config: RwkvConfig )

Parámetros

config (RwkvConfig) — 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 transformer del modelo RWKV con una cabeza de modelado de lenguaje en la parte superior (capa lineal con pesos vinculados a las incrustaciones de entrada).

forward

< source >

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

Parámetros

input_ids (torch.LongTensor de forma (batch_size, input_ids_length)) — input_ids_length = sequence_length si past_key_values es None en caso contrario past_key_values.get_seq_length() (sequence_length de los estados de clave y valor de entrada pasados). Índices de los tokens de la secuencia de entrada en el vocabulario.
Si se usa past_key_values, solo se deben pasar como input_ids los input_ids que no tengan su pasado calculado.

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.LongTensor 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.
state (tuple de cinco torch.Tensor de forma (batch_size, hidden_size, num_hidden_layers), opcional) — Si se pasa, el modelo utiliza el estado anterior en todos los bloques (lo que dará la salida para los input_ids proporcionados como si el modelo añadiera state_input_ids + input_ids como contexto).
labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Etiquetas para el modelado de lenguaje. Tenga en cuenta que las etiquetas se desplazan dentro del modelo, es decir, puede establecer labels = input_ids Los índices se seleccionan en [-100, 0, ..., config.vocab_size] Todas las etiquetas establecidas en -100 se ignoran (se enmascaran), la pérdida solo se calcula para las etiquetas en [0, ..., config.vocab_size]
use_cache (bool, opcional) — Si se establece en True, se devuelve el último estado y puede usarse para generar rápidamente los siguientes logits.
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.
output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
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

RwkvCausalLMOutput o tuple(torch.Tensor)

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

El método forward de RwkvForCausalLM 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).
state (list de cinco torch.Tensor de forma (batch_size, hidden_size, num_hidden_layers)) — El estado del modelo en el último paso de tiempo. Se puede utilizar en un método forward con los siguientes input_ids para evitar proporcionar los input_ids anteriores.
hidden_states (tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
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:

Atención de Rwkv y las fórmulas recurrentes

En un Transformer auto-regresivo tradicional, la atención se escribe como $O = \hbox{softmax}(QK^{T} / \sqrt{d}) V$

con $Q$, $K$ y $V$ son matrices de forma seq_len x hidden_size llamadas query, key y value (en realidad son matrices más grandes con una dimensión de batch y una dimensión de cabeza de atención, pero solo nos interesan las dos últimas, donde se realiza el producto de matrices, así que, por simplicidad, solo consideramos esas dos). El producto $QK^{T}$ entonces tiene forma seq_len x seq_len y podemos tomar el producto de matrices con $V$ para obtener la salida $O$ de la misma forma que las demás.

Sustituir el softmax por su valor da: $O_{i} = \frac{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}} V_{j}}{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}}}$

Tenga en cuenta que las entradas en $QK^{T}$ correspondientes a $j > i$ están enmascaradas (la suma se detiene en j) porque la atención no puede mirar tokens futuros (solo pasados).

En comparación, la atención de RWKV viene dada por $O_{i} = \sigma(R_{i}) \frac{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}} V_{j}}{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}}}$

donde $R$ es una nueva matriz llamada receptancia por el autor, $K$ y $V$ siguen siendo la clave y el valor (aquí $\sigma$ es la función sigmoide). $W$ es un nuevo vector que representa la posición del token y se define como $W_{0} = u \hbox{ and } W_{k} = (k-1)w \hbox{ for } k \geq 1$

con $u$ y $w$ parámetros aprendibles llamados en el código time_first y time_decay respectivamente. Tanto el numerador como el denominador pueden expresarse de forma recursiva. Si los denominamos $N_{i}$ y $D_{i}$ tenemos: $N_{i} = e^{u + K_{i}} V_{i} + \hat{N}_{i} \hbox{ where } \hat{N}_{i} = e^{K_{i-1}} V_{i-1} + e^{w + K_{i-2}} V_{i-2} \cdots + e^{(i-2)w + K_{1}} V_{1}$

de modo que $\hat{N}_{i}$ (llamado numerator_state en el código) satisface $\hat{N}_{0} = 0 \hbox{ and } \hat{N}_{j+1} = e^{K_{j}} V_{j} + e^{w} \hat{N}_{j}$

y $D_{i} = e^{u + K_{i}} + \hat{D}_{i} \hbox{ where } \hat{D}_{i} = e^{K_{i-1}} + e^{w + K_{i-2}} \cdots + e^{(i-2)w + K_{1}}$

de modo que $\hat{D}_{i}$ (llamado denominator_state en el código) satisface $\hat{D}_{0} = 0 \hbox{ and } \hat{D}_{j+1} = e^{K_{j}} + e^{w} \hat{D}_{j}$

La fórmula recurrente real que se utiliza es un poco más compleja, ya que, por estabilidad numérica, no queremos calcular exponenciales de números grandes. Normalmente, el softmax no se calcula tal cual, sino que se divide el exponencial del término máximo tanto en el numerador como en el denominador: $\frac{e^{x_{i}}}{\sum_{j=1}^{n} e^{x_{j}}} = \frac{e^{x_{i} - M}}{\sum_{j=1}^{n} e^{x_{j} - M}}$

con $M$ el máximo de todos los $x_{j}$. Así que aquí, además de guardar el estado del numerador ($\hat{N}$) y el estado del denominador ($\hat{D}$), también seguimos el máximo de todos los términos encontrados en los exponenciales. Por lo tanto, en realidad usamos $\tilde{N}_{i} = e^{-M_{i}} \hat{N}_{i} \hbox{ and } \tilde{D}_{i} = e^{-M_{i}} \hat{D}_{i}$

definidas por las siguientes fórmulas recurrentes: $\tilde{N}_{0} = 0 \hbox{ and } \tilde{N}_{j+1} = e^{K_{j} - q} V_{j} + e^{w + M_{j} - q} \tilde{N}_{j} \hbox{ where } q = \max(K_{j}, w + M_{j})$

y $\tilde{D}_{0} = 0 \hbox{ and } \tilde{D}_{j+1} = e^{K_{j} - q} + e^{w + M_{j} - q} \tilde{D}_{j} \hbox{ where } q = \max(K_{j}, w + M_{j})$

y $M_{j+1} = q$. Con esos valores, podemos calcular $N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}_{i} \hbox{ where } q = \max(u + K_{i}, M_{i})$

y $D_{i} = e^{u + K_{i} - q} + e^{M_{i}} \tilde{D}_{i} \hbox{ where } q = \max(u + K_{i}, M_{i})$

lo que finalmente nos da $O_{i} = \sigma(R_{i}) \frac{N_{i}}{D_{i}}$

Update on GitHub

←RoFormer Seed-Oss→