Transformers documentation

Generación

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

and get access to the augmented documentation experience

to get started

Generación

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

Puede parametrizar el método generate con una instancia de la clase 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. La guía también explica cómo usar funciones relacionadas, como la transmisión de tokens.

GenerationConfig

clase transformers.GenerationConfig

< >

( **kwargs )

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 canónico de beam search).
  • 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 emite.

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

  • do_sample (bool) — Si se usa muestreo o no; de lo 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): 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) — Si el modelo debe o no utilizar las atenciones de claves/valores pasadas (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:

    Si no se especifica ninguna, se utilizará la caché predeterminada del modelo (que a menudo es DynamicCache). Consulte nuestra documentación de caché para obtener más información.

  • cache_config (dict, opcional, valor predeterminado None) — Los argumentos utilizados en la clase de caché de clave-valor pueden pasarse en cache_config.
  • max_cache_len (int, opcional) — Solo se utiliza con cachés estáticas (cache_implementation establecido en "static" o "offloaded_static"). Dimensiona la caché de antemano a esta longitud en lugar de la max_length de la llamada actual. Establécela una sola vez al tamaño de la llamada más grande que esperes para 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 nueva asignación de memoria 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 escala 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 habituales 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 más aleatoriedad y diversidad. Los valores típicos están 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 para 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 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 en 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 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 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 sin 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 ngramas 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. Consulta NoBadWordsLogitsProcessor para obtener más documentación y ejemplos.
  • renormalize_logits (bool) — 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 fuerza como primer token generado después de decoder_start_token_id. Útil para modelos multilingües como 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 y 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 aumenta exponencialmente después de que se hayan 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 para obtener más documentación y ejemplos.
  • token_healing (bool) — Repara los tokens finales de los prompts reemplazándolos con sus extensiones apropiadas. 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 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 y 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 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 más detalles.
  • output_logits (bool) — Indica si se deben devolver 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 en lugar de devolver exclusivamente 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 (vea 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 de fin de secuencia. Opcionalmente, use una lista para establecer varios tokens de fin de secuencia.

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 inicia la decodificación con un token diferente al 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 lote (p. ej., modelos multilingües con idiomas objetivo distintos en un mismo lote)

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

  • is_assistant (bool) — Indica si el modelo es un modelo asistente (borrador).
  • num_assistant_tokens (int, opcional) — Define el número de fichas especulativas que debe generar el modelo asistente antes de ser verificadas por el modelo objetivo 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, se alcanzan aceleraciones menores.
  • num_assistant_tokens_schedule (str, opcional) — Define el calendario según el cual se deben cambiar los tokens máximos del asistente durante la inferencia.
    • "heuristic": Cuando todos los tokens especulativos son correctos, se aumenta num_assistant_tokens en 2; en caso contrario, se reduce en 1. El valor de num_assistant_tokens es persistente entre varias llamadas de generación con el mismo modelo 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) — El 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 no se ha alcanzado aún 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 del modelo de borrador y del modelo objetivo, con un sesgo hacia evitar 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 https://huggingface.co/papers/2405.04304 de Dynamic Speculation Lookahead Accelerates Speculative Decoding of Large Language Models.
  • prompt_lookup_num_tokens (int, opcional) — El número de tokens que se emitirán como tokens candidatos.
  • max_matching_ngram_size (int, opcional) — El tamaño máximo de ngramas a considerar para la coincidencia en el prompt. El valor predeterminado es 2 si no se proporciona.
  • assistant_early_exit(int, optional) — 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, optional) — 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. Vea este blog para más detalles.
  • target_lookbehind(int, opcional) — 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. Vea este blog para más detalles.
  • assistant_ensemble_weight (float, opcional) — Habilita la verificación de ensemble estático 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 tasa de aceptación más alta. 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 mediante búsqueda de prompt.
  • 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 compilable cache, 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 criterios específicos, incluido el uso de una cache compilable. Abra un issue 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.

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

< >

( pretrained_model_name: str | os.PathLikeconfig_file_name: str | os.PathLike | None = Nonecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs ) → GenerationConfig

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 usando el método save_pretrained(), por ejemplo, ./my_model_directory/.
  • config_file_name (str o os.PathLike, opcional, por defecto "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, por defecto "main") — La versión específica del modelo que se va a usar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que usamos 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 solicitud de extracción (pull request) que hayas realizado en el Hub, puedes pasar revision="refs/pr/<pr_number>".

  • return_unused_kwargs (bool, opcional, por defecto False) — Si False, entonces esta función devuelve solo el objeto de configuración final.

    Si 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 el nombre de la carpeta aquí.
  • kwargs (dict[str, Any], opcional) — Los valores en kwargs de cualquier clave que sea un atributo de configuración se usarán para sobrescribir los valores cargados. El comportamiento respecto a pares clave/valor cuyas claves no son atributos de configuración está controlado por el parámetro de palabra clave return_unused_kwargs.

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

Instanciar un GenerationConfig desde un archivo de configuración de generación.

Ejemplos:

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

< >

( model_config: typing.Union[ForwardRef('PreTrainedConfig'), dict] ) → GenerationConfig

Parámetros

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

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

Instancia un GenerationConfig a partir de un PreTrainedConfig. Esta función es útil para convertir objetos PreTrainedConfig heredados, que pueden contener parámetros de generación, en un GenerationConfig independiente.

save_pretrained

< >

( save_directory: str | os.PathLikeconfig_file_name: str | os.PathLike | None = Nonepush_to_hub: bool = False**kwargs )

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, por defecto "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 hub de modelos de Hugging Face después de guardarlo. Puedes especificar el repositorio al que deseas subirlo con repo_id (por defecto, usará el nombre de save_directory en tu espacio de nombres).
  • kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan al método 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().

actualizar

< >

( defaults_only = Falseallow_custom_entries = False**kwargs ) → dict[str, Any]

Parámetros

  • defaults_only (bool, opcional, valor predeterminado False) — Si se actualizan 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

< >

( strict = Falseuser_set_attributes: set[str] | None = None )

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 ruidosas cuando el valor se heredó de la configuración predeterminada del modelo en generation_config.json. 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. 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í es mejor validarlos 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

< >

( assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None ) → GenerationMode

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á la 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.

GenerationMixin

clase transformers.GenerationMixin

< >

( )

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 asegurarse de que se ejecuten las pruebas relacionadas con generate en la CI de transformers.

Una clase de modelo debe heredar de GenerationMixin para habilitar la llamada a métodos como generate, o cuando ha definido un método generate personalizado que depende de GenerationMixin, directa o indirectamente, 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 debe heredar de GenerationMixin, ya que rompe la interfaz de generate.

La clase expone 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.

generate

< >

( inputs: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = Noneprefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = Nonesynced_gpus: bool | None = Noneassistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = Nonestreamer: typing.Optional[ForwardRef('BaseStreamer')] = Nonenegative_prompt_ids: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonecustom_generate: str | collections.abc.Callable | None = None**kwargs ) → ModelOutput or torch.LongTensor

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 entrada 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, 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á el valor predeterminado, 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, 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 fue 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 creados a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya fue 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 condicionado al ID del lote batch_id y a los tokens generados previamente inputs_ids. Este argumento es útil para la generación condicionada al prefijo, tal como se describe en Autoregressive Entity Retrieval.
  • synced_gpus (bool, opcional) — Si se debe continuar ejecutando el bucle while hasta max_length. A menos que se sobrescriba, esta bandera se establecerá en True si se usa 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 usar para acelerar la generación. El modelo asistente debe tener exactamente el mismo tokenizer. 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 que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través de streamer.put(token_ids) y el objeto responsable 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 rompan 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 del 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 del 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 ejecutará los pasos habituales de preparación de la entrada y, a continuación, llamará al callable proporcionado para ejecutar el bucle de decodificación. Para obtener más información, consulte la documentación.
  • kwargs (dict[str, Any], opcional) — Parametrización ad hoc de generation_config y/o kwargs adicionales específicos del modelo 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 o torch.LongTensor

Un 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 posibles son:

Si el modelo es un modelo encoder-decoder (model.config.is_encoder_decoder=True), los tipos ModelOutput posibles son:

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, consulte la siguiente guía.

compute_transition_scores

< >

( sequences: Tensorscores: tuplebeam_indices: typing.Optional[torch.Tensor] = Nonenormalize_logits: bool = False ) → torch.Tensor

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.FloatTensor)) — 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.FloatTensor con hasta max_new_tokens elementos (un elemento para cada token generado), con cada tensor de forma (batch_size*num_beams, config.vocab_size).
  • beam_indices (torch.LongTensor, opcional) — Índices de los haces del id del token generado 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) — 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:

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

clase transformers.ContinuousMixin

< >

( )

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

< >

( generation_config: transformers.generation.configuration_utils.GenerationConfig | None = Noneblock: bool = Truetimeout: float | None = Nonecontinuous_batching_config: transformers.generation.configuration_utils.ContinuousBatchingConfig | None = Nonepersistent_manager: bool = Falsewarmup: bool = Trueworkload_hints: transformers.generation.continuous_batching.utils.WorkloadHints | None = None )

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

< >

( )

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

generate_batch

< >

( inputs: listgeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonecontinuous_batching_config: transformers.generation.configuration_utils.ContinuousBatchingConfig | None = Nonerecord_timestamps: bool = Falseprogress_bar: bool = Falsepersistent_manager: bool = Falsewarmup: bool = True**kwargs ) → dict[str, GenerationOutput]

Parámetros

  • inputs — Lista de secuencias de tokens de entrada (prompts)
  • 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 tendrá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 mantener el gestor después de que finalice la generación. El valor predeterminado es False.
  • warmup — si se deben precapturar los gráficos de CUDA 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

< >

( generation_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonecontinuous_batching_config: transformers.generation.configuration_utils.ContinuousBatchingConfig | None = Noneworkload_hints: transformers.generation.continuous_batching.utils.WorkloadHints | None = None ) → ContinuousBatchingManager

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

clase transformers.ContinuousBatchingManager

< >

( model: ProtoPretrainedModelgeneration_config: GenerationConfigcontinuous_batching_config: ContinuousBatchingConfigworkload_hints: transformers.generation.continuous_batching.utils.WorkloadHints | None = None )

Gestor para el procesamiento por lotes continuo de solicitudes de generación. Proporciona una interfaz de usuario para enviar solicitudes de generación, recuperar 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

< >

( input_ids: listrequest_id: str | None = Nonemax_new_tokens: int | None = Nonestreaming: bool = Falserecord_timestamps: bool = Falseeos_token_id: int | list[int] | None = None**logit_processor_kwargs: Any ) → str | None

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 registran marcas de tiempo para cada token generado
  • eos_token_id — ID(s) del token de fin de secuencia
  • logit_processor_kwargs — Argumentos de palabra 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

< >

( inputs: listmax_new_tokens: int | None = Nonestreaming: bool = Falserecord_timestamps: bool = False**logit_processor_kwargs: Any )

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

cancel_request

< >

( request_id: str )

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

< >

( )

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

< >

( request_id: str | None = Nonetimeout: float | None = None )

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

is_running

< >

( )

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

join

< >

( stop_trigger_time: floattimeout: float | None = None )

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

pausa

< >

( )

Un gestor de contexto que pausa el bucle de generación, de modo que el hilo que lo llama pueda usar 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 sale. Si TP está activado, todos los rangos deben entrar en este contexto, de lo contrario los demás rangos se bloquearán indefinidamente.

register_result_handler

< >

( request_id: strcallback: Callable )

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

request_id_iter

< >

( request_id: str )

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.

inicio

< >

( )

Inicie el hilo de generación en segundo plano.

stop

< >

( block: bool = Truetimeout: float | None = Nonekeep_for_next_session: bool = Falsehard_stop: bool = False )

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

< >

( model: ProtoPretrainedModelauto_switch_to_flash: bool = True )

Cambia la implementación de attn a una que sea 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.

calentamiento

< >

( )

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

Programador

clase transformers.generation.Scheduler

< >

( cache: PagedAttentionCachesafety_margin: floatmax_requests_per_batch: int )

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 diferentes estrategias para priorizar y agrupar las solicitudes.

add_waiting_request

< >

( state: RequestState )

Añade una solicitud a la lista de espera.

clear_cancelled_requests

< >

( )

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

finish_request

< >

( request_id: str )

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

< >

( request_id: str )

Obtiene los tokens generados para una solicitud activa.

has_pending_requests

< >

( )

Comprueba si hay solicitudes listas para ser procesadas.

request_is_cancelled

< >

( request_id: str )

Comprueba si una solicitud ha sido cancelada o eliminada.

restablecer

< >

( )

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

schedule_batch

< >

( token_budget: intcache_budget: int )

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

< >

( request_id: str )

Marca una solicitud de cancelación.

FIFOScheduler

clase transformers.generation.FIFOScheduler

< >

( cache: PagedAttentionCachesafety_margin: float | Nonemax_requests_per_batch: int )

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

clase transformers.generation.PrefillFirstScheduler

< >

( cache: PagedAttentionCachesafety_margin: float | Nonemax_requests_per_batch: int )

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

Update on GitHub