# 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` :

- PyTorch [generate()](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationMixin.generate) est implémenté dans [GenerationMixin](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationMixin).

Vous pouvez paramétrer la méthode generate avec une instance de la classe [GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.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, connaître les valeurs par défaut, modifier les paramètres de manière ad hoc, ainsi que créer et enregistrer une configuration de génération personnalisée, reportez-vous au [guide des stratégies de génération de texte](../generation_strategies). Ce guide explique également comment utiliser des fonctionnalités associées, comme le streaming de jetons.

## GenerationConfig[[transformers.GenerationConfig]]

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

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

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

**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 prédiction multi-jetons (MTP) si le modèle le 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 dernières positions (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 :  - `"dynamic"` : [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) - `"static"` : [StaticCache](/docs/transformers/main/fr/internal/generation_utils#transformers.StaticCache) - `"offloaded"` : `DynamicCache(offloaded=True)` - `"offloaded_static"` : `StaticCache(offloaded=True)` - `"quantized"` : [QuantizedCache](/docs/transformers/main/fr/internal/generation_utils#transformers.QuantizedCache)  Si aucune valeur n'est spécifiée, le cache par défaut du modèle sera utilisé (souvent [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache)). Consultez notre [documentation sur le cache](https://huggingface.co/docs/transformers/en/kv_cache) 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` d'un modèle. Si elle n'est pas définie, la valeur par défaut est 1.0

top_k (`int`, *facultatif*) : 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 la valeur est inférieure à 1, seuls les jetons les plus probables dont les probabilités cumulées atteignent `top_p` ou plus sont conservés 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 des jetons, 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'inverse des valeurs habituelles de `top_p`).

top_h (`float`, *facultatif*) : Facteur d'échelle du budget d'entropie, qui contrôle la quantité d'entropie de la distribution préservé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 est conservé dont l'entropie *renormalisée* est inférieure ou égale à `top_h` fois l'entropie de la distribution complète. Des valeurs plus faibles (par ex. 0,2–0,5) conduisent à des sorties plus ciblées et déterministes, tandis que des valeurs proches de 1,0 permettent 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 typicité 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 la valeur est fixée sur un float < 1, l'ensemble le plus restreint de jetons les plus localement typiques, dont les probabilités cumulées atteignent `typical_p` ou plus, est conservé pour la génération. Consultez [cet article](https://huggingface.co/papers/2202.00666) pour plus de détails.

epsilon_cutoff (`float`, *facultatif*) : Si défini sur une valeur flottante strictement comprise 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, selon la taille du modèle. Consultez [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) pour plus de détails.

eta_cutoff (`float`, *facultatif*) : L'échantillonnage Eta est un hybride de l'échantillonnage localement typique et de l'échantillonnage epsilon. S'il est défini sur une valeur flottante strictement comprise 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é attendue du jeton suivant, mise à l'échelle par `sqrt(eta_cutoff)`. Dans l'article, les valeurs suggérées vont de 3e-4 à 2e-3, en fonction de la taille du modèle. Consultez [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) pour plus de détails.

repetition_penalty (`float`, *facultatif*) : Le paramètre de pénalité de répétition. 1.0 signifie qu'aucune pénalité n'est appliquée. Consultez [ce papier](https://huggingface.co/papers/1909.05858) 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 correspond à la log-vraisemblance de la séquence (donc 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 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](/docs/transformers/main/fr/internal/generation_utils#transformers.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 vivement 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*, valeur 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](../model_doc/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'éviter que la méthode de génération ne plante. 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 qu'un certain nombre de jetons a été généré. 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](/docs/transformers/main/fr/internal/generation_utils#transformers.SequenceBiasLogitsProcessor) pour une documentation et des exemples supplémentaires.

token_healing (`bool`) : Répare les jetons de fin des invites en les remplaçant par leurs extensions appropriées. Cela améliore la qualité des complétions pour les invites affectées par le biais de tokenisation gloutonne.

guidance_scale (`float`, *facultatif*) : L'échelle de guidage pour le guidage libre de 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](/docs/transformers/main/fr/internal/generation_utils#transformers.SynthIDTextWatermarkingConfig) et de [WatermarkingConfig](/docs/transformers/main/fr/internal/generation_utils#transformers.WatermarkingConfig) pour plus de détails. S'il est transmis 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` dans 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. Consultez `hidden_states` dans les tenseurs retournés pour plus de détails.

output_scores (`bool`) : Indique s'il faut ou non retourner les scores de prédiction. Consultez `scores` dans 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](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt que la séquence générée uniquement. Ce drapeau doit être défini sur `True` pour retourner le cache de génération (lorsque `use_cache` est `True`) ou des sorties facultatives (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 *padding*.

bos_token_id (`int`, *facultatif*) : L'identifiant du jeton *beginning-of-sequence*.

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 spécifiques aux modèles encodeur-décodeur :**

encoder_no_repeat_ngram_size (`int`, *facultatif*) : Si défini sur 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 différentes langues cibles dans un même lot)

**Paramètres de génération spécifiques à 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_ que le modèle assistant doit générer avant d'être vérifié 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"` : Si tous les jetons spéculatifs sont corrects, augmenter `num_assistant_tokens` de 2, sinon le réduire de 1. La valeur de `num_assistant_tokens` est conservée d'un appel de génération à l'autre 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*) : Le 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 brouillon et de la cible, avec une tendance à éviter les faux négatifs. La valeur de `assistant_confidence_threshold` est persistante sur plusieurs appels de génération avec le même modèle assistant. Il s'agit d'une version non supervisée de la spéculation dynamique de Dynamic Speculation Lookahead Accelerates Speculative Decoding of Large Language Models .

prompt_lookup_num_tokens (`int`, *facultatif*) : Le nombre de jetons à produire en tant que jetons candidats.

max_matching_ngram_size (`int`, *facultatif*) : La taille maximale de ngramme à prendre en compte pour la correspondance dans le prompt. Par défaut, la valeur est 2 si aucune n'est fournie.

assistant_early_exit(`int`, *facultatif*) : 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`, *facultatif*) : 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. Consultez ce [blog](https://huggingface.co/blog/universal_assisted_generation) pour plus de détails.

target_lookbehind(`int`, *optionnel*) : Si défini sur un entier positif, le processus de réencodage prendra également en compte les `target_lookbehind` derniers jetons de la cible pour aligner correctement les jetons. Ne peut être utilisé qu'avec des tokenizers différents dans le décodage spéculatif. Consultez ce [blog](https://huggingface.co/blog/universal_assisted_generation) 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 sur une valeur comprise 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 d'invite.

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*) : Si un cache compilable est utilisé, ce paramètre contrôle la façon 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 est effectuée lorsque des critères spécifiques sont remplis, notamment l'utilisation d'un cache compilable. Veuillez ouvrir un ticket si vous avez 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](../generation_strategies).

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](https://huggingface.co/docs/transformers/internal/generation_utils) 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, veillez à les définir explicitement dans la configuration de génération.

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

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

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

**Paramètres :**

pretrained_model_name (`str` ou `os.PathLike`) : peut être l'un des éléments suivants :  - 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 *répertoire* contenant un fichier de configuration enregistré à l'aide de la méthode [save_pretrained()](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig.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*, valeur 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*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, ou non spécifié, le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

revision (`str`, *facultatif*, valeur 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, de sorte que `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*, valeur par défaut `False`) : Si `False`, 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*, valeur par défaut `""`) : si les fichiers concernés 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 dans 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`.

**Retourne :** [GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig)

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

Instanciez un [GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig) à partir d'un fichier de configuration de génération.

Exemples :

```python
>>> from transformers import GenerationConfig

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

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

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

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

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

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

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

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

**Paramètres :**

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

**Retourne :** [GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig)

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

Instancie un [GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig) à partir d'un [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig). Cette fonction est utile pour convertir les objets [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) hérités, qui peuvent contenir des paramètres de génération, en un [GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig) autonome.

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

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

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

**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*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination 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 par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/main/fr/main_classes/model#transformers.utils.PushToHubMixin.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()](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig.from_pretrained).

#### mettre à jour[[transformers.GenerationConfig.update]]

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

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

**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 faut autoriser la mise à jour d'entrées personnalisées dans la configuration à l'aide de `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.

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

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

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

**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 les combinaisons de drapeaux en conflit (par exemple, des drapeaux réservés à l'échantillonnage définis alors que `do_sample=False`) ne sont déclenchés que si le drapeau en conflit figure dans cet ensemble — ce qui évite les avertissements superflus lorsque la valeur a été héritée du fichier `generation_config.json` par défaut 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](/docs/transformers/main/fr/main_classes/text_generation#transformers.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 au moment de l'appel à generate, 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[[transformers.GenerationConfig.get_generation_mode]]

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

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

**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](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig).

## GenerationMixin[[transformers.GenerationMixin]]

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

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

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

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. L'héritage 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 vérification 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 définit une méthode `generate` personnalisée qui s'appuie, directement ou indirectement, sur `GenerationMixin` et partage approximativement la même interface pour des méthodes publiques comme `generate`. Trois exemples :
- `LlamaForCausalLM` doit hériter de `GenerationMixin` afin de pouvoir appeler `generate` et les 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`. Toutefois, 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 rompt l’interface de `generate`.

La classe expose [generate()](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationMixin.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](../generation_strategies).

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

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

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

**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 éléments suivants : `input_ids`, `input_values`, `input_features` ou `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationConfig), *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération. Les `**kwargs` passés à 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](/docs/transformers/main/fr/main_classes/text_generation#transformers.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 créés à 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 fournie, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si elle n'est pas fournie, 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 précédemment générés `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](https://huggingface.co/papers/2010.00904).

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 depuis lequel vous appelez generate. Par conséquent, le modèle assistant doit être beaucoup plus petit.

streamer (`BaseStreamer`, *facultatif*) : Objet Streamer qui sera utilisé pour diffuser les séquences générées. Les jetons générés sont transmis via `streamer.put(token_ids)` et le streamer 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'un des éléments suivants : - `str` (nom du dépôt sur le 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 d'accès local au dépôt) : idem, 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` effectue les étapes habituelles de préparation des entrées, puis appelle le callable fourni pour exécuter la boucle de décodage. Pour plus d'informations, consultez [la documentation](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *facultatif*) : Paramétrage ad hoc de `generation_config` et/ou d'autres kwargs spécifiques au modèle qui seront transmis à la fonction `forward` du modèle. Si le modèle est un modèle encoder-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](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.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](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :

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

Si le modèle est un modèle encodeur-décodeur (`model.config.is_encoder_decoder=True`), les types [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :

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

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 réglé 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](../generation_strategies).

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

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

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

**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 logarithmes des probabilités des jetons conditionnés sur le log softmax des jetons précédemment générés dans ce faisceau. Tuple 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` lors de la génération.

normalize_logits (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut normaliser les logits (qui, pour des raisons de rétrocompatibilité, peuvent ne pas être normalisés).

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

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

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

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

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

## ContinuousMixin[[transformers.ContinuousMixin]]

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

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

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

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. Toute modification apportée à l’un de ces trois points d’entrée doit être reflétée dans les deux autres.

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

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

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

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[[transformers.ContinuousMixin.destroy_cached_continuous_batching_manager]]

```python
destroy_cached_continuous_batching_manager()
```

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

Détruire le gestionnaire de lotissement continu mis en cache et libérer les ressources GPU.

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

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

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

**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 groupement continu

record_timestamps : Si défini sur true, les requêtes incluront un horodatage pour chaque jeton généré

progress_bar : Si défini sur true, une barre de progression sera affichée

persistent_manager : indique s'il faut conserver le gestionnaire après la fin de la génération. La valeur par défaut est False.

warmup : spécifie s'il faut pré-capturer les graphes CUDA avant le traitement des 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[[transformers.ContinuousMixin.init_continuous_batching]]

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

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

**Paramètres :**

generation_config : une configuration de génération facultative, qui peut contenir un objet CompileConfig

continuous_batching_config : Configuration de lotissement continu facultative

workload_hints : WorkloadHints facultatives pour aider le gestionnaire de lotissement continu à 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[[transformers.ContinuousBatchingManager]]

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

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

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

Gestionnaire pour le traitement par lot 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[[transformers.ContinuousBatchingManager.add_request]]

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

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

**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 maximum 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[[transformers.ContinuousBatchingManager.add_requests]]

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

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

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

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

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

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

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[[transformers.ContinuousBatchingManager.destroy]]

```python
destroy()
```

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

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[[transformers.ContinuousBatchingManager.get_result]]

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

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

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[[transformers.ContinuousBatchingManager.is_running]]

```python
is_running()
```

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

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

#### rejoindre[[transformers.ContinuousBatchingManager.join]]

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

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

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[[transformers.ContinuousBatchingManager.pause]]

```python
pause()
```

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

Un gestionnaire de contexte qui met en pause la boucle de génération, afin que le thread appelant puisse utiliser le modèle, généralement pour le mettre à jour sur place. Le thread n'entre dans ce contexte qu'une fois la boucle mise 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 thread 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[[transformers.ContinuousBatchingManager.register_result_handler]]

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

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

**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 en streaming, uniquement à la fin. Le gestionnaire est automatiquement nettoyé lorsque la requête se termine.

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

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

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

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

#### commencer[[transformers.ContinuousBatchingManager.start]]

```python
start()
```

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

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

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

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

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

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[[transformers.ContinuousBatchingManager.switch_to_cb_friendly_attn]]

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

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

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 celle-ci est prise en charge et disponible.

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

```python
warmup()
```

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

Pré-capture des 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[[transformers.generation.Scheduler]]

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

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

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

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 mettent en œuvre différentes stratégies pour prioriser et regrouper les requêtes en lots.

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

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

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

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

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

```python
clear_cancelled_requests()
```

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

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

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

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

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

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 lorsqu'elle a rencontré une erreur.

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

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

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

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

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

```python
has_pending_requests()
```

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

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

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

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

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

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

#### réinitialiser[[transformers.generation.Scheduler.reset]]

```python
reset()
```

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

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

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

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

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

Planifie les requêtes du 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 paramètre token_budget est le nombre maximal de jetons pouvant être traités dans un lot, et le paramètre cache_budget est le nombre maximal d'entrées de cache KV pouvant être lues dans un lot. Renvoie 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[[transformers.generation.Scheduler.set_request_cancellation]]

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

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

Marque une demande d'annulation.

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

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

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

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

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[[transformers.generation.PrefillFirstScheduler]]

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

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

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

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.