Transformers documentation

Génération

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

Génération

Chaque framework dispose d'une méthode generate pour la génération de texte, implémentée dans leur classe respective GenerationMixin :

Vous pouvez paramétrer la méthode generate avec une instance de la classe GenerationConfig. Reportez-vous à cette classe pour la liste complète des paramètres de génération, qui contrôlent le comportement de la méthode de génération.

Pour savoir comment inspecter la configuration de génération d’un modèle, quelles sont les valeurs par défaut, comment modifier les paramètres ad hoc, et comment créer et enregistrer une configuration de génération personnalisée, consultez le guide des stratégies de génération de texte. Le guide explique également comment utiliser des fonctionnalités associées, comme le streaming de jetons.

GenerationConfig

classe transformers.GenerationConfig

< >

( **kwargs )

Paramètres qui contrôlent la longueur de la sortie

  • max_length (int, facultatif) — max_new_tokens est recommandé pour contrôler le nombre de jetons générés par le modèle. max_length est conservé pour la rétrocompatibilité.
  • max_new_tokens (int, facultatif) — Le nombre maximal de jetons à générer, en ignorant le nombre de jetons du prompt.
  • min_length (int, facultatif) — La longueur minimale de la séquence à générer. Correspond à la longueur du prompt d’entrée + min_new_tokens. Son effet est écrasé par min_new_tokens, si celui-ci est également défini.
  • min_new_tokens (int, facultatif) — Le nombre minimal de jetons à générer, en ignorant le nombre de jetons du prompt.
  • early_stopping (bool ou str, facultatif) — Contrôle la condition d’arrêt des méthodes basées sur les faisceaux, comme beam-search. Il accepte les valeurs suivantes : True, où la génération s’arrête dès qu’il y a num_beams candidats complets ; False, où une heuristique est appliquée et la génération s’arrête lorsqu’il est très peu probable de trouver de meilleurs candidats ; "never", où la procédure de beam search ne s’arrête que lorsqu’il ne peut plus y avoir de meilleurs candidats (algorithme de beam search canonique).
  • max_time (float, facultatif) — La durée maximale, en secondes, que vous autorisez pour l’exécution du calcul. La génération terminera tout de même le passage en cours une fois le temps alloué dépassé.
  • stop_strings (str ou list[str], facultatif) — Une chaîne de caractères ou une liste de chaînes de caractères qui doivent mettre fin à la génération si le modèle les produit.

Paramètres qui contrôlent la stratégie de génération utilisée

  • do_sample (bool) — Indique s'il faut utiliser l'échantillonnage ; sinon, le décodage glouton est utilisé.
  • num_beams (int, facultatif) — Nombre de faisceaux pour la recherche par faisceaux. 1 signifie qu'aucune recherche par faisceaux n'est effectuée.
  • use_mtp — (bool) : Indique s'il faut utiliser la Multi-Token Prediction (MTP) si le modèle la prend en charge.

Paramètres qui contrôlent le cache

  • use_cache (bool) — Indique si le modèle doit utiliser les clés/valeurs d'attention des derniers pas (si applicable au modèle) pour accélérer le décodage.
  • cache_implementation (str, facultatif) — Nom de la classe de cache qui sera instanciée dans generate, pour un décodage plus rapide. Les valeurs possibles sont :

    Si aucune n'est spécifiée, nous utiliserons le cache par défaut du modèle (souvent DynamicCache). Consultez notre documentation sur les caches pour plus d'informations.

  • cache_config (dict, facultatif, par défaut None) — Les arguments utilisés dans la classe de cache clé-valeur peuvent être passés dans cache_config.
  • max_cache_len (int, facultatif) — Utilisé uniquement avec les caches statiques (cache_implementation défini sur "static" ou "offloaded_static"). Pré-dimensionne le cache à cette longueur au lieu de la max_length de l’appel en cours. Définissez-le une seule fois à la valeur de l’appel le plus long que vous prévoyez, afin que les appels répétés de generate() avec un prompt plus long ou une valeur plus élevée de max_new_tokens (jusqu’à cette limite) réutilisent le même cache au lieu de déclencher une réallocation et une recompilation par torch.compile.

Paramètres pour la manipulation des logits de sortie du modèle

  • temperature (float, facultatif) — La valeur utilisée pour moduler les probabilités du jeton suivant. Cette valeur est définie dans le fichier generation_config.json du modèle. Si elle n’est pas définie, la valeur par défaut est 1.0
  • top_k (int, facultatif) — Le nombre de jetons du vocabulaire ayant la plus haute probabilité à conserver pour le filtrage top-k. Cette valeur est définie dans le fichier generation_config.json d’un modèle. Si elle n’est pas définie, la valeur par défaut est 50.
  • top_p (float, facultatif) — Si défini sur un float < 1, seul l’ensemble minimal de jetons les plus probables dont les probabilités cumulées atteignent top_p ou plus est conservé pour la génération. Cette valeur est définie dans le fichier generation_config.json du modèle. Si elle n’est pas définie, la valeur par défaut est 1.0
  • min_p (float, facultatif) — Probabilité minimale du jeton, qui sera mise à l’échelle par la probabilité du jeton le plus probable. Elle doit être une valeur comprise entre 0 et 1. Les valeurs typiques se situent dans la plage 0,01-0,2, avec une sélectivité comparable à celle obtenue en réglant top_p dans la plage 0,99-0,8 (utilisez l’opposé des valeurs habituelles de top_p).
  • top_h (float, facultatif) — Facteur d’échelle du budget d’entropie, qui contrôle la part de l’entropie de la distribution conservée lors de l’échantillonnage. Doit être une valeur comprise entre 0 et 1. À chaque étape, les jetons sont triés par probabilité, et le plus petit préfixe de jetons dont l’entropie renormalisée est inférieure ou égale à top_h fois l’entropie de la distribution complète est conservé. Les valeurs plus faibles (par ex. 0,2–0,5) produisent des sorties plus ciblées et déterministes, tandis que les valeurs proches de 1,0 autorisent plus d’aléatoire et de diversité. Les valeurs typiques se situent dans la plage 0,3–0,6.
  • typical_p (float, facultatif) — La mesure de typicalité locale évalue à quel point la probabilité conditionnelle de prédire le jeton cible suivant est proche de la probabilité conditionnelle attendue de prédire un jeton aléatoire suivant, étant donné le texte partiel déjà généré. Si définie sur une valeur float < 1, l’ensemble le plus petit de jetons les plus localement typiques, dont les probabilités s’additionnent à typical_p ou plus, est conservé pour la génération. Voir cet article pour plus de détails.
  • epsilon_cutoff (float, facultatif) — Si défini sur un float strictement compris entre 0 et 1, seuls les jetons dont la probabilité conditionnelle est supérieure à epsilon_cutoff seront échantillonnés. Dans l’article, les valeurs suggérées vont de 3e-4 à 9e-4, en fonction de la taille du modèle. Voir Truncation Sampling as Language Model Desmoothing pour plus de détails.
  • eta_cutoff (float, facultatif) — L'échantillonnage Eta est un hybride de l'échantillonnage typique local et de l'échantillonnage epsilon. S'il est défini sur un float strictement compris entre 0 et 1, un jeton n'est pris en compte que s'il est supérieur à eta_cutoff ou à sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). Ce dernier terme correspond intuitivement à la probabilité du jeton suivant attendu, mise à l'échelle par sqrt(eta_cutoff). Dans l'article, les valeurs suggérées vont de 3e-4 à 2e-3, selon la taille du modèle. Consultez Truncation Sampling as Language Model Desmoothing pour plus de détails.
  • repetition_penalty (float, facultatif) — Le paramètre de pénalité de répétition. 1.0 signifie qu’il n’y a pas de pénalité. Voir ce papier pour plus de détails.
  • encoder_repetition_penalty (float, facultatif) — Le paramètre pour encoder_repetition_penalty. Une pénalité exponentielle appliquée aux séquences qui ne figurent pas dans l’entrée d’origine. 1.0 signifie qu’aucune pénalité n’est appliquée.
  • length_penalty (float, facultatif) — Pénalité exponentielle appliquée à la longueur, utilisée lors de la génération par faisceau. Elle est appliquée comme exposant à la longueur de la séquence, qui est ensuite utilisée pour diviser le score de la séquence. Étant donné que le score est la log vraisemblance de la séquence (c’est-à-dire négative), length_penalty > 0.0 favorise les séquences plus longues, tandis que length_penalty < 0.0 encourage les séquences plus courtes.
  • no_repeat_ngram_size (int, facultatif) — Si défini sur un int > 0, tous les n-grammes de cette taille ne peuvent apparaître qu’une seule fois.
  • bad_words_ids (list[list[int]], facultatif) — Liste de listes d’identifiants de jetons qui ne sont pas autorisés à être générés. Consultez NoBadWordsLogitsProcessor pour une documentation et des exemples supplémentaires.
  • renormalize_logits (bool) — Indique s'il faut renormaliser les logits après l'application de tous les processeurs de logits (y compris les personnalisés). Il est fortement recommandé de définir ce drapeau sur True, car les algorithmes de recherche supposent que les logits de score sont normalisés, mais certains processeurs de logits brisent cette normalisation.
  • forced_bos_token_id (int, facultatif, par défaut model.config.forced_bos_token_id) — L’identifiant du jeton à forcer comme premier jeton généré après le decoder_start_token_id. Utile pour les modèles multilingues comme mBART où le premier jeton généré doit être le jeton de la langue cible.
  • 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) — Indique s'il faut supprimer les éventuelles sorties nan et inf du modèle afin d'empêcher la méthode de génération de planter. Notez que l'utilisation de remove_invalid_values peut ralentir la génération.
  • exponential_decay_length_penalty (tuple(int, float), facultatif) — Ce Tuple ajoute une pénalité de longueur à croissance exponentielle, après la génération d'un certain nombre de jetons. Le tuple doit être composé de : (start_index, decay_factor) où start_index indique le point de départ de la pénalité et decay_factor représente le facteur de décroissance exponentielle
  • suppress_tokens (list[int], facultatif) — Une liste de jetons qui seront supprimés lors de la génération. Le processeur de logits SuppressTokens définira leurs probabilités de log à -inf afin qu'ils ne soient pas échantillonnés.
  • begin_suppress_tokens (list[int], facultatif) — Une liste de jetons qui seront supprimés au début de la génération. Le processeur de logits SuppressBeginTokens définira leurs probabilités de log à -inf afin qu'ils ne soient pas échantillonnés.
  • sequence_bias (dict[tuple[int], float], facultatif) — Dictionnaire qui associe une séquence de jetons à son terme de biais. Les biais positifs augmentent les probabilités que la séquence soit sélectionnée, tandis que les biais négatifs font l’inverse. Consultez SequenceBiasLogitsProcessor pour une documentation et des exemples supplémentaires.
  • token_healing (bool) — Répare les jetons de fin des prompts en les remplaçant par leurs extensions appropriées. Cela améliore la qualité des complétions pour les prompts affectés par le biais de tokenisation gloutonne.
  • guidance_scale (float, facultatif) — L'échelle de guidage pour le guidage sans classifieur (CFG). Le CFG est activé en définissant guidance_scale > 1. Une échelle de guidage plus élevée encourage le modèle à générer des échantillons plus étroitement liés au prompt d'entrée, généralement au détriment de la qualité.
  • watermarking_config (BaseWatermarkingConfig ou dict, facultatif) — Arguments utilisés pour apposer un filigrane sur les sorties du modèle en ajoutant un petit biais à un ensemble aléatoire de jetons « verts ». Consultez la documentation de SynthIDTextWatermarkingConfig et de WatermarkingConfig pour plus de détails. S’il est passé sous forme de Dict, il sera converti en WatermarkingConfig en interne.

Paramètres qui définissent les variables de sortie de generate

  • num_return_sequences (int, facultatif) — Le nombre de séquences retournées, calculées de manière indépendante, pour chaque élément du lot.
  • output_attentions (bool) — Indique s'il faut retourner les tenseurs d'attentions de toutes les couches d'attention. Voir attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • output_scores (bool) — Indique s'il faut ou non retourner les scores de prédiction. Voir scores sous les tenseurs retournés pour plus de détails.
  • output_logits (bool) — Whether or not to return the unprocessed prediction logit scores. See logits under returned tensors for more details.
  • return_dict_in_generate (bool) — Indique s'il faut retourner un ModelOutput, par opposition à retourner uniquement la séquence générée. Ce drapeau doit être défini sur True pour retourner le cache de génération (lorsque use_cache est True) ou les sorties optionnelles (voir les drapeaux commençant par output_)

Jetons spéciaux qui peuvent être utilisés lors de la génération

  • pad_token_id (int, facultatif) — L'identifiant du jeton de remplissage.
  • bos_token_id (int, facultatif) — L’identifiant du jeton de début de séquence.
  • eos_token_id (Union[int, list[int]], facultatif) — L’identifiant du jeton end-of-sequence. Facultativement, utilisez une liste pour définir plusieurs jetons end-of-sequence.

Paramètres de génération exclusifs aux modèles encodeur-décodeur

  • encoder_no_repeat_ngram_size (int, facultatif) — Si défini sur un int > 0, tous les n-grammes de cette taille présents dans encoder_input_ids ne peuvent pas apparaître dans decoder_input_ids.
  • decoder_start_token_id (int ou list[int], facultatif) — Si un modèle encodeur-décodeur commence le décodage avec un jeton différent de bos, l’identifiant de ce jeton ou une liste de longueur batch_size. Indiquer une liste permet d’utiliser des identifiants de départ différents pour chaque élément du lot (par exemple, des modèles multilingues avec des langues cibles différentes dans un même lot)

Paramètres de génération exclusifs à la génération d'assistant

  • is_assistant (bool) — Indique si le modèle est un modèle assistant (brouillon).
  • num_assistant_tokens (int, facultatif) — Définit le nombre de jetons spéculatifs qui doivent être générés par le modèle assistant avant d’être vérifiés par le modèle cible à chaque itération. Des valeurs plus élevées pour num_assistant_tokens rendent la génération plus spéculative : si le modèle assistant est performant, des accélérations plus importantes peuvent être obtenues ; si le modèle assistant nécessite de nombreuses corrections, les accélérations obtenues seront plus faibles.
  • num_assistant_tokens_schedule (str, facultatif) — Définit le calendrier selon lequel le nombre maximal de jetons de l'assistant doit être modifié pendant l'inférence.
    • "heuristic" : lorsque tous les jetons spéculatifs sont corrects, augmente num_assistant_tokens de 2, sinon réduis-le de 1. La valeur de num_assistant_tokens est conservée sur plusieurs appels de génération avec le même modèle assistant.
    • "heuristic_transient" : Identique à "heuristic", mais num_assistant_tokens est réinitialisé à sa valeur initiale après chaque appel de génération.
    • "constant" : num_assistant_tokens reste inchangé pendant la génération
  • assistant_confidence_threshold (float, facultatif) — Seuil de confiance pour le modèle assistant. Si la confiance du modèle assistant dans sa prédiction pour le jeton actuel est inférieure à ce seuil, le modèle assistant arrête l’itération de génération du jeton en cours, même si le nombre de jetons spéculatifs (défini par num_assistant_tokens) n’a pas encore été atteint. Le seuil de confiance de l’assistant est ajusté au fil des itérations spéculatives afin de réduire le nombre de passages avant inutiles du modèle de brouillon et du modèle cible, avec une tendance à éviter les faux négatifs. La valeur de assistant_confidence_threshold est conservée sur plusieurs appels de génération avec le même modèle assistant. Il s’agit d’une version non supervisée du Dynamic Speculation Lookahead de Dynamic Speculation Lookahead Accelerates Speculative Decoding of Large Language Models https://huggingface.co/papers/2405.04304.
  • prompt_lookup_num_tokens (int, facultatif) — Le nombre de jetons à produire en tant que jetons candidats.
  • max_matching_ngram_size (int, facultatif) — Taille maximale des n-grammes à prendre en compte pour la correspondance dans le prompt. La valeur par défaut est 2 si aucune valeur n’est fournie.
  • assistant_early_exit(int, optional) — Si défini sur un entier positif, la sortie anticipée du modèle sera utilisée comme assistant. Ne peut être utilisé qu’avec des modèles prenant en charge la sortie anticipée (c’est-à-dire des modèles dont les logits des couches intermédiaires peuvent être interprétés par la tête du LM).
  • assistant_lookbehind(int, optionnel) — Si défini sur un entier positif, le processus de réencodage prendra également en compte les assistant_lookbehind derniers jetons de l’assistant pour aligner correctement les jetons. Ne peut être utilisé qu’avec des tokenizers différents dans le décodage spéculatif. Voir ce blog pour plus de détails.
  • target_lookbehind(int, facultatif) — Si défini sur un entier positif, le processus de réencodage prendra également en compte les target_lookbehind derniers jetons cibles pour aligner correctement les jetons. Ne peut être utilisé qu’avec des tokenizers différents dans le décodage spéculatif. Voir ce blog pour plus de détails.
  • assistant_ensemble_weight (float, facultatif) — Active la vérification d’ensemble statique dans le décodage spéculatif. Si définie avec une valeur dans (0.0, 1.0), le vérificateur accepte les jetons par rapport au mélange w * p_target + (1 - w) * q_draft au lieu de p_target, échangeant un biais distributionnel contrôlé contre un taux d’acceptation plus élevé. La valeur par défaut est None, ce qui maintient le décodage sans perte. Nécessite que le modèle assistant retourne des logits, il n’est donc pas compatible avec le décodage par recherche de prompt.
  • speculation_type (str, facultatif) — Le type de spéculation demandé. Les valeurs acceptées sont dflash.

Paramètres liés aux performances et à la compilation

  • compile_config (CompileConfig, facultatif) — Lors de l'utilisation d'un cache compilable, ce paramètre contrôle la manière dont generate compile le passage avant pour une inférence plus rapide.
  • disable_compile (bool) — Indique s'il faut désactiver la compilation automatique du passage avant. La compilation automatique a lieu lorsque des critères spécifiques sont remplis, notamment l'utilisation d'un cache compilable. Veuillez ouvrir un ticket si vous constatez le besoin d'utiliser ce drapeau.

Classe qui contient une configuration pour une tâche de génération. Un appel generate prend en charge les méthodes de génération suivantes pour les modèles text-to-text, text-to-text, speech-to-text et vision-to-text :

  • décodage glouton si num_beams=1 et do_sample=False
  • échantillonnage multinomial si num_beams=1 et do_sample=True
  • décodage par recherche en faisceau si num_beams>1 et do_sample=False
  • échantillonnage multinomial avec beam-search si num_beams>1 et do_sample=True
  • décodage assisté si assistant_model ou prompt_lookup_num_tokens est passé à .generate()

Pour en savoir plus sur les stratégies de décodage, consultez le guide des stratégies de génération de texte.

Un grand nombre de ces drapeaux contrôlent les logits ou les critères d’arrêt de la génération. Assurez-vous de consulter les classes liées à generate pour une description complète des manipulations possibles, ainsi que des exemples de leur utilisation.

Note : les champs de configuration qui sont encore None seront remplacés par GenerationConfig._get_default_generation_params() pendant la boucle de génération. Si vous souhaitez utiliser des valeurs différentes pour ces champs, assurez-vous de les définir explicitement dans la configuration de génération.

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

Paramètres

  • pretrained_model_name (str ou os.PathLike) — Cela peut être soit :
    • une chaîne de caractères, l'identifiant du modèle d'une configuration de modèle pré-entraîné hébergée dans un dépôt de modèles sur huggingface.co.
    • un chemin vers un dossier contenant un fichier de configuration enregistré à l’aide de la méthode save_pretrained(), par exemple ./my_model_directory/.
  • config_file_name (str ou os.PathLike, facultatif, par défaut "generation_config.json") — Nom du fichier JSON de configuration de génération à charger depuis pretrained_model_name.
  • cache_dir (str ou os.PathLike, facultatif) — Chemin vers un répertoire dans lequel la configuration d'un modèle pré-entraîné téléchargé doit être mise en cache si le cache standard ne doit pas être utilisé.
  • force_download (bool, facultatif, par défaut False) — Indique s'il faut forcer le (re)téléchargement des fichiers de configuration et remplacer les versions en cache si elles existent.
  • proxies (dict[str, str], facultatif) — Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Les proxys sont utilisés pour chaque requête.
  • token (str ou bool, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si True, ou non spécifié, utilisera le jeton généré lors de l’exécution de hf auth login (stocké dans ~/.huggingface).
  • revision (str, facultatif, par défaut "main") — La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag ou d'un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, donc revision peut être n'importe quel identifiant autorisé par git.

    Pour tester une pull request que vous avez créée sur le Hub, vous pouvez passer revision="refs/pr/<pr_number>".

  • return_unused_kwargs (bool, facultatif, défaut False) — Si False, alors cette fonction renvoie uniquement l'objet de configuration final.

    Si True, cette fonction renvoie un Tuple(config, unused_kwargs) où unused_kwargs est un dictionnaire composé des paires clé/valeur dont les clés ne sont pas des attributs de configuration : c'est-à-dire la partie de kwargs qui n'a pas été utilisée pour mettre à jour config et qui est autrement ignorée.

  • subfolder (str, facultatif, par défaut "") — Si les fichiers pertinents se trouvent dans un sous-dossier du dépôt de modèle sur huggingface.co, vous pouvez spécifier le nom du dossier ici.
  • kwargs (dict[str, Any], facultatif) — Les valeurs de kwargs correspondant à des attributs de configuration sont utilisées pour remplacer les valeurs chargées. Le comportement concernant les paires clé/valeur dont les clés ne sont pas des attributs de configuration est contrôlé par le paramètre mot-clé return_unused_kwargs.

L'objet de configuration instancié à partir de ce modèle pré-entraîné.

Instanciez un GenerationConfig à partir d'un fichier de configuration de génération.

Exemples :

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

Paramètres

  • model_config (PreTrainedConfig | dict) — La configuration du modèle qui sera utilisée pour instancier la configuration de génération.

L'objet de configuration instancié à partir de ces paramètres.

Instancie un GenerationConfig à partir d'un PreTrainedConfig. Cette fonction est utile pour convertir les objets PreTrainedConfig hérités, qui peuvent contenir des paramètres de génération, en un GenerationConfig autonome.

save_pretrained

< >

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

Paramètres

  • save_directory (str ou os.PathLike) — Répertoire où le fichier JSON de configuration sera enregistré (il sera créé s'il n'existe pas).
  • config_file_name (str ou os.PathLike, facultatif, par défaut "generation_config.json") — Nom du fichier JSON de configuration de génération à enregistrer dans save_directory.
  • push_to_hub (bool, facultatif, par défaut False) — Indique s'il faut ou non pousser votre modèle sur le hub de modèles Hugging Face après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avec repo_id (par défaut, il s'agit du nom de save_directory dans votre espace de noms).
  • kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à la méthode push_to_hub().

Enregistrer un objet de configuration de génération dans le répertoire save_directory afin qu'il puisse être rechargé à l'aide de la méthode de classe from_pretrained().

update

< >

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

Paramètres

  • defaults_only (bool, facultatif, valeur par défaut False) — Indique s'il faut mettre à jour toutes les clés de la configuration avec kwargs ou uniquement celles qui sont définies sur None (c'est-à-dire la valeur par défaut).
  • allow_custom_entries (bool, facultatif, valeur par défaut False) — Indique s'il est possible de mettre à jour les entrées personnalisées de la configuration avec kwargs si elles ne sont pas présentes dans la configuration actuelle.
  • kwargs (dict[str, Any]) — Dictionnaire d'attributs à mettre à jour de manière provisoire pour cette classe.

Retourne

dict[str, Any]

Dictionnaire contenant toutes les paires clé-valeur qui n'ont pas été utilisées pour mettre à jour l'instance.

Met à jour les attributs de cette instance de classe avec les attributs de kwargs s’ils correspondent à des attributs existants, et renvoie tous les kwargs non utilisés.

validate

< >

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

Paramètres

  • strict (bool) — Si True, lève une exception pour tout problème détecté. Si False, ne journalise que les problèmes.
  • user_set_attributes (set[str], facultatif) — Noms des attributs explicitement fournis par l’appelant. Lorsqu’ils sont fournis, les avertissements de « problème mineur » concernant des combinaisons de drapeaux conflictuelles (par exemple, des drapeaux de sampling uniquement définis alors que do_sample=False) ne se déclenchent que si le drapeau en conflit est présent dans cet ensemble — évitant ainsi des avertissements superflus lorsque la valeur a été héritée de la configuration par défaut generation_config.json du modèle. Lorsque None, tous les attributs définis sont considérés comme définis par l’utilisateur (comportement rétrocompatible pour les appels directs à validate()).

Valide les valeurs des attributs de l’instance GenerationConfig. Lève des exceptions en présence d’une paramétrisation détectable comme incorrecte à partir de l’instance de configuration seule.

Notez que certains paramètres non validés ici sont mieux validés lors de l'exécution de la génération, car ils peuvent dépendre d'autres entrées et/ou du modèle, comme les paramètres liés à la longueur de la génération.

get_generation_mode

< >

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

Paramètres

  • assistant_model (PreTrainedModel, facultatif) — Le modèle assistant à utiliser pour la génération assistée. S'il est défini, le mode de génération sera la génération assistée.

Retourne

GenerationMode

Le mode de génération déclenché par l'instance.

Retourne le mode de génération déclenché par l'instance GenerationConfig.

GenerationMixin

classe transformers.GenerationMixin

< >

( )

Une classe contenant toutes les fonctions de génération de texte auto-régressive, à utiliser en tant que mixin dans les classes de modèles. Hériter de cette classe confère au modèle un comportement spécifique lié à la génération, tel que le chargement d'un GenerationConfig lors de l'initialisation ou la garantie que les tests liés à generate sont exécutés dans la CI de transformers.

Une classe de modèle doit hériter de GenerationMixin pour permettre l'appel de méthodes telles que generate, ou lorsqu'elle a défini une méthode generate personnalisée qui s'appuie sur GenerationMixin, directement ou indirectement, et qui partage approximativement la même interface pour les méthodes publiques telles que generate. Trois exemples :

  • LlamaForCausalLM doit hériter de GenerationMixin pour permettre l’appel de generate et des autres méthodes publiques du mixin ;
  • BlipForQuestionAnswering possède une méthode generate personnalisée qui partage approximativement la même interface que GenerationMixin.generate (elle comporte quelques arguments supplémentaires et le même résultat). Cette fonction appelle également GenerationMixin.generate indirectement, via un modèle interne. En conséquence, BlipForQuestionAnswering devrait hériter de GenerationMixin afin de bénéficier de toute l’automatisation liée à la génération dans notre base de code ;
  • BarkModel possède une méthode generate personnalisée et l’un de ses modèles internes appelle GenerationMixin.generate. Cependant, son generate ne partage pas la même interface que GenerationMixin.generate. Dans ce cas, BarkModel ne doit PAS hériter de GenerationMixin, car cela casse l’interface de generate.

La classe expose generate(), qui peut être utilisé pour :

  • décodage glouton si num_beams=1 et do_sample=False
  • échantillonnage multinomial si num_beams=1 et do_sample=True
  • décodage par recherche en faisceau si num_beams>1 et do_sample=False
  • échantillonnage multinomial avec beam-search si num_beams>1 et do_sample=True
  • décodage assisté si assistant_model ou prompt_lookup_num_tokens est passé à .generate()

Pour en savoir plus sur les stratégies de décodage, consultez le guide des stratégies de génération de texte.

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

Paramètres

  • inputs (torch.Tensor de forme variable selon la modalité, facultatif) — La séquence utilisée comme invite pour la génération ou comme entrées du modèle pour l’encodeur. Si None, la méthode l’initialise avec bos_token_id et une taille de lot de 1. Pour les modèles uniquement décodeurs, inputs doit être au format de input_ids. Pour les modèles encodeur-décodeur, inputs peut représenter l’un des input_ids, input_values, input_features ou pixel_values.
  • generation_config (GenerationConfig, facultatif) — La configuration de génération à utiliser comme paramétrage de base pour l’appel de génération. Les **kwargs transmis à generate qui correspondent aux attributs de generation_config les remplaceront. Si generation_config n’est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle generation_config.json, s’il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de GenerationConfig, dont la documentation doit être consultée pour paramétrer la génération.
  • logits_processor (LogitsProcessorList, facultatif) — Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut construits à partir des arguments et de la configuration de génération. Si un processeur de logits est transmis qui a déjà été créé avec les arguments ou une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés.
  • stopping_criteria (StoppingCriteriaList, facultatif) — Critères d’arrêt personnalisés qui complètent les critères d’arrêt par défaut construits à partir des arguments et d’une configuration de génération. Si un critère d’arrêt est transmis qui a déjà été créé à partir des arguments ou d’une configuration de génération, une erreur est levée. Si votre critère d’arrêt dépend de l’entrée scores, assurez-vous de passer return_dict_in_generate=True, output_scores=True à generate. Cette fonctionnalité est destinée aux utilisateurs avancés.
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]], facultatif) — Si fourni, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si non fourni, aucune contrainte n'est appliquée. Cette fonction prend 2 arguments : l'identifiant du lot batch_id et input_ids. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lot batch_id et les jetons générés précédemment inputs_ids. Cet argument est utile pour la génération contrainte conditionnée par le préfixe, comme décrit dans Autoregressive Entity Retrieval.
  • synced_gpus (bool, facultatif) — Indique s'il faut continuer à exécuter la boucle while jusqu'à max_length. Sauf si cette valeur est remplacée, ce drapeau est défini sur True lors de l'utilisation de FullyShardedDataParallel ou de DeepSpeed ZeRO Stage 3 avec plusieurs GPU, afin d'éviter tout blocage si un GPU termine la génération avant les autres. Sinon, la valeur par défaut est False.
  • assistant_model (PreTrainedModel, facultatif) — Un modèle assistant pouvant être utilisé pour accélérer la génération. Le modèle assistant doit utiliser exactement le même tokenizer. L’accélération est obtenue lorsque la prédiction des jetons candidats par le modèle assistant est beaucoup plus rapide que l’exécution de la génération avec le modèle dont vous appelez la méthode generate. En conséquence, le modèle assistant doit être beaucoup plus petit.
  • streamer (BaseStreamer, facultatif) — Objet de diffusion utilisé pour diffuser les séquences générées. Les jetons générés sont transmis via streamer.put(token_ids) et l’objet est responsable de tout traitement ultérieur.
  • negative_prompt_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Le prompt négatif requis par certains processeurs tels que CFG. La taille du lot doit correspondre à la taille du lot d’entrée. Il s’agit d’une fonctionnalité expérimentale, susceptible de subir des modifications cassant l’API dans les versions futures.
  • negative_prompt_attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Attention_mask pour negative_prompt_ids.
  • custom_generate (str ou Callable, facultatif) — L'une des options suivantes :
    • str (nom du dépôt Hugging Face Hub) : exécute la fonction generate personnalisée définie dans custom_generate/generate.py de ce dépôt à la place de la méthode standard generate. Le dépôt remplace entièrement la logique de génération, et le type de retour peut différer.
    • str (chemin du dépôt local) : identique à ce qui précède, mais à partir d’un chemin local. Les répertoires locaux nécessitent également trust_remote_code=True car le fichier local custom_generate/generate.py est exécuté.
    • Callable : generate effectuera les étapes habituelles de préparation des entrées, puis appellera le callable fourni pour exécuter la boucle de décodage. Pour plus d’informations, consultez la documentation.
  • kwargs (dict[str, Any], facultatif) — Paramétrage ad hoc de generation_config et/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonction forward du modèle. Si le modèle est un modèle encodeur-décodeur, les kwargs spécifiques à l'encodeur ne doivent pas être préfixés et les kwargs spécifiques au décodeur doivent être préfixés par decoder_.

Retourne

ModelOutput ou torch.LongTensor

Un ModelOutput (si return_dict_in_generate=True ou lorsque config.return_dict_in_generate=True) ou un torch.LongTensor.

Si le modèle n'est pas un modèle encodeur-décodeur (model.config.is_encoder_decoder=False), les types ModelOutput possibles sont :

Si le modèle est un modèle encodeur-décodeur (model.config.is_encoder_decoder=True), les types ModelOutput possibles sont :

Génère des séquences d'identifiants de jetons pour les modèles dotés d'une tête de modélisation de langage.

La plupart des paramètres de contrôle de la génération sont définis dans generation_config qui, s'il n'est pas transmis, sera défini sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quel generation_config en transmettant les paramètres correspondants à generate(), par exemple .generate(inputs, num_beams=4, do_sample=True).

Pour un aperçu des stratégies de génération et des exemples de code, consultez le guide suivant.

compute_transition_scores

< >

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

Paramètres

  • sequences (torch.LongTensor) — Les séquences générées. La deuxième dimension (sequence_length) est soit égale à max_length, soit plus courte si tous les lots se sont terminés prématurément en raison de eos_token_id.
  • scores (tuple(torch.Tensor)) — Scores de transition pour chaque jeton du vocabulaire à chaque étape de génération. Scores de transition de faisceau composés des probabilités logarithmiques des jetons conditionnées sur le log softmax des jetons précédemment générés dans ce faisceau. Tuplet de torch.Tensor avec au plus max_new_tokens éléments (un élément pour chaque jeton généré), chaque tenseur ayant la forme (batch_size*num_beams, config.vocab_size).
  • beam_indices (torch.LongTensor, facultatif) — Indices des faisceaux des identifiants de jetons générés à chaque étape de génération. torch.LongTensor de forme (batch_size*num_return_sequences, sequence_length). Requis uniquement si num_beams>1 au moment de la génération.
  • normalize_logits (bool, facultatif, par défaut False) — Indique s'il faut normaliser les logits (qui, pour des raisons de rétrocompatibilité, peuvent ne pas l'être).

Retourne

torch.Tensor

Un torch.Tensor de forme (batch_size*num_return_sequences, sequence_length) contenant les scores de transition (logits)

Calcule les scores de transition des séquences à partir des scores de génération (et des indices de faisceau, si la recherche par faisceau a été utilisée). Il s'agit d'une méthode pratique pour obtenir rapidement les scores des jetons sélectionnés au moment de la génération.

Exemples :

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

classe transformers.ContinuousMixin

< >

( )

Classe de mixin pour les modèles afin d'ajouter les capacités de lotissement continu. Le lotissement continu comporte trois points d'entrée :

  • init_continuous_batching, qui est le point d’entrée réel pour le batch continu
  • continuous_batching_context_manager, qui est lui-même un wrapper autour de init_continuous_batching
  • generate_batch, qui est en réalité un wrapper autour de continuous_batching_context_manager

Ils sont définis dans cet ordre. Tout apport effectué sur l’un de ces trois points d’entrée doit être reflété dans les deux autres.

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 gestionnaire de contexte pour utiliser en toute sécurité le gestionnaire de lotissement continu. Les arguments sont similaires à ceux de init_continuous_batching, à l'exception de :

  • block : indique s'il faut bloquer le thread lors de l'arrêt du gestionnaire. La valeur par défaut est True.
  • timeout : durée maximale d'attente pour l'arrêt du thread. La valeur par défaut est None (aucun délai d'attente).
  • warmup : indique s'il faut pré-capturer les graphes CUDA aux tailles maximales avant l'exécution. La valeur par défaut est True.

destroy_cached_continuous_batching_manager

< >

( )

Détruire le gestionnaire de lotissement continu mis en cache et libérer les ressources 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]

Paramètres

  • inputs — Liste de séquences de jetons d'entrée (invites)
  • generation_config — Configuration de génération facultative
  • continuous_batching_config — Configuration optionnelle du lotissement continu
  • record_timestamps — Si défini sur true, les requêtes auront un horodatage pour chaque jeton généré
  • progress_bar — Si défini sur true, une barre de progression sera affichée
  • persistent_manager — permet de conserver le gestionnaire après la fin de la génération. La valeur par défaut est False.
  • warmup — indique s'il faut pré-capturer les graphes CUDA avant de traiter les requêtes. La valeur par défaut est True.

Retourne

dict[str, GenerationOutput]

un dictionnaire d'identifiants de requêtes vers des objets GenerationOutput

Générer des séquences pour un lot de prompts en utilisant le batchage continu.

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

Paramètres

  • generation_config — Configuration de génération facultative, pouvant contenir un objet CompileConfig
  • continuous_batching_config — Configuration de batch continu facultative
  • workload_hints — WorkloadHints facultatives pour aider le gestionnaire de continuous batching à prendre de meilleures décisions concernant les valeurs par défaut

Retourne

ContinuousBatchingManager

L'instance du gestionnaire à laquelle ajouter des requêtes et d'où récupérer les résultats.

Initialiser un gestionnaire pour l’inférence par lot continu.

ContinuousBatchingManager

classe transformers.ContinuousBatchingManager

< >

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

Gestionnaire pour la gestion du lotissement continu des requêtes de génération. Il fournit une interface utilisateur pour soumettre des requêtes de génération, récupérer les résultats et gérer le thread de génération en arrière-plan. Cette classe ne doit pas être créée directement, mais via l'un des points d'entrée suivants (toutes les méthodes du 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

Paramètres

  • input_ids — Identifiants des jetons d'entrée à utiliser comme invite
  • request_id — ID de demande personnalisé facultatif (généré automatiquement si None)
  • max_new_tokens — Nombre maximal de nouveaux jetons à générer
  • streaming — Indique s'il faut diffuser les jetons au fur et à mesure de leur génération
  • record_timestamps — Indique s'il faut enregistrer les horodatages pour chaque jeton généré
  • eos_token_id — ID(s) du jeton de fin de séquence
  • logit_processor_kwargs — Arguments par mot-clé pour le processeur de logits.

Retourne

str | None

L'identifiant de la requête si le processus est un pilote TP, None sinon.

Ajoute une nouvelle requête de génération à la file d’attente. Si le processus n’est pas un pilote TP, cette opération est sans effet.

add_requests

< >

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

Fonction utilitaire pour mettre en lot add_request et retourner leurs identifiants. Consultez sa documentation pour plus de détails.

cancel_request

< >

( request_id: str )

Annuler une requête par son identifiant. Si cette méthode est appelée depuis un processus qui n'est pas un pilote TP, elle n'a aucun effet : seuls les processus pilotes TP interagissent avec le gestionnaire.

destroy

< >

( )

Termine le gestionnaire et libère les ressources distribuées. Il est sûr d'appeler cette méthode plusieurs fois. Après cet appel, le gestionnaire ne peut plus être redémarré.

get_result

< >

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

Récupère un résultat depuis la file de sortie. Si un identifiant est fourni, renvoie la première requête correspondante. Si un délai d’attente est fourni, renvoie None après expiration du délai (en secondes).

is_running

< >

( )

Retourne True si le thread de génération en arrière-plan a été démarré et est toujours actif.

join

< >

( stop_trigger_time: floattimeout: float | None = None )

Attendez que le thread en arrière-plan se termine. L'attente peut être limitée à l'aide de l'argument timeout (en secondes).

pause

< >

( )

Un gestionnaire de contexte qui met en pause la boucle de génération, afin que le thread appelant puisse utiliser le modèle, typiquement pour le mettre à jour sur place. Le thread n'entre dans ce contexte qu'une fois la boucle en pause, et la boucle reprend à la sortie, en conservant son cache et ses requêtes en cours : rien n'est vidangé et aucune requête n'est perdue. Plusieurs threads peuvent maintenir la pause simultanément, et la boucle reprend dès que le dernier en sort. Si le TP est activé, tous les rangs doivent entrer dans ce contexte, sinon les autres rangs resteront bloqués indéfiniment.

register_result_handler

< >

( request_id: strcallback: Callable )

Paramètres

  • request_id (str) — L'identifiant de la requête pour laquelle recevoir les sorties.
  • callback (callable) — Appelé avec un GenerationOutput pour chaque résultat.

Enregistrer un rappel pour la livraison des résultats (en streaming ou non).

Le rappel est invoqué sur la boucle d’événements via call_soon_threadsafe à chaque fois qu’un résultat est produit pour cette requête. Pour les requêtes en streaming, cela se produit à chaque jeton ; pour les requêtes non-streaming, uniquement à la fin. Le gestionnaire est automatiquement nettoyé lorsque la requête se termine.

request_id_iter

< >

( request_id: str )

Itérer sur les résultats correspondant à un identifiant de requête spécifique (bloquant).

Utilise la file de sortie partagée avec remise en file. Pour le service à forte concurrence, utilisez plutôt register_result_handler.

démarrer

< >

( )

Démarrer le thread de génération en arrière-plan.

stop

< >

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

Arrête le thread de génération en arrière-plan. Si le drapeau block est défini sur True, cette méthode attend l’arrêt du thread pendant un temps maximal de timeout secondes (None signifie aucun délai d’attente). Si le drapeau keep_for_next_session est défini sur True, le gestionnaire est mis en cache sur le modèle pour une utilisation future. Si le drapeau hard_stop est défini, le thread de génération en arrière-plan est arrêté immédiatement et les requêtes en attente échouent.

switch_to_cb_friendly_attn

< >

( model: ProtoPretrainedModelauto_switch_to_flash: bool = True )

Basculez l’implémentation de l’attention vers une version compatible CB. Si auto_switch_to_flash est True et que l’implémentation de l’attention est SDPA ou eager, basculez également vers flash si celui-ci est pris en charge et disponible.

préchauffage

< >

( )

Pré-capture les graphes CUDA pour les chemins varlen et decode en exécutant des lots fictifs. Initialise le processeur de lots si ce n'est pas déjà fait.

Planificateur

classe transformers.generation.Scheduler

< >

( cache: PagedAttentionCachesafety_margin: floatmax_requests_per_batch: int )

Classe de base abstraite pour la planification des requêtes dans le processeur de lots continus. Les planificateurs gèrent le cycle de vie des requêtes, depuis leur ajout à la file d’attente jusqu’à leur planification pour le traitement. Différents planificateurs implémentent différentes stratégies pour prioriser et regrouper les requêtes en lots.

add_waiting_request

< >

( state: RequestState )

Ajoute une requête à la liste d’attente.

clear_cancelled_requests

< >

( )

Supprimez toutes les demandes annulées des files actives et en attente.

finish_request

< >

( request_id: str )

Effectue le traitement complet d'une requête et libère les blocs de cache qui lui étaient alloués. Cette méthode est appelée lorsqu'une requête a terminé sa génération ou a rencontré une erreur.

get_active_request_static_outputs

< >

( request_id: str )

Récupère les jetons générés pour une requête active.

has_pending_requests

< >

( )

Vérifie s'il y a des demandes prêtes à être traitées.

request_is_cancelled

< >

( request_id: str )

Vérifie si une requête a été annulée ou supprimée.

réinitialiser

< >

( )

Réinitialiser l'état du planificateur pour une nouvelle boucle de génération.

schedule_batch

< >

( token_budget: intcache_budget: int )

Planifie les requêtes pour le prochain lot en fonction des budgets de jetons et de cache disponibles. Cette méthode sélectionne les requêtes à traiter dans le lot actuel, en tenant compte des budgets et des règles de priorisation du planificateur. Le token_budget est le nombre maximal de jetons pouvant être traités dans un lot, et le cache_budget est le nombre maximal d'entrées de cache KV pouvant être lues dans un lot. Retourne la liste des requêtes planifiées sous leur forme « FutureRequestState », un booléen indiquant si le chemin rapide de décodage peut être utilisé, le nombre total de jetons de requête et le nombre maximal de jetons kv lus.

set_request_cancellation

< >

( request_id: str )

Marque une demande d'annulation.

FIFOScheduler

classe transformers.generation.FIFOScheduler

< >

( cache: PagedAttentionCachesafety_margin: float | Nonemax_requests_per_batch: int )

Ce planificateur traite les requêtes dans l'ordre de leur arrivée, ce qui signifie que les requêtes de décodage ont la priorité sur les requêtes de préremplissage.

PrefillFirstScheduler

classe transformers.generation.PrefillFirstScheduler

< >

( cache: PagedAttentionCachesafety_margin: float | Nonemax_requests_per_batch: int )

Planificateur qui priorise les requêtes de préremplissage fractionné par rapport aux requêtes de décodage. Ce planificateur garantit que les requêtes de préremplissage fractionné (qui sont des continuations de prompts partiellement traités) sont terminées avant le traitement de nouvelles requêtes de décodage.

Update on GitHub