Transformers documentation
Dory
Este modelo fue aportado a Hugging Face Transformers el 2026-11-19.
Dory
Dory es un modelo de lenguaje en bucle (recurrente latente) de NVIDIA. Utiliza una arquitectura normalized-GPT con capas de atención deslizante y atención completa intercaladas. Al aplicar repetidamente un bloque compartido de capas, Dory puede escalar su inteligencia destinando más cómputo por token. Este cómputo se puede ajustar cambiando el número de bucles durante la inferencia con el mismo checkpoint.
Encuentra todos los puntos de control oficiales en la colección Dory.
Introducción
Genere texto con Pipeline o AutoModelForCausalLM. Ambos ejemplos utilizan la plantilla de chat, que habilita el razonamiento de forma predeterminada, y la configuración de muestreo recomendada.
from transformers import pipeline
pipe = pipeline(
task="text-generation",
model="nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16",
)
pipe([{"role": "user", "content": "Name the largest planet in our solar system."}], max_new_tokens=512)from transformers import AutoModelForCausalLM, AutoTokenizer
checkpoint = "nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto")
inputs = tokenizer.apply_chat_template(
[{"role": "user", "content": "Name the largest planet in our solar system."}],
add_generation_prompt=True,
return_dict=True,
return_tensors="pt",
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True))Notas
Establezca
n_recurrent_loopspara equilibrar el cómputo y la precisión. Los puntos de control publicados tienen un valor predeterminado de 2. Pruebe 1 para un menor cómputo por token o 4 para una mayor precisión. Más bucles pueden acortar las respuestas, por lo que mida la latencia de extremo a extremo.Establezca
recurrent_kv_cache_mode="last_loop"para compartir el historial de KV entre bucles en lugar de mantener historiales separados con el valor predeterminadoper_loop. La memoria de la caché se vuelve independiente del número de bucles. Cada bucle sigue calculando sus propios Q, K y V, pero solo el último bucle los escribe en la caché. Los bucles anteriores leen el pasado en caché y atienden sobre él junto con sus propias claves nuevas, sin escribir. El diagrama siguiente muestra una capa recurrenteLcon 3 bucles.prefill "a b c": cache[L] empty loop0: attend [k0(abc)] loop1: attend [k1(abc)] loop2: attend [k2(abc)] → cache[L] = k2(abc) (write) decode "d": cache[L] = k2(abc) (read) loop0: attend [k2(abc) | k0(d)] loop1: attend [k2(abc) | k1(d)] loop2: attend [k2(abc) | k2(d)] → cache[L] = k2(abcd)
DoryConfig
clase transformers.DoryConfig
< 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 = 131072hidden_size: int = 2560intermediate_size: int = 7168num_hidden_layers: int = 36num_attention_heads: int = 16num_key_value_heads: int = 4head_dim: int = 256hidden_act: str = 'silu'max_position_embeddings: int = 8192initializer_range: float = 0.0177use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = Falserope_parameters: dict | None = Noneattention_bias: bool = Falseattention_dropout: float = 0.0mlp_bias: bool = Falsesliding_window: int = 1024layer_types: list[str] | None = Nonengpt_alpha_init: float = 0.05n_input_layers: int = 8n_recurrent_layers: int | None = Nonen_output_layers: int = 8n_recurrent_loops: int = 2recurrent_kv_cache_mode: typing.Literal['per_loop', 'last_loop'] = 'per_loop' )
Parámetros
- vocab_size (
int, opcional, valor predeterminado131072) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - hidden_size (
int, opcional, valor predeterminado2560) — Dimensión de las representaciones ocultas. - intermediate_size (
int, opcional, valor predeterminado7168) — Dimensión de las representaciones del MLP. - num_hidden_layers (
int, opcional, valor predeterminado36) — Número de capas ocultas en el decodificador Transformer. - num_attention_heads (
int, opcional, valor predeterminado16) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - num_key_value_heads (
int, opcional, valor predeterminado4) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Sinum_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); sinum_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado seránum_attention_heads. - head_dim (
int, opcional, valor predeterminado256) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads - hidden_act (
str, opcional, valor predeterminadosilu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, valor predeterminado8192) — La longitud máxima de secuencia con la que se podría utilizar este modelo. - initializer_range (
float, opcional, valor predeterminado0.0177) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - use_cache (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante siconfig.is_decoder=Trueo cuando el modelo es un modelo generativo solo de decodificador. - pad_token_id (
int, opcional) — Id del token utilizado para el relleno en el vocabulario. - bos_token_id (
int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario. - tie_word_embeddings (
bool, opcional, valor predeterminadoFalse) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo. - rope_parameters (
dict, opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor pararope_thetay, opcionalmente, los parámetros utilizados para el escalado en caso de que desee usar RoPE conmax_position_embeddingsmás largos. - attention_bias (
bool, opcional, valor predeterminadoFalse) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención. - attention_dropout (
float, opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - mlp_bias (
bool, opcional, valor predeterminadoFalse) — Si se debe usar un sesgo en las capas up_proj, down_proj y gate_proj de las capas MLP. - sliding_window (
int, opcional, valor predeterminado1024) — Tamaño de la ventana de atención deslizante. Si esNone, no se aplica ninguna ventana deslizante. - layer_types (
list[str], opcional) — Una lista que asigna explícitamente cada índice de capa con su tipo de capa. Si no se proporciona, se generará automáticamente en función de los valores de la configuración. - ngpt_alpha_init (
float, opcional, valor predeterminado 0.05) — Valor inicial de las tasas de interpolación residual de nGPTlambda_1/lambda_2. - n_input_layers (
int, opcional, valor predeterminado 8) — Número de capas del decodificador que se ejecutan una vez antes de la sección recurrente. - n_recurrent_layers (
int, opcional) — Número de capas del decodificador en la sección recurrente. Por defecto, son las capas restantes. - n_output_layers (
int, opcional, valor predeterminado 8) — Número de capas del decodificador que se ejecutan una vez después de la sección recurrente. - n_recurrent_loops (
int, opcional, valor predeterminado 2) — Número de pasadas por la sección recurrente. Más bucles intercambian cómputo por precisión. - recurrent_kv_cache_mode (
str, opcional, valor predeterminado"per_loop") —"per_loop"mantiene una caché KV por bucle recurrente."last_loop"mantiene una única caché KV por capa recurrente, escrita solo por el último bucle (los bucles anteriores la leen), de modo que la memoria de la caché no crece con el número de bucles.
Esta es la clase de configuración para almacenar la configuración de un DoryModel. Se utiliza para instanciar un modelo Dory 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 nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16
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.
DoryModel
clase transformers.DoryModel
< source >( config: DoryConfig )
Parámetros
- config (DoryConfig) — 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 Dory 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.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - cache (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lacachedevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
cache, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
cache, se espera que el usuario introduzca solo losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) de forma(batch_size, unprocessed_length)en lugar de todos losinput_idsde forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor decachey pueden usarse para acelerar la decodificación (vercache).
Devuelve
BaseModelOutputWithPast o tuple(torch.Tensor)
Un BaseModelOutputWithPast 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 (DoryConfig) y las entradas.
El método forward de DoryModel 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
Moduledespué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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.Si se utiliza
cache, solo se genera el último hidden-state de las secuencias con forma(batch_size, 1, hidden_size).cache (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si
config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entradacache) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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.
DoryForCausalLM
clase transformers.DoryForCausalLM
< source >( config: DoryConfig )
Parámetros
- config (DoryConfig) — 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 Dory para el modelado de lenguaje causal.
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.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - cache (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lacachedevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
cache, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
cache, se espera que el usuario introduzca solo losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) de forma(batch_size, unprocessed_length)en lugar de todos losinput_idsde forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida del modelado de lenguaje causal. Los índices deben estar en[-100, 0, ..., config.vocab_size](verinput_idsdocstring). Los tokens con índices establecidos en-100se ignoran (enmascarados), la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size].Las etiquetas se desplazan internamente para que
labels[..., 1:]se utilicen para predecirlogits[..., :-1, :]. Pasa etiquetas no desplazadas que coincidan coninput_ids(es decir,labels = input_ids). No desplaces las etiquetas tú mismo antes de pasarlas.Si las etiquetas ya están desplazadas (por ejemplo, con paralelismo de secuencia), pásalas como argumento de palabra clave
shift_labelsy se usarán tal cual. Todavía se debe pasarlabelspara que se calcule la pérdida. - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor decachey pueden usarse para acelerar la decodificación (vercache). - logits_to_keep (
Union[int, torch.Tensor], opcional, valor predeterminado0) — Si es unint, calcula los logits para los últimoslogits_to_keeptokens. Si es0, calcula los logits para todos losinput_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 untorch.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
CausalLMOutputWithPast o tuple(torch.Tensor)
Un CausalLMOutputWithPast 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 (DoryConfig) y las entradas.
El método forward de DoryForCausalLM 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
Moduledespué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.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).cache (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden utilizar (véase la entrada
cache) para acelerar la decodificación secuencial.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.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, DoryForCausalLM
>>> model = DoryForCausalLM.from_pretrained("meta-dory/Dory-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-dory/Dory-2-7b-hf")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."