Transformers documentation
Génération
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() est implémenté dans 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
< source >( **kwargs )
Paramètres qui contrôlent la longueur de la sortie
- max_length (
int, facultatif) —max_new_tokensest recommandé pour contrôler le nombre de jetons générés par le modèle.max_lengthest 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é parmin_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 (
booloustr, 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 anum_beamscandidats 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 (
stroulist[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 dansgenerate, pour un décodage plus rapide. Les valeurs possibles sont :"dynamic": DynamicCache"static": StaticCache"offloaded":DynamicCache(offloaded=True)"offloaded_static":StaticCache(offloaded=True)"quantized": QuantizedCache
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éfautNone) — Les arguments utilisés dans la classe de cache clé-valeur peuvent être passés danscache_config. - max_cache_len (
int, facultatif) — Utilisé uniquement avec les caches statiques (cache_implementationdéfini sur"static"ou"offloaded_static"). Pré-dimensionne le cache à cette longueur au lieu de lamax_lengthde 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 degenerate()avec un prompt plus long ou une valeur plus élevée demax_new_tokens(jusqu’à cette limite) réutilisent le même cache au lieu de déclencher une réallocation et une recompilation partorch.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 fichiergeneration_config.jsondu 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 fichiergeneration_config.jsond’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 atteignenttop_pou plus est conservé pour la génération. Cette valeur est définie dans le fichiergeneration_config.jsondu 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églanttop_pdans la plage 0,99-0,8 (utilisez l’opposé des valeurs habituelles detop_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_hfois 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_pou 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_cutoffseront é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_cutoffou àsqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). Ce dernier terme correspond intuitivement à la probabilité du jeton suivant attendu, mise à l'échelle parsqrt(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 quelength_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 surTrue, 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éfautmodel.config.forced_bos_token_id) — L’identifiant du jeton à forcer comme premier jeton généré après ledecoder_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 (
intor list[int], *optional*, defaults tomodel.config.forced_eos_token_id) -- The id of the token to force as the last generated token whenmax_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 deremove_invalid_valuespeut 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_indexindique le point de départ de la pénalité etdecay_factorrepré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 logitsSuppressTokensdéfinira leurs probabilités de log à-infafin 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 logitsSuppressBeginTokensdéfinira leurs probabilités de log à-infafin 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éfinissantguidance_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 (
BaseWatermarkingConfigoudict, 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 deDict, il sera converti enWatermarkingConfigen 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. Voirattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - output_scores (
bool) — Indique s'il faut ou non retourner les scores de prédiction. Voirscoressous les tenseurs retournés pour plus de détails. - output_logits (
bool) — Whether or not to return the unprocessed prediction logit scores. Seelogitsunder 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 surTruepour retourner le cache de génération (lorsqueuse_cacheestTrue) ou les sorties optionnelles (voir les drapeaux commençant paroutput_)
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 dansencoder_input_idsne peuvent pas apparaître dansdecoder_input_ids. - decoder_start_token_id (
intoulist[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 longueurbatch_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 pournum_assistant_tokensrendent 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, augmentenum_assistant_tokensde 2, sinon réduis-le de 1. La valeur denum_assistant_tokensest conservée sur plusieurs appels de génération avec le même modèle assistant."heuristic_transient": Identique à"heuristic", maisnum_assistant_tokensest réinitialisé à sa valeur initiale après chaque appel de génération."constant":num_assistant_tokensreste 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 parnum_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 deassistant_confidence_thresholdest 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 lesassistant_lookbehindderniers 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 lestarget_lookbehindderniers 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élangew * p_target + (1 - w) * q_draftau lieu dep_target, échangeant un biais distributionnel contrôlé contre un taux d’acceptation plus élevé. La valeur par défaut estNone, 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 sontdflash.
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
generatecompilele 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=1etdo_sample=False - échantillonnage multinomial si
num_beams=1etdo_sample=True - décodage par recherche en faisceau si
num_beams>1etdo_sample=False - échantillonnage multinomial avec beam-search si
num_beams>1etdo_sample=True - décodage assisté si
assistant_modelouprompt_lookup_num_tokensest 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
< source >( 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 (
strouos.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 (
strouos.PathLike, facultatif, par défaut"generation_config.json") — Nom du fichier JSON de configuration de génération à charger depuispretrained_model_name. - cache_dir (
strouos.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éfautFalse) — 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 (
stroubool, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. SiTrue, ou non spécifié, utilisera le jeton généré lors de l’exécution dehf 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, doncrevisionpeut ê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éfautFalse) — SiFalse, alors cette fonction renvoie uniquement l'objet de configuration final.Si
True, cette fonction renvoie unTuple(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 dekwargsqui n'a pas été utilisée pour mettre à jourconfiget 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.
Retourne
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
< source >( model_config: typing.Union[ForwardRef('PreTrainedConfig'), dict] ) → GenerationConfig
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
< source >( save_directory: str | os.PathLikeconfig_file_name: str | os.PathLike | None = Nonepush_to_hub: bool = False**kwargs )
Paramètres
- save_directory (
strouos.PathLike) — Répertoire où le fichier JSON de configuration sera enregistré (il sera créé s'il n'existe pas). - config_file_name (
strouos.PathLike, facultatif, par défaut"generation_config.json") — Nom du fichier JSON de configuration de génération à enregistrer danssave_directory. - push_to_hub (
bool, facultatif, par défautFalse) — 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 avecrepo_id(par défaut, il s'agit du nom desave_directorydans 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
< source >( defaults_only = Falseallow_custom_entries = False**kwargs ) → dict[str, Any]
Paramètres
- defaults_only (
bool, facultatif, valeur par défautFalse) — Indique s'il faut mettre à jour toutes les clés de la configuration aveckwargsou uniquement celles qui sont définies surNone(c'est-à-dire la valeur par défaut). - allow_custom_entries (
bool, facultatif, valeur par défautFalse) — Indique s'il est possible de mettre à jour les entrées personnalisées de la configuration aveckwargssi 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
< source >( 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éfautgeneration_config.jsondu modèle. LorsqueNone, 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
< source >( assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None ) → GenerationMode
Retourne le mode de génération déclenché par l'instance GenerationConfig.
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 :
LlamaForCausalLMdoit hériter deGenerationMixinpour permettre l’appel degenerateet des autres méthodes publiques du mixin ;BlipForQuestionAnsweringpossède une méthodegeneratepersonnalisée qui partage approximativement la même interface queGenerationMixin.generate(elle comporte quelques arguments supplémentaires et le même résultat). Cette fonction appelle égalementGenerationMixin.generateindirectement, via un modèle interne. En conséquence,BlipForQuestionAnsweringdevrait hériter deGenerationMixinafin de bénéficier de toute l’automatisation liée à la génération dans notre base de code ;BarkModelpossède une méthodegeneratepersonnalisée et l’un de ses modèles internes appelleGenerationMixin.generate. Cependant, songeneratene partage pas la même interface queGenerationMixin.generate. Dans ce cas,BarkModelne doit PAS hériter deGenerationMixin, car cela casse l’interface degenerate.
La classe expose generate(), qui peut être utilisé pour :
- décodage glouton si
num_beams=1etdo_sample=False - échantillonnage multinomial si
num_beams=1etdo_sample=True - décodage par recherche en faisceau si
num_beams>1etdo_sample=False - échantillonnage multinomial avec beam-search si
num_beams>1etdo_sample=True - décodage assisté si
assistant_modelouprompt_lookup_num_tokensest 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
< source >( 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.Tensorde 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. SiNone, la méthode l’initialise avecbos_token_idet une taille de lot de 1. Pour les modèles uniquement décodeurs,inputsdoit être au format deinput_ids. Pour les modèles encodeur-décodeur, inputs peut représenter l’un desinput_ids,input_values,input_featuresoupixel_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
**kwargstransmis à generate qui correspondent aux attributs degeneration_configles remplaceront. Sigeneration_confign’est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèlegeneration_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éescores, assurez-vous de passerreturn_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 lotbatch_idetinput_ids. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lotbatch_idet les jetons générés précédemmentinputs_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 surTruelors de l'utilisation deFullyShardedDataParallelou 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 estFalse. - 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 viastreamer.put(token_ids)et l’objet est responsable de tout traitement ultérieur. - negative_prompt_ids (
torch.LongTensorde 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.LongTensorde forme(batch_size, sequence_length), facultatif) — Attention_mask pournegative_prompt_ids. - custom_generate (
strouCallable, facultatif) — L'une des options suivantes :str(nom du dépôt Hugging Face Hub) : exécute la fonctiongeneratepersonnalisée définie danscustom_generate/generate.pyde ce dépôt à la place de la méthode standardgenerate. 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 égalementtrust_remote_code=Truecar le fichier localcustom_generate/generate.pyest exécuté.Callable:generateeffectuera 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 degeneration_configet/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonctionforwarddu 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_configqui, 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 quelgeneration_configen 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
< source >( 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 deeos_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 detorch.Tensoravec au plusmax_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.LongTensorde forme(batch_size*num_return_sequences, sequence_length). Requis uniquement sinum_beams>1au moment de la génération. - normalize_logits (
bool, facultatif, par défautFalse) — 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))
TrueContinuousMixin
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 continucontinuous_batching_context_manager, qui est lui-même un wrapper autour deinit_continuous_batchinggenerate_batch, qui est en réalité un wrapper autour decontinuous_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
< source >( 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.
Détruire le gestionnaire de lotissement continu mis en cache et libérer les ressources GPU.
generate_batch
< source >( 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
< source >( 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
< source >( 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_batchingcontinuous_batching_context_managergenerate_batch
add_request
< source >( 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
< source >( 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.
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.
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é.
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).
Retourne True si le thread de génération en arrière-plan a été démarré et est toujours actif.
Attendez que le thread en arrière-plan se termine. L'attente peut être limitée à l'aide de l'argument timeout (en secondes).
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
< source >( request_id: strcallback: Callable )
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.
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 le thread de génération en arrière-plan.
stop
< source >( 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
< source >( 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é-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
< source >( 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.
Ajoute une requête à la liste d’attente.
Supprimez toutes les demandes annulées des files actives et en attente.
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.
Récupère les jetons générés pour une requête active.
Vérifie s'il y a des demandes prêtes à être traitées.
Vérifie si une requête a été annulée ou supprimée.
Réinitialiser l'état du planificateur pour une nouvelle boucle de génération.
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.
Marque une demande d'annulation.
FIFOScheduler
classe transformers.generation.FIFOScheduler
< source >( 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
< source >( 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.