# Generación

Cada framework tiene un método generate para la generación de texto implementado en su respectiva clase `GenerationMixin`:

- PyTorch [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate) está implementado en [GenerationMixin](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin).

Puede parametrizar el método generate con una instancia de la clase [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig). Consulte esta clase para obtener la lista completa de parámetros de generación, que controlan el comportamiento del método de generación.

Para aprender a inspeccionar la configuración de generación de un modelo, cuáles son los valores predeterminados, cómo cambiar los parámetros de forma ad hoc y cómo crear y guardar una configuración de generación personalizada, consulte la [guía de estrategias de generación de texto](../generation_strategies). La guía también explica cómo usar funciones relacionadas, como la transmisión de tokens.

## GenerationConfig[[transformers.GenerationConfig]]

#### transformers.GenerationConfig[[transformers.GenerationConfig]]

```python
transformers.GenerationConfig(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L96)

**Parámetros que controlan la longitud de la salida:**

max_length (`int`, *opcional*) : se recomienda `max_new_tokens` para controlar cuántos tokens genera el modelo. `max_length` se mantiene por compatibilidad con versiones anteriores.

max_new_tokens (`int`, *opcional*) : El número máximo de tokens a generar, ignorando el número de tokens del prompt.

min_length (`int`, *opcional*) : La longitud mínima de la secuencia que se generará. Corresponde a la longitud del prompt de entrada + `min_new_tokens`. Su efecto se anula por `min_new_tokens`, si también se establece.

min_new_tokens (`int`, *opcional*) : El número mínimo de tokens que se deben generar, ignorando el número de tokens del prompt.

early_stopping (`bool` o `str`, *opcional*) : Controla la condición de parada para los métodos basados en beam, como beam-search. Acepta los siguientes valores: `True`, donde la generación se detiene en cuanto hay `num_beams` candidatos completos; `False`, donde se aplica una heurística y la generación se detiene cuando es muy improbable encontrar mejores candidatos; `"never"`, donde el procedimiento de beam search solo se detiene cuando no pueden existir mejores candidatos (algoritmo de búsqueda por beam canónico).

max_time (`float`, *opcional*) : La cantidad máxima de tiempo, en segundos, que se permite para la ejecución del cálculo. La generación aún completará la pasada actual una vez que se haya agotado el tiempo asignado.

stop_strings (`str` o `list[str]`, *opcional*) : Una cadena o una lista de cadenas que deben terminar la generación si el modelo las produce.

**Parámetros que controlan la estrategia de generación utilizada:**

do_sample (`bool`) : Si se usa muestreo; en caso contrario, se usa decodificación codiciosa.

num_beams (`int`, *opcional*) : Número de haces para la búsqueda por haces. 1 significa que no se realiza búsqueda por haces.

use_mtp : (`bool`): Indica si se debe usar la predicción de múltiples tokens (MTP) si el modelo lo admite.

**Parámetros que controlan la caché:**

use_cache (`bool`) : Indica si el modelo debe utilizar las atenciones de claves/valores de la última pasada (si es aplicable al modelo) para acelerar la decodificación.

cache_implementation (`str`, *opcional*) : Nombre de la clase de caché que se instanciará en `generate`, para un decodificado más rápido. Los valores posibles son:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/es/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/es/internal/generation_utils#transformers.QuantizedCache)  Si no se especifica ninguno, se utilizará la caché predeterminada del modelo (que a menudo es [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache)). Consulte nuestra [documentación de caché](https://huggingface.co/docs/transformers/en/kv_cache) para obtener más información.

cache_config (`dict`, *opcional*, valor predeterminado `None`) : Los argumentos utilizados en la clase de caché de clave-valor se pueden pasar en `cache_config`.

max_cache_len (`int`, *opcional*) : Solo se utiliza con cachés estáticas (`cache_implementation` establecido en `"static"` o `"offloaded_static"`). Preasigna la caché a esta longitud en lugar de la `max_length` de la llamada actual. Establézcala una vez en el valor de la llamada más grande que espera, de modo que las llamadas repetidas a `generate()` con un prompt más largo o un `max_new_tokens` mayor (hasta este límite) reutilicen la misma caché en lugar de provocar una reasignación y una recompilación de `torch.compile`.

**Parámetros para la manipulación de los logits de salida del modelo:**

temperature (`float`, *opcional*) : El valor utilizado para modular las probabilidades del siguiente token. Este valor se establece en el archivo `generation_config.json` de un modelo. Si no se establece, el valor predeterminado es 1.0

top_k (`int`, *opcional*) : El número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k. Este valor se establece en el archivo `generation_config.json` de un modelo. Si no se establece, el valor predeterminado es 50.

top_p (`float`, *opcional*) : Si se establece en un float < 1, solo se conservan para la generación el conjunto más pequeño de tokens más probables cuyas probabilidades suman `top_p` o más. Este valor se establece en el archivo `generation_config.json` de un modelo. Si no se establece, el valor predeterminado es 1.0

min_p (`float`, *opcional*) : Probabilidad mínima del token, que se escalará por la probabilidad del token más probable. Debe ser un valor entre 0 y 1. Los valores típicos están en el rango de 0.01 a 0.2, con una selectividad comparable a la de establecer `top_p` en el rango de 0.99 a 0.8 (utilice el opuesto de los valores normales de `top_p`).

top_h (`float`, *opcional*) : Factor de escalado del presupuesto de entropía, que controla cuánto de la entropía de la distribución se preserva al muestrear. Debe ser un valor entre 0 y 1. En cada paso, los tokens se ordenan por probabilidad y se conserva el prefijo más pequeño de tokens cuya entropía *renormalizada* sea menor o igual a `top_h` veces la entropía de la distribución completa. Valores más pequeños (p. ej., 0.2–0.5) producen salidas más enfocadas y deterministas, mientras que valores cercanos a 1.0 permiten mayor aleatoriedad y diversidad. Los valores típicos se encuentran en el rango de 0.3 a 0.6.

typical_p (`float`, *opcional*) : La tipicidad local mide qué tan similar es la probabilidad condicional de predecir el siguiente token objetivo a la probabilidad condicional esperada de predecir un token aleatorio a continuación, dado el texto parcial ya generado. Si se establece en float < 1, se conservan para la generación el conjunto más pequeño de tokens más localmente típicos cuyas probabilidades suman `typical_p` o más. Consulte [este artículo](https://huggingface.co/papers/2202.00666) para obtener más detalles.

epsilon_cutoff (`float`, *opcional*) : Si se establece en un float estrictamente entre 0 y 1, solo se muestrearán tokens con una probabilidad condicional mayor que `epsilon_cutoff`. En el artículo, los valores sugeridos van desde 3e-4 hasta 9e-4, dependiendo del tamaño del modelo. Consulte [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) para más detalles.

eta_cutoff (`float`, *opcional*) : El muestreo Eta es un híbrido del muestreo localmente típico y el muestreo epsilon. Si se establece como un float estrictamente entre 0 y 1, un token solo se considera si es mayor que `eta_cutoff` o `sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits)))`. El segundo término es, intuitivamente, la probabilidad esperada del siguiente token, escalada por `sqrt(eta_cutoff)`. En el artículo, los valores sugeridos van desde 3e-4 hasta 2e-3, dependiendo del tamaño del modelo. Consulte [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) para más detalles.

repetition_penalty (`float`, *opcional*) : El parámetro para la penalización de repetición. 1.0 significa sin penalización. Consulte [este artículo](https://huggingface.co/papers/1909.05858) para más detalles.

encoder_repetition_penalty (`float`, *opcional*) : El parámetro para encoder_repetition_penalty. Una penalización exponencial para las secuencias que no están en la entrada original. 1.0 significa que no hay penalización.

length_penalty (`float`, *opcional*) : Penalización exponencial de la longitud que se utiliza con la generación basada en beam. Se aplica como exponente a la longitud de la secuencia, que a su vez se utiliza para dividir la puntuación de la secuencia. Dado que la puntuación es la verosimilitud logarítmica de la secuencia (es decir, negativa), `length_penalty` > 0.0 promueve secuencias más largas, mientras que `length_penalty` < 0.0 fomenta secuencias más cortas.

no_repeat_ngram_size (`int`, *opcional*) : Si se establece en un int > 0, todos los n-gramas de ese tamaño solo pueden ocurrir una vez.

bad_words_ids (`list[list[int]]`, *opcional*) : Lista de listas de ids de tokens que no se permiten generar. Consulte [NoBadWordsLogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.NoBadWordsLogitsProcessor) para obtener más documentación y ejemplos.

renormalize_logits (`bool`) : Indica si se deben renormalizar los logits después de aplicar todos los procesadores de logits (incluidos los personalizados). Se recomienda encarecidamente establecer esta bandera en `True`, ya que los algoritmos de búsqueda suponen que los logits de puntuación están normalizados, pero algunos procesadores de logits rompen la normalización.

forced_bos_token_id (`int`, *opcional*, valor predeterminado `model.config.forced_bos_token_id`) : El id del token que se forzará como el primer token generado después de `decoder_start_token_id`. Útil para modelos multilingües como [mBART](../model_doc/mbart), donde el primer token generado debe ser el token del idioma de destino.

forced_eos_token_id (`int` or list[int]`, *optional*, defaults to `model.config.forced_eos_token_id`) : The id of the token to force as the last generated token when `max_length` is reached. Optionally, use a list to set multiple *end-of-sequence* tokens.

remove_invalid_values (`bool`) : Si se deben eliminar posibles salidas *nan* e *inf* del modelo para evitar que el método de generación falle. Tenga en cuenta que el uso de `remove_invalid_values` puede ralentizar la generación.

exponential_decay_length_penalty (`tuple(int, float)`, *opcional*) : Esta tupla añade una penalización de longitud que crece de forma exponencial, una vez se han generado un cierto número de tokens. La tupla debe consistir en: `(start_index, decay_factor)`, donde `start_index` indica dónde comienza la penalización y `decay_factor` representa el factor de decaimiento exponencial.

suppress_tokens (`list[int]`, *opcional*) : Una lista de tokens que se suprimirán durante la generación. El procesador de logits `SuppressTokens` establecerá sus probabilidades de registro en `-inf` para que no se muestreen.

begin_suppress_tokens  (`list[int]`, *opcional*) : Una lista de tokens que se suprimirán al inicio de la generación. El procesador de logits `SuppressBeginTokens` establecerá sus probabilidades de registro en `-inf` para que no se muestreen.

sequence_bias (`dict[tuple[int], float]`, *opcional*)) : Diccionario que asigna a una secuencia de tokens su término de sesgo. Los sesgos positivos aumentan la probabilidad de que la secuencia sea seleccionada, mientras que los sesgos negativos hacen lo contrario. Consulte [SequenceBiasLogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.SequenceBiasLogitsProcessor) para obtener más documentación y ejemplos.

token_healing (`bool`) : Corrige los tokens finales de los prompts reemplazándolos por sus extensiones correspondientes. Esto mejora la calidad de las completaciones para los prompts afectados por el sesgo de tokenización codiciosa.

guidance_scale (`float`, *opcional*) : La escala de guía para la guía libre de clasificador (CFG). CFG se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta anima al modelo a generar muestras más estrechamente vinculadas al prompt de entrada, generalmente a costa de una menor calidad.

watermarking_config (`BaseWatermarkingConfig` o `dict`, *opcional*) : Argumentos utilizados para aplicar una marca de agua a las salidas del modelo añadiendo un pequeño sesgo a un conjunto aleatorio de tokens "verdes". Consulte la documentación de [SynthIDTextWatermarkingConfig](/docs/transformers/main/es/internal/generation_utils#transformers.SynthIDTextWatermarkingConfig) y [WatermarkingConfig](/docs/transformers/main/es/internal/generation_utils#transformers.WatermarkingConfig) para más detalles. Si se pasa como `Dict`, se convertirá internamente en un `WatermarkingConfig`.

**Parámetros que definen las variables de salida de generate:**

num_return_sequences (`int`, *opcional*) : El número de secuencias devueltas calculadas de forma independiente para cada elemento del lote.

output_attentions (`bool`) : 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`) : Indica si se deben devolver o no los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

output_scores (`bool`) : Indica si se deben devolver las puntuaciones de predicción. Consulte `scores` en los tensores devueltos para obtener más detalles.

output_logits (`bool`) : Indica si se deben devolver o no las puntuaciones de logit de predicción sin procesar. Consulte `logits` en los tensores devueltos para obtener más detalles.

return_dict_in_generate (`bool`) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de devolver únicamente la secuencia generada. Esta bandera debe establecerse en `True` para devolver la caché de generación (cuando `use_cache` es `True`) o las salidas opcionales (consulte las banderas que comienzan con `output_`)

**Tokens especiales que se pueden usar en el momento de la generación:**

pad_token_id (`int`, *opcional*) : El id del token de *padding*.

bos_token_id (`int`, *opcional*) : El id del token de *inicio de secuencia*.

eos_token_id (`Union[int, list[int]]`, *opcional*) : El id del token *end-of-sequence*. Opcionalmente, use una lista para establecer varios tokens *end-of-sequence*.

**Parámetros de generación exclusivos para modelos encoder-decoder:**

encoder_no_repeat_ngram_size (`int`, *opcional*) : Si se establece en un int > 0, todos los ngramas de ese tamaño que aparecen en `encoder_input_ids` no pueden aparecer en `decoder_input_ids`.

decoder_start_token_id (`int` o `list[int]`, *opcional*) : Si un modelo encoder-decoder comienza a decodificar con un token diferente de *bos*, el id de ese token o una lista de longitud `batch_size`. Indicar una lista permite usar ids de inicio diferentes para cada elemento del batch (p. ej., modelos multilingües con idiomas objetivo distintos en un mismo batch).

**Parámetros de generación exclusivos para la generación del asistente:**

is_assistant (`bool`) : Indica si el modelo es un modelo de asistente (borrador).

num_assistant_tokens (`int`, *opcional*) : Define el número de _tokens especulativos_ que el modelo asistente debe generar antes de que el modelo objetivo los verifique en cada iteración. Valores más altos para `num_assistant_tokens` hacen que la generación sea más _especulativa_ : si el modelo asistente es eficiente, se pueden alcanzar mayores aceleraciones; si el modelo asistente requiere muchas correcciones, las aceleraciones serán menores.

num_assistant_tokens_schedule (`str`, *opcional*) : Define el intervalo con el que se modificará el número máximo de tokens del asistente durante la inferencia. - `"heuristic"`: Si todos los tokens especulativos son correctos, se incrementa `num_assistant_tokens` en 2; en caso contrario, se reduce en 1. El valor de `num_assistant_tokens` se mantiene entre varias llamadas de generación con el mismo modelo de asistente. - `"heuristic_transient"`: Igual que `"heuristic"`, pero `num_assistant_tokens` se restablece a su valor inicial después de cada llamada de generación. - `"constant"`: `num_assistant_tokens` permanece sin cambios durante la generación

assistant_confidence_threshold (`float`, *opcional*) : Umbral de confianza para el modelo asistente. Si la confianza del modelo asistente en su predicción para el token actual es inferior a este umbral, el modelo asistente detiene la iteración actual de generación de tokens, incluso si aún no se ha alcanzado el número de _tokens especulativos_ (definido por `num_assistant_tokens`). El umbral de confianza del asistente se ajusta a lo largo de las iteraciones especulativas para reducir el número de pases de inferencia innecesarios en el modelo de borrador y el modelo objetivo, con un sesgo hacia la evitación de falsos negativos. El valor de `assistant_confidence_threshold` es persistente entre múltiples llamadas de generación con el mismo modelo asistente. Es una versión no supervisada del *dynamic speculation lookahead* de *Dynamic Speculation Lookahead Accelerates Speculative Decoding of Large Language Models*.

prompt_lookup_num_tokens (`int`, *opcional*) : El número de tokens que se deben generar como tokens candidatos.

max_matching_ngram_size (`int`, *opcional*) : El tamaño máximo de ngram a considerar para la coincidencia en el prompt. El valor predeterminado es 2 si no se proporciona.

assistant_early_exit(`int`, *opcional*) : Si se establece en un entero positivo, se utilizará la salida anticipada del modelo como asistente. Solo se puede usar con modelos que admitan la salida anticipada (es decir, modelos en los que los logits de las capas intermedias pueden ser interpretados por la cabeza del LM).

assistant_lookbehind(`int`, *opcional*) : Si se establece en un entero positivo, el proceso de re-codificación considerará además los últimos `assistant_lookbehind` tokens del asistente para alinear correctamente los tokens. Solo se puede usar con tokenizadores diferentes en la decodificación especulativa. Consulte este [blog](https://huggingface.co/blog/universal_assisted_generation) para obtener más detalles.

target_lookbehind(`int`, *optional*) : Si se establece en un entero positivo, el proceso de re-codificación considerará además los últimos `target_lookbehind` tokens objetivo para alinear correctamente los tokens. Solo se puede usar con tokenizadores diferentes en la decodificación especulativa. Consulte este [blog](https://huggingface.co/blog/universal_assisted_generation) para más detalles.

assistant_ensemble_weight (`float`, *opcional*) : Habilita la verificación de conjuntos estáticos en la decodificación especulativa. Si se establece en un valor dentro de `(0.0, 1.0)`, el verificador acepta tokens frente a la mezcla `w * p_target + (1 - w) * q_draft` en lugar de `p_target`, intercambiando un sesgo distribucional controlado por una mayor tasa de aceptación. El valor predeterminado es `None`, lo que mantiene la decodificación sin pérdidas. Requiere que el modelo asistente devuelva logits, por lo que no es compatible con la decodificación por búsqueda de indicaciones.

speculation_type (`str`, *opcional*) : El tipo de especulación solicitado. Los valores aceptados son `dflash`.

**Parámetros relacionados con el rendimiento y la compilación:**

compile_config (CompileConfig, *opcional*) : Si se utiliza una cache compilable, esto controla cómo `generate` va a `compile` el paso hacia adelante para una inferencia más rápida.

disable_compile (`bool`) : Si se debe deshabilitar la compilación automática de la pasada hacia adelante. La compilación automática se produce cuando se cumplen ciertos criterios, incluido el uso de una caché compilable. Abra un problema si encuentra la necesidad de usar esta bandera.

Clase que contiene una configuración para una tarea de generación. Una llamada a `generate` admite los siguientes métodos de generación para modelos de decodificador de texto, texto a texto, voz a texto y visión a texto:

- *decodificación codiciosa* si `num_beams=1` y `do_sample=False`
- *muestreo multinomial* si `num_beams=1` y `do_sample=True`
- *decodificación por búsqueda de haces* si `num_beams>1` y `do_sample=False`
- *muestreo multinomial con búsqueda por haz* si `num_beams>1` y `do_sample=True`
- *decodificación asistida* si se pasa `assistant_model` o `prompt_lookup_num_tokens` a `.generate()`

Para obtener más información sobre las estrategias de decodificación, consulte la [guía de estrategias de generación de texto](../generation_strategies).

Un gran número de estas banderas controlan los logits o los criterios de parada de la generación. Asegúrate de consultar las [clases relacionadas con generate](https://huggingface.co/docs/transformers/internal/generation_utils) para obtener una descripción completa de las manipulaciones posibles, así como ejemplos de su uso.

Nota: los campos de configuración que aún son `None` se sobrescribirán con `GenerationConfig._get_default_generation_params()` durante el bucle de generación. Si deseas usar valores diferentes para estos campos, asegúrate de establecerlos explícitamente en la configuración de generación.

#### from_pretrained[[transformers.GenerationConfig.from_pretrained]]

```python
from_pretrained(pretrained_model_name: str | os.PathLike, config_file_name: str | os.PathLike | None = None, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L950)

**Parámetros:**

pretrained_model_name (`str` o `os.PathLike`) : Puede ser:  - una cadena, el *model id* de una configuración de modelo preentrenado alojada en un repositorio de modelos en huggingface.co. - una ruta a un *directorio* que contiene un archivo de configuración guardado con el método [save_pretrained()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig.save_pretrained), p. ej., `./my_model_directory/`.

config_file_name (`str` o `os.PathLike`, *opcional*, valor predeterminado `"generation_config.json"`) : Nombre del archivo JSON de configuración de generación que se cargará desde `pretrained_model_name`.

cache_dir (`str` o `os.PathLike`, *opcional*) : Ruta a un directorio en el que se debe almacenar en caché la configuración de un modelo preentrenado descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los archivos de configuración y sobrescribir las versiones en caché si existen.

proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Los proxies se utilizan en cada solicitud.

token (`str` o `bool`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, o no se especifica, se usará el token generado al ejecutar `hf auth login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git.    Para probar una pull request que hayas realizado en el Hub, puedes pasar `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opcional*, valor predeterminado `False`) : Si es `False`, esta función devuelve solo el objeto de configuración final. Si es `True`, esta función devuelve una `Tuple(config, unused_kwargs)` donde *unused_kwargs* es un diccionario que consiste en pares clave/valor cuyas claves no son atributos de configuración: es decir, la parte de `kwargs` que no se ha utilizado para actualizar `config` y que se ignora de lo contrario.

subfolder (`str`, *opcional*, valor predeterminado `""`) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co, puede especificar aquí el nombre de la carpeta.

kwargs (`dict[str, Any]`, *opcional*) : Los valores en kwargs de cualquier clave que sea un atributo de configuración se utilizarán para reemplazar los valores cargados. El comportamiento respecto a los pares clave/valor cuyas claves *no* son atributos de configuración se controla mediante el parámetro de palabra clave `return_unused_kwargs`.

**Devuelve:** [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig)

El objeto de configuración instanciado a partir de este modelo preentrenado.

Instanciar un [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig) desde un archivo de configuración de generación.

Ejemplos:

```python
>>> from transformers import GenerationConfig

>>> # Download configuration from huggingface.co and cache.
>>> generation_config = GenerationConfig.from_pretrained("openai-community/gpt2")

>>> # E.g. config was saved using *save_pretrained('./test/saved_model/')*
>>> generation_config.save_pretrained("./test/saved_model/")
>>> generation_config = GenerationConfig.from_pretrained("./test/saved_model/")

>>> # You can also specify configuration names to your generation configuration file
>>> generation_config.save_pretrained("./test/saved_model/", config_file_name="my_configuration.json")
>>> generation_config = GenerationConfig.from_pretrained("./test/saved_model/", "my_configuration.json")

>>> # If you'd like to try a minor variation to an existing configuration, you can also pass generation
>>> # arguments to `.from_pretrained()`. Be mindful that typos and unused arguments will be ignored
>>> generation_config, unused_kwargs = GenerationConfig.from_pretrained(
...     "openai-community/gpt2", top_k=1, foo=False, do_sample=True, return_unused_kwargs=True
... )
>>> generation_config.top_k
1

>>> unused_kwargs
{'foo': False}
```

#### from_model_config[[transformers.GenerationConfig.from_model_config]]

```python
from_model_config(model_config: typing.Union[ForwardRef('PreTrainedConfig'), dict])
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1288)

**Parámetros:**

model_config (`PreTrainedConfig | dict`) : La configuración del modelo que se utilizará para instanciar la configuración de generación.

**Devuelve:** [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig)

El objeto de configuración instanciado a partir de esos parámetros.

Instancia un [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig) a partir de un [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig). Esta función es útil para convertir objetos [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) heredados, que pueden contener parámetros de generación, en un [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig) independiente.

#### save_pretrained[[transformers.GenerationConfig.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, config_file_name: str | os.PathLike | None = None, push_to_hub: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L891)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el archivo JSON de configuración (se creará si no existe).

config_file_name (`str` o `os.PathLike`, *opcional*, valor predeterminado `"generation_config.json"`) : Nombre del archivo JSON de configuración de generación que se guardará en `save_directory`.

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/main/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarde un objeto de configuración de generación en el directorio `save_directory` para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig.from_pretrained).

#### actualizar[[transformers.GenerationConfig.update]]

```python
update(defaults_only = False, allow_custom_entries = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1338)

**Parámetros:**

defaults_only (`bool`, *opcional*, valor predeterminado `False`) : Si se deben actualizar todas las claves de la configuración con `kwargs` o solo aquellas que están establecidas en `None` (es decir, el valor predeterminado).

allow_custom_entries (`bool`, *opcional*, valor predeterminado `False`) : Si se permite actualizar entradas personalizadas en la configuración con `kwargs` si no están presentes en la configuración actual.

kwargs (`dict[str, Any]`) : Diccionario de atributos para actualizar provisionalmente esta clase.

**Devuelve:** `dict[str, Any]`

Diccionario que contiene todos los pares clave-valor que no se utilizaron para actualizar la instancia.

Actualiza los atributos de esta instancia de la clase con los atributos de `kwargs` si coinciden con los atributos existentes, devolviendo todos los kwargs no utilizados.

#### validate[[transformers.GenerationConfig.validate]]

```python
validate(strict = False, user_set_attributes: set[str] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L648)

**Parámetros:**

strict (bool) : Si es True, se lanza una excepción por cualquier problema encontrado. Si es False, solo se registran los problemas.

user_set_attributes (set[str], *opcional*) : Nombres de los atributos que el llamador proporcionó explícitamente. Cuando se proporciona, las advertencias de "problema menor" sobre combinaciones de banderas en conflicto (p. ej., banderas solo de muestreo establecidas mientras `do_sample=False`) solo se activan si la bandera en conflicto está en este conjunto, evitando advertencias innecesarias cuando el valor se heredó de la configuración predeterminada `generation_config.json` de un modelo. Cuando es `None`, todos los atributos establecidos se consideran definidos por el usuario (comportamiento compatible con versiones anteriores para llamadas directas a `validate()`).

Valida los valores de los atributos de la instancia de [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig). Lanza excepciones ante una parametrización que se puede detectar como incorrecta a partir de la instancia de configuración por sí sola.

Tenga en cuenta que algunos parámetros no validados aquí se validan mejor en tiempo de ejecución de generate, ya que pueden depender de otras entradas y/o del modelo, como los parámetros relacionados con la longitud de la generación.

#### get_generation_mode[[transformers.GenerationConfig.get_generation_mode]]

```python
get_generation_mode(assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L535)

**Parámetros:**

assistant_model (`PreTrainedModel`, *opcional*) : El modelo asistente que se utilizará para la generación asistida. Si se establece, el modo de generación será generación asistida.

**Devuelve:** `GenerationMode`

El modo de generación activado por la instancia.

Devuelve el modo de generación activado por la instancia de [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig).

## GenerationMixin[[transformers.GenerationMixin]]

#### transformers.GenerationMixin[[transformers.GenerationMixin]]

```python
transformers.GenerationMixin()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L494)

Una clase que contiene todas las funciones para la generación de texto auto-regresiva, destinada a usarse como mixin en las clases de modelos. Heredar de esta clase hace que el modelo tenga un comportamiento especial relacionado con la generación, como cargar una `GenerationConfig` en el momento de la inicialización o garantizar que se ejecuten las pruebas relacionadas con `generate` en la CI de `transformers`.

Una clase de modelo debe heredar de `GenerationMixin` para poder llamar a métodos como `generate`, o cuando ha definido un método `generate` personalizado que depende de `GenerationMixin`, de forma directa o indirecta, y que comparte aproximadamente la misma interfaz para métodos públicos como `generate`. Tres ejemplos:
- `LlamaForCausalLM` debe heredar de `GenerationMixin` para permitir la llamada a `generate` y otros métodos públicos del mixin;
- `BlipForQuestionAnswering` tiene un método `generate` personalizado que comparte aproximadamente la misma interfaz que `GenerationMixin.generate` (tiene algunos argumentos adicionales y la misma salida). Esa función también llama indirectamente a `GenerationMixin.generate`, a través de un modelo interno. Por lo tanto, `BlipForQuestionAnswering` debería heredar de `GenerationMixin` para beneficiarse de toda la automatización relacionada con la generación en nuestra base de código;
- `BarkModel` tiene un método `generate` personalizado y uno de sus modelos internos llama a `GenerationMixin.generate`. Sin embargo, su `generate` no comparte la misma interfaz que `GenerationMixin.generate`. En este caso, `BarkModel` no debería heredar de `GenerationMixin`, ya que rompe la interfaz de `generate`.

La clase expone [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate), que se puede utilizar para:
- *decodificación codiciosa* si `num_beams=1` y `do_sample=False`
- *muestreo multinomial* si `num_beams=1` y `do_sample=True`
- *decodificación por búsqueda de haces* si `num_beams>1` y `do_sample=False`
- *muestreo multinomial con búsqueda por haz* si `num_beams>1` y `do_sample=True`
- *decodificación asistida* si se pasa `assistant_model` o `prompt_lookup_num_tokens` a `.generate()`

Para obtener más información sobre las estrategias de decodificación, consulte la [guía de estrategias de generación de texto](../generation_strategies).

#### generate[[transformers.GenerationMixin.generate]]

```python
generate(inputs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool | None = None, assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, negative_prompt_ids: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, custom_generate: str | collections.abc.Callable | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L2581)

**Parámetros:**

inputs (`torch.Tensor` de forma variable según la modalidad, *opcional*) : La secuencia utilizada como indicación para la generación o como entradas del modelo para el codificador. Si es `None`, el método la inicializa con `bos_token_id` y un tamaño de lote de 1. Para modelos solo de decodificador, `inputs` debe estar en el formato de `input_ids`. Para modelos codificador-decodificador, *inputs* puede representar cualquiera de `input_ids`, `input_values`, `input_features` o `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los `**kwargs` pasados a generate que coincidan con los atributos de `generation_config` los sobrescribirán. Si no se proporciona `generation_config`, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelo `generation_config.json`, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig), cuya documentación debe consultarse para parametrizar la generación.

logits_processor (`LogitsProcessorList`, *opcional*) : Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de generación. Si se pasa un procesador de logits que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.

stopping_criteria (`StoppingCriteriaList`, *opcional*) : Criterios de parada personalizados que complementan los criterios de parada predeterminados construidos a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Si su criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`. Esta función está destinada a usuarios avanzados.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opcional*) : Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos: el ID del lote `batch_id` y `input_ids`. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación, condicionada al ID del lote `batch_id` y a los tokens generados previamente `inputs_ids`. Este argumento es útil para la generación restringida condicionada al prefijo, tal como se describe en [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opcional*) : Indica si se debe continuar ejecutando el bucle while hasta max_length. A menos que se sobrescriba, esta bandera se establecerá en `True` si se utiliza `FullyShardedDataParallel` o DeepSpeed ZeRO Stage 3 con varias GPUs, para evitar bloqueos si una GPU termina de generar antes que las demás. De lo contrario, el valor predeterminado es `False`.

assistant_model (`PreTrainedModel`, *opcional*) : Un modelo asistente que se puede utilizar para acelerar la generación. El modelo asistente debe tener exactamente el mismo tokenizador. La aceleración se logra cuando la predicción de tokens candidatos con el modelo asistente es mucho más rápida que ejecutar la generación con el modelo desde el que se llama a generate. Por lo tanto, el modelo asistente debe ser mucho más pequeño.

streamer (`BaseStreamer`, *opcional*) : Objeto Streamer que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través de `streamer.put(token_ids)` y el streamer se encarga de cualquier procesamiento adicional.

negative_prompt_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : El prompt negativo necesario para algunos procesadores, como CFG. El tamaño del lote debe coincidir con el tamaño del lote de entrada. Esta es una función experimental, sujeta a cambios que pueden romper la API en versiones futuras.

negative_prompt_attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Attention_mask para `negative_prompt_ids`.

custom_generate (`str` o `Callable`, *opcional*) : Una de las siguientes opciones: - `str` (nombre de un repositorio de Hugging Face Hub): ejecuta la función personalizada `generate` definida en `custom_generate/generate.py` de ese repositorio en lugar del método estándar `generate`. El repositorio reemplaza por completo la lógica de generación, y el tipo de retorno puede diferir. - `str` (ruta de un repositorio local): igual que lo anterior, pero desde una ruta local. Los directorios locales también requieren `trust_remote_code=True` porque se ejecuta el `custom_generate/generate.py` local. - `Callable`: `generate` realizará los pasos habituales de preparación de la entrada y luego llamará al callable proporcionado para ejecutar el bucle de decodificación. Para obtener más información, consulte [la documentación](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opcional*) : Parametrización ad hoc de `generation_config` y/o kwargs específicos del modelo adicionales que se reenviarán a la función `forward` del modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo *decoder_*.

**Devuelve:** [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) o `torch.LongTensor`

Un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` o cuando `config.return_dict_in_generate=True`) o un `torch.LongTensor`.

Si el modelo *no* es un modelo encoder-decoder (`model.config.is_encoder_decoder=False`), los tipos [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) posibles son:

- [GenerateDecoderOnlyOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput),
- [GenerateBeamDecoderOnlyOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateBeamDecoderOnlyOutput)

Si el modelo es un modelo encoder-decoder (`model.config.is_encoder_decoder=True`), los tipos [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) posibles son:

- [GenerateEncoderDecoderOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Genera secuencias de ids de tokens para modelos con una cabeza de modelado de lenguaje.

La mayoría de los parámetros de control de generación se configuran en `generation_config`, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquier `generation_config` pasando los parámetros correspondientes a generate(), por ejemplo, `.generate(inputs, num_beams=4, do_sample=True)`.

Para obtener una visión general de las estrategias de generación y ejemplos de código, consulta la [siguiente guía](../generation_strategies).

#### compute_transition_scores[[transformers.GenerationMixin.compute_transition_scores]]

```python
compute_transition_scores(sequences: Tensor, scores: tuple, beam_indices: typing.Optional[torch.Tensor] = None, normalize_logits: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L1734)

**Parámetros:**

sequences (`torch.LongTensor`) : Las secuencias generadas. La segunda dimensión (sequence_length) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`.

scores (`tuple(torch.Tensor)`) : Puntuaciones de transición para cada token del vocabulario en cada paso de generación. Puntuaciones de transición de haz que consisten en probabilidades logarítmicas de tokens condicionadas al log softmax de los tokens generados previamente en este haz. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento por cada token generado), con cada tensor de forma `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *opcional*) : Índices de los haces de los ids de tokens generados en cada paso de generación. `torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`. Solo es necesario si `num_beams>1` en el momento de la generación.

normalize_logits (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben normalizar los logits (que, por razones de compatibilidad con versiones anteriores, pueden no estar normalizados).

**Devuelve:** `torch.Tensor`

Un `torch.Tensor` de forma `(batch_size*num_return_sequences, sequence_length)` que contiene las puntuaciones de transición (logits)

Calcula las puntuaciones de transición de las secuencias a partir de las puntuaciones de generación (y los índices de haz, si se utilizó la búsqueda por haz). Este es un método conveniente para obtener rápidamente las puntuaciones de los tokens seleccionados en el momento de la generación.

Ejemplos:

```python
>>> from transformers import GPT2Tokenizer, AutoModelForCausalLM
>>> import numpy as np

>>> tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer.pad_token_id = tokenizer.eos_token_id
>>> inputs = tokenizer(["Today is"], return_tensors="pt")

>>> # Example 1: Print the scores for each token generated with Greedy Search
>>> outputs = model.generate(**inputs, max_new_tokens=5, return_dict_in_generate=True, output_scores=True)
>>> transition_scores = model.compute_transition_scores(
...     outputs.sequences, outputs.scores, normalize_logits=True
... )
>>> # input_length is the length of the input prompt for decoder-only models, like the GPT family, and 1 for
>>> # encoder-decoder models, like BART or T5.
>>> input_length = 1 if model.config.is_encoder_decoder else inputs.input_ids.shape[1]
>>> generated_tokens = outputs.sequences[:, input_length:]
>>> for tok, score in zip(generated_tokens[0], transition_scores[0]):
...     # | token | token string | log probability | probability
...     print(f"| {tok:5d} | {tokenizer.decode(tok):8s} | {score.numpy():.3f} | {np.exp(score.numpy()):.2%}")
|   262 |  the     | -1.414 | 24.33%
|  1110 |  day     | -2.609 | 7.36%
|   618 |  when    | -2.010 | 13.40%
|   356 |  we      | -1.859 | 15.58%
|   460 |  can     | -2.508 | 8.14%

>>> # Example 2: Reconstruct the sequence scores from Beam Search
>>> outputs = model.generate(
...     **inputs,
...     max_new_tokens=5,
...     num_beams=4,
...     num_return_sequences=4,
...     return_dict_in_generate=True,
...     output_scores=True,
... )
>>> transition_scores = model.compute_transition_scores(
...     outputs.sequences, outputs.scores, outputs.beam_indices, normalize_logits=False
... )
>>> # If you sum the generated tokens' scores and apply the length penalty, you'll get the sequence scores.
>>> # Tip 1: recomputing the scores is only guaranteed to match with `normalize_logits=False`. Depending on the
>>> # use case, you might want to recompute it with `normalize_logits=True`.
>>> # Tip 2: the output length does NOT include the input length
>>> output_length = np.sum(transition_scores.numpy() < 0, axis=1)
>>> length_penalty = model.generation_config.length_penalty
>>> reconstructed_scores = transition_scores.sum(axis=1) / (output_length**length_penalty)
>>> print(np.allclose(outputs.sequences_scores, reconstructed_scores))
True
```

## ContinuousMixin[[transformers.ContinuousMixin]]

#### transformers.ContinuousMixin[[transformers.ContinuousMixin]]

```python
transformers.ContinuousMixin()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1249)

Clase mixin para modelos para añadir capacidades de lotes continuos. Los lotes continuos tienen tres puntos de entrada:
- `init_continuous_batching`, que es el punto de entrada real para el loteo continuo
- `continuous_batching_context_manager`, que a su vez es un envoltorio de `init_continuous_batching`
- `generate_batch`, que en realidad es un envoltorio de `continuous_batching_context_manager`

Están definidos en este orden. Cualquier cambio realizado en cualquiera de esos tres puntos de entrada debe reflejarse en los otros dos.

#### continuous_batching_context_manager[[transformers.ContinuousMixin.continuous_batching_context_manager]]

```python
continuous_batching_context_manager(generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, block: bool = True, timeout: float | None = None, continuous_batching_config: transformers.generation.configuration_utils.ContinuousBatchingConfig | None = None, persistent_manager: bool = False, warmup: bool = True, workload_hints: transformers.generation.continuous_batching.utils.WorkloadHints | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1328)

Un gestor de contexto para usar de forma segura el gestor de lotes continuos. Los argumentos son similares a los de `init_continuous_batching`, excepto por:
- block: si se debe bloquear el hilo al detener el administrador. El valor predeterminado es True.
- timeout: tiempo máximo de espera para que el hilo se detenga. El valor predeterminado es None (sin tiempo de espera).
- warmup: si se deben precapturar los gráficos de CUDA en los tamaños más grandes antes de ejecutar. El valor predeterminado es True.

#### destroy_cached_continuous_batching_manager[[transformers.ContinuousMixin.destroy_cached_continuous_batching_manager]]

```python
destroy_cached_continuous_batching_manager()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1321)

Destruye el gestor de lotes continuos en caché y libera los recursos de la GPU.

#### generate_batch[[transformers.ContinuousMixin.generate_batch]]

```python
generate_batch(inputs: list, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, continuous_batching_config: transformers.generation.configuration_utils.ContinuousBatchingConfig | None = None, record_timestamps: bool = False, progress_bar: bool = False, persistent_manager: bool = False, warmup: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1368)

**Parámetros:**

inputs : Lista de secuencias de tokens de entrada (indicaciones)

generation_config : Configuración de generación opcional

continuous_batching_config : Configuración opcional de lotes continuos

record_timestamps : Si se establece en true, las solicitudes incluirán una marca de tiempo para cada token generado

progress_bar : Si se establece en true, se mostrará una barra de progreso

persistent_manager : si se debe persistir el gestor después de que finalice la generación. El valor predeterminado es False.

warmup : si se deben capturar los gráficos de CUDA de antemano antes de procesar las solicitudes. El valor predeterminado es True.

**Devuelve:** `dict[str, GenerationOutput]`

un diccionario de ids de solicitud a objetos GenerationOutput

Genera secuencias para un lote de prompts usando continuous batching.

#### init_continuous_batching[[transformers.ContinuousMixin.init_continuous_batching]]

```python
init_continuous_batching(generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, continuous_batching_config: transformers.generation.configuration_utils.ContinuousBatchingConfig | None = None, workload_hints: transformers.generation.continuous_batching.utils.WorkloadHints | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1261)

**Parámetros:**

generation_config : una configuración de generación opcional, que puede contener un objeto CompileConfig

continuous_batching_config : Una configuración opcional de lotes continuos

workload_hints : WorkloadHints opcional para ayudar al gestor de lotes continuos a tomar mejores decisiones sobre los valores predeterminados

**Devuelve:** `ContinuousBatchingManager`

La instancia del administrador para agregar solicitudes y recuperar resultados.

Inicializa un gestor para inferencia con lotes continuos.

## ContinuousBatchingManager[[transformers.ContinuousBatchingManager]]

#### transformers.ContinuousBatchingManager[[transformers.ContinuousBatchingManager]]

```python
transformers.ContinuousBatchingManager(model: ProtoPretrainedModel, generation_config: GenerationConfig, continuous_batching_config: ContinuousBatchingConfig, workload_hints: transformers.generation.continuous_batching.utils.WorkloadHints | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L658)

Gestor para el procesamiento por lotes continuo de solicitudes de generación. Proporciona una interfaz de usuario para enviar solicitudes de generación, obtener resultados y gestionar el hilo de generación en segundo plano. Esta clase no debe crearse directamente, sino a través de uno de los siguientes puntos de entrada (todos métodos del mixin `ContinuousMixin`):
- `init_continuous_batching`
- `continuous_batching_context_manager`
- `generate_batch`

#### add_request[[transformers.ContinuousBatchingManager.add_request]]

```python
add_request(input_ids: list, request_id: str | None = None, max_new_tokens: int | None = None, streaming: bool = False, record_timestamps: bool = False, eos_token_id: int | list[int] | None = None, **logit_processor_kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L914)

**Parámetros:**

input_ids : IDs de tokens de entrada para usar como prompt

request_id : ID de solicitud personalizado opcional (se genera automáticamente si es None)

max_new_tokens : Número máximo de nuevos tokens a generar

streaming : Si se deben transmitir los tokens a medida que se generan

record_timestamps : Si se deben registrar marcas de tiempo para cada token generado

eos_token_id : ID(s) del token de fin de secuencia

logit_processor_kwargs : Argumentos de palabras clave para el procesador de logits.

**Devuelve:** `str | None`

El ID de solicitud si el proceso es un controlador de TP, None en caso contrario.

Agrega una nueva solicitud de generación a la cola. Si el proceso no es un controlador de TP, esta operación no tiene efecto.

#### add_requests[[transformers.ContinuousBatchingManager.add_requests]]

```python
add_requests(inputs: list, max_new_tokens: int | None = None, streaming: bool = False, record_timestamps: bool = False, **logit_processor_kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L972)

Función de utilidad para agrupar `add_request` y devolver sus IDs. Consulta su documentación para más detalles.

#### cancel_request[[transformers.ContinuousBatchingManager.cancel_request]]

```python
cancel_request(request_id: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1007)

Cancela una solicitud por su ID. Si se llama desde un proceso que no es un conductor de TP, no tiene efecto: solo los procesos de conductor de TP interactúan con el administrador.

#### destroy[[transformers.ContinuousBatchingManager.destroy]]

```python
destroy()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L887)

Termina el gestor y libera los recursos distribuidos. Es seguro llamarlo varias veces. Después de llamarlo, el gestor no se puede reiniciar.

#### get_result[[transformers.ContinuousBatchingManager.get_result]]

```python
get_result(request_id: str | None = None, timeout: float | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1016)

Recupera un resultado de la cola de salida. Si se proporciona un ID, devuelve la primera solicitud coincidente. Si se proporciona un tiempo de espera, devuelve None después del tiempo de espera (en segundos).

#### is_running[[transformers.ContinuousBatchingManager.is_running]]

```python
is_running()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L801)

Devuelve True si el hilo de generación en segundo plano se ha iniciado y sigue activo.

#### unirse[[transformers.ContinuousBatchingManager.join]]

```python
join(stop_trigger_time: float, timeout: float | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L872)

Esperar a que el hilo en segundo plano termine. La espera puede limitarse mediante el argumento timeout (en segundos).

#### pausa[[transformers.ContinuousBatchingManager.pause]]

```python
pause()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L894)

Un gestor de contexto que pausa el bucle de generación, de modo que el hilo que lo llama pueda utilizar el modelo, normalmente para actualizarlo in situ. El hilo solo entra en este contexto una vez que el bucle está pausado, y el bucle se reanuda al salir, conservando su caché y sus solicitudes en curso: nada se vacía y ninguna solicitud se pierde. Varios hilos pueden mantener la pausa al mismo tiempo, y el bucle se reanuda cuando el último de ellos sale. Si TP está activado, todos los ranks deben entrar en este contexto; de lo contrario, los demás ranks se bloquearán indefinidamente.

#### register_result_handler[[transformers.ContinuousBatchingManager.register_result_handler]]

```python
register_result_handler(request_id: str, callback: Callable)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1053)

**Parámetros:**

request_id (*str*) : El ID de solicitud para recibir las salidas.

callback (*callable*) : Se llama con un `GenerationOutput` para cada resultado.

Registre un callback para la entrega de resultados (con streaming o sin streaming).

El callback se invoca en el bucle de eventos mediante `call_soon_threadsafe` cada vez que se produce un resultado para esta solicitud. En las solicitudes de streaming, esto ocurre en cada token; en las no de streaming, solo al completarse. El manejador se limpia automáticamente cuando la solicitud finaliza.

#### request_id_iter[[transformers.ContinuousBatchingManager.request_id_iter]]

```python
request_id_iter(request_id: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L1040)

Iterar sobre los resultados que coinciden con un id de solicitud específico (bloqueante).

Utiliza la cola de salida compartida con reencolado. Para el servicio de alta concurrencia, use `register_result_handler` en su lugar.

#### comenzar[[transformers.ContinuousBatchingManager.start]]

```python
start()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L805)

Inicie el hilo de generación en segundo plano.

#### stop[[transformers.ContinuousBatchingManager.stop]]

```python
stop(block: bool = True, timeout: float | None = None, keep_for_next_session: bool = False, hard_stop: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L814)

Detiene el hilo de generación en segundo plano. Si la bandera `block` se establece en True, este método espera a que el hilo se detenga durante un tiempo máximo de `timeout` segundos (None significa sin tiempo de espera). Si la bandera `keep_for_next_session` se establece en True, el gestor se almacena en caché en el modelo para su uso futuro. Si se establece la bandera `hard_stop`, el hilo de generación en segundo plano se detendrá de inmediato y las solicitudes pendientes fallarán.

#### switch_to_cb_friendly_attn[[transformers.ContinuousBatchingManager.switch_to_cb_friendly_attn]]

```python
switch_to_cb_friendly_attn(model: ProtoPretrainedModel, auto_switch_to_flash: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L745)

Cambia la implementación de attn por una compatible con CB. Si auto_switch_to_flash es True y la implementación de attn es SDPA o eager, también cambia a flash si está soportada y disponible.

#### warmup[[transformers.ContinuousBatchingManager.warmup]]

```python
warmup()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/continuous_api.py#L791)

Captura de antemano de grafos CUDA para las rutas varlen y decode ejecutando lotes ficticios. Inicializa el procesador de lotes si aún no se ha hecho.

## Programador[[transformers.generation.Scheduler]]

#### transformers.generation.Scheduler[[transformers.generation.Scheduler]]

```python
transformers.generation.Scheduler(cache: PagedAttentionCache, safety_margin: float, max_requests_per_batch: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L23)

Clase base abstracta para programar solicitudes en el procesador de lotes continuos. Los programadores gestionan el ciclo de vida de las solicitudes desde que se añaden a la cola de espera hasta que se programan para su procesamiento. Diferentes programadores implementan distintas estrategias para priorizar y agrupar las solicitudes.

#### add_waiting_request[[transformers.generation.Scheduler.add_waiting_request]]

```python
add_waiting_request(state: RequestState)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L58)

Añade una solicitud a la lista de espera.

#### clear_cancelled_requests[[transformers.generation.Scheduler.clear_cancelled_requests]]

```python
clear_cancelled_requests()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L96)

Elimina todas las solicitudes canceladas de las colas activas y de espera.

#### finish_request[[transformers.generation.Scheduler.finish_request]]

```python
finish_request(request_id: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L78)

Completa el procesamiento de una solicitud y libera sus bloques de caché asignados. Este método se llama cuando una solicitud ha finalizado la generación o ha encontrado un error.

#### get_active_request_static_outputs[[transformers.generation.Scheduler.get_active_request_static_outputs]]

```python
get_active_request_static_outputs(request_id: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L85)

Obtiene los tokens generados para una solicitud activa.

#### has_pending_requests[[transformers.generation.Scheduler.has_pending_requests]]

```python
has_pending_requests()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L74)

Comprueba si hay solicitudes listas para ser procesadas.

#### request_is_cancelled[[transformers.generation.Scheduler.request_is_cancelled]]

```python
request_is_cancelled(request_id: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L113)

Comprueba si una solicitud ha sido cancelada o eliminada.

#### restablecer[[transformers.generation.Scheduler.reset]]

```python
reset()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L47)

Restablecer el estado del programador para un nuevo bucle de generación.

#### schedule_batch[[transformers.generation.Scheduler.schedule_batch]]

```python
schedule_batch(token_budget: int, cache_budget: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L63)

Programa las solicitudes para el próximo lote en función de los presupuestos disponibles de tokens y de caché. Este método selecciona qué solicitudes deben procesarse en el lote actual, teniendo en cuenta los presupuestos y las reglas de priorización del programador. token_budget es el número máximo de tokens que se pueden procesar en un lote, y cache_budget es el número máximo de entradas de caché KV que se pueden leer en un lote. Devuelve la lista de solicitudes programadas en su forma de "FutureRequestState", un valor booleano que indica si se puede usar la ruta rápida de decodificación, el número total de tokens de consulta y el número máximo de tokens kv leídos.

#### set_request_cancellation[[transformers.generation.Scheduler.set_request_cancellation]]

```python
set_request_cancellation(request_id: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L91)

Marca una solicitud de cancelación.

## FIFOScheduler[[transformers.generation.FIFOScheduler]]

#### transformers.generation.FIFOScheduler[[transformers.generation.FIFOScheduler]]

```python
transformers.generation.FIFOScheduler(cache: PagedAttentionCache, safety_margin: float | None, max_requests_per_batch: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L308)

Este programador procesa las solicitudes en el orden en que llegan, lo que significa que las solicitudes de decodificación tienen prioridad sobre las de prellenado.

## PrefillFirstScheduler[[transformers.generation.PrefillFirstScheduler]]

#### transformers.generation.PrefillFirstScheduler[[transformers.generation.PrefillFirstScheduler]]

```python
transformers.generation.PrefillFirstScheduler(cache: PagedAttentionCache, safety_margin: float | None, max_requests_per_batch: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/continuous_batching/scheduler.py#L357)

Programador que prioriza las solicitudes de prefill dividido sobre las solicitudes de decodificación. Este programador garantiza que las solicitudes de prefill dividido (que son continuaciones de prompts procesados parcialmente) se completen antes de procesar nuevas solicitudes de decodificación.