Transformers documentation

Geração

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

and get access to the augmented documentation experience

to get started

Geração

Cada framework possui um método generate para geração de texto implementado em sua respectiva classe GenerationMixin:

Você pode parametrizar o método generate com uma instância da classe GenerationConfig. Consulte esta classe para obter a lista completa dos parâmetros de geração, que controlam o comportamento do método de geração.

Para saber como inspecionar a configuração de geração de um modelo, quais são os padrões, como alterar os parâmetros ad hoc e como criar e salvar uma configuração de geração personalizada, consulte o guia de estratégias de geração de texto. O guia também explica como usar recursos relacionados, como o streaming de tokens.

GenerationConfig

classe transformers.GenerationConfig

< >

( **kwargs )

Parâmetros que controlam o comprimento da saída

  • max_length (int, opcional) — max_new_tokens é recomendado para controlar quantos tokens o modelo gera. max_length permanece por compatibilidade com versões anteriores.
  • max_new_tokens (int, opcional) — O número máximo de tokens a serem gerados, ignorando o número de tokens no prompt.
  • min_length (int, opcional) — O comprimento mínimo da sequência a ser gerada. Corresponde ao comprimento do prompt de entrada + min_new_tokens. Seu efeito é sobrescrito por min_new_tokens, se também for definido.
  • min_new_tokens (int, opcional) — O número mínimo de tokens a serem gerados, ignorando o número de tokens no prompt.
  • early_stopping (bool ou str, opcional) — Controla a condição de parada para métodos baseados em feixes, como beam-search. Aceita os seguintes valores: True, em que a geração para assim que houver num_beams candidatos completos; False, em que uma heurística é aplicada e a geração para quando é muito improvável encontrar candidatos melhores; "never", em que o procedimento de beam search só para quando não podem existir candidatos melhores (algoritmo canônico de beam search).
  • max_time (float, opcional) — O tempo máximo, em segundos, que você permite que a computação seja executada. A geração ainda concluirá a passagem atual após o tempo alocado ter sido excedido.
  • stop_strings (str ou list[str], opcional) — Uma string ou uma lista de strings que devem encerrar a geração caso o modelo as produza.

Parâmetros que controlam a estratégia de geração utilizada

  • do_sample (bool) — Se deve usar amostragem; caso contrário, usa decodificação gulosa.
  • num_beams (int, opcional) — Número de feixes para a busca por feixes. 1 significa que não há busca por feixes.
  • use_mtp — (bool): Indica se deve ou não usar Multi-Token Prediction (MTP), caso o modelo ofereça suporte a esse recurso.

Parâmetros que controlam o cache

  • use_cache (bool) — Se o modelo deve ou não usar as atenções de chaves/valores passados (se aplicável ao modelo) para acelerar a decodificação.
  • cache_implementation (str, opcional) — Nome da classe de cache que será instanciada em generate, para decodificação mais rápida. Os valores possíveis são:

    Se nenhum for especificado, usaremos o cache padrão do modelo (que frequentemente é DynamicCache). Consulte nossa documentação de cache para mais informações.

  • cache_config (dict, opcional, padrão None) — Os argumentos usados na classe de cache de chave-valor podem ser passados em cache_config.
  • max_cache_len (int, opcional) — Usado apenas com caches estáticos (cache_implementation definido como "static" ou "offloaded_static"). Pré-dimensiona o cache para este comprimento em vez do max_length da chamada atual. Defina-o uma única vez para o maior comprimento de chamada esperado, para que chamadas repetidas de generate() com um prompt mais longo ou um valor maior de max_new_tokens (até esse limite) reutilizem o mesmo cache em vez de acionar uma realocação e uma recompilação do torch.compile.

Parâmetros para manipulação dos logits de saída do modelo

  • temperature (float, opcional) — O valor usado para modular as probabilidades do próximo token. Esse valor é definido no arquivo generation_config.json de um modelo. Se não for definido, o valor padrão é 1.0
  • top_k (int, opcional) — O número de tokens do vocabulário com maior probabilidade a serem mantidos para o filtro top-k. Esse valor é definido no arquivo generation_config.json de um modelo. Se não for definido, o valor padrão é 50.
  • top_p (float, opcional) — Se definido como float < 1, apenas o menor conjunto de tokens mais prováveis, cujas probabilidades somam top_p ou mais, é mantido para a geração. Esse valor é definido no arquivo generation_config.json de um modelo. Se não for definido, o valor padrão é 1.0
  • min_p (float, opcional) — Probabilidade mínima do token, que será escalada pela probabilidade do token mais provável. Deve ser um valor entre 0 e 1. Valores típicos estão na faixa de 0,01 a 0,2, com seletividade comparável à de definir top_p na faixa de 0,99 a 0,8 (use o oposto dos valores normais de top_p).
  • top_h (float, opcional) — Fator de escala do orçamento de entropia, que controla quanta da entropia da distribuição é preservada durante a amostragem. Deve ser um valor entre 0 e 1. A cada etapa, os tokens são ordenados por probabilidade, e o menor prefixo de tokens é mantido cuja entropia renormalizada seja menor ou igual a top_h vezes a entropia da distribuição completa. Valores menores (por exemplo, 0,2–0,5) resultam em saídas mais focadas e determinísticas, enquanto valores próximos de 1,0 permitem mais aleatoriedade e diversidade. Os valores típicos estão na faixa de 0,3 a 0,6.
  • typical_p (float, opcional) — A tipicidade local mede o quão semelhante a probabilidade condicional de prever o próximo token alvo é à probabilidade condicional esperada de prever um token aleatório a seguir, dado o texto parcial já gerado. Se definido como float < 1, o menor conjunto de tokens mais localmente típicos com probabilidades que somam typical_p ou mais é mantido para a geração. Veja este artigo para mais detalhes.
  • epsilon_cutoff (float, opcional) — Se definido como um float estritamente entre 0 e 1, apenas tokens com probabilidade condicional maior que epsilon_cutoff serão amostrados. No artigo, os valores sugeridos variam de 3e-4 a 9e-4, dependendo do tamanho do modelo. Consulte Truncation Sampling as Language Model Desmoothing para mais detalhes.
  • eta_cutoff (float, opcional) — A amostragem Eta é um híbrido da amostragem localmente típica e da amostragem epsilon. Se definido como um float estritamente entre 0 e 1, um token só é considerado se for maior que eta_cutoff ou sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). O segundo termo é, intuitivamente, a probabilidade esperada do próximo token, escalonada por sqrt(eta_cutoff). No artigo, os valores sugeridos variam de 3e-4 a 2e-3, dependendo do tamanho do modelo. Consulte Truncation Sampling as Language Model Desmoothing para mais detalhes.
  • repetition_penalty (float, opcional) — O parâmetro para a penalidade de repetição. 1.0 significa sem penalidade. Veja este artigo para mais detalhes.
  • encoder_repetition_penalty (float, opcional) — O parâmetro para encoder_repetition_penalty. Uma penalidade exponencial para sequências que não estão na entrada original. 1.0 significa sem penalidade.
  • length_penalty (float, opcional) — Penalidade exponencial ao comprimento, utilizada na geração baseada em feixe. Ela é aplicada como um expoente ao comprimento da sequência, que por sua vez é usado para dividir a pontuação da sequência. Como a pontuação é a verossimilhança logarítmica da sequência (ou seja, negativa), length_penalty > 0.0 favorece sequências mais longas, enquanto length_penalty < 0.0 incentiva sequências mais curtas.
  • no_repeat_ngram_size (int, opcional) — Se definido como int > 0, todos os ngrams desse tamanho podem ocorrer apenas uma vez.
  • bad_words_ids (list[list[int]], opcional) — Lista de listas de ids de tokens que não podem ser gerados. Consulte NoBadWordsLogitsProcessor para mais documentação e exemplos.
  • renormalize_logits (bool) — Indica se os logits devem ser renormalizados após a aplicação de todos os processadores de logits (incluindo os personalizados). É altamente recomendável definir essa flag como True, pois os algoritmos de busca pressupõem que os logits de pontuação estão normalizados, mas alguns processadores de logits quebram essa normalização.
  • forced_bos_token_id (int, opcional, padrão model.config.forced_bos_token_id) — O id do token a ser forçado como o primeiro token gerado após o decoder_start_token_id. Útil para modelos multilíngues como mBART, em que o primeiro token gerado precisa ser o token do idioma de destino.
  • forced_eos_token_id (int or list[int], *optional*, defaults to model.config.forced_eos_token_id) -- The id of the token to force as the last generated token when max_length` is reached. Optionally, use a list to set multiple end-of-sequence tokens.
  • remove_invalid_values (bool) — Se deve remover possíveis saídas nan e inf do modelo para evitar que o método de geração falhe. Observe que o uso de remove_invalid_values pode tornar a geração mais lenta.
  • exponential_decay_length_penalty (tuple(int, float), opcional) — Esta Tuple adiciona uma penalidade de comprimento que aumenta exponencialmente, após a geração de uma certa quantidade de tokens. A tupla deve consistir em: (start_index, decay_factor), onde start_index indica onde a penalidade começa e decay_factor representa o fator de decaimento exponencial
  • suppress_tokens (list[int], opcional) — Uma lista de tokens que serão suprimidos na geração. O logit processor SuppressTokens definirá seus log probs como -inf para que não sejam amostrados.
  • begin_suppress_tokens (list[int], opcional) — Uma lista de tokens que serão suprimidos no início da geração. O processador de logits SuppressBeginTokens definirá seus log probs como -inf para que não sejam amostrados.
  • sequence_bias (dict[tuple[int], float], opcional) — Dicionário que mapeia uma sequência de tokens para seu termo de viés. Viés positivos aumentam as chances de a sequência ser selecionada, enquanto viés negativos fazem o oposto. Consulte SequenceBiasLogitsProcessor para mais documentação e exemplos.
  • token_healing (bool) — Corrige os tokens finais dos prompts substituindo-os pelas suas extensões apropriadas. Isso melhora a qualidade das conclusões para prompts afetados pelo viés de tokenização gulosa.
  • guidance_scale (float, opcional) — A escala de orientação para classifier free guidance (CFG). O CFG é ativado definindo guidance_scale > 1. Uma escala de orientação mais alta incentiva o modelo a gerar amostras mais próximas do prompt de entrada, geralmente em detrimento da qualidade.
  • watermarking_config (BaseWatermarkingConfig ou dict, opcional) — Argumentos usados para aplicar marca d'água às saídas do modelo, adicionando um pequeno viés a um conjunto aleatório de tokens “verdes”. Consulte a documentação de SynthIDTextWatermarkingConfig e WatermarkingConfig para mais detalhes. Se for passado como Dict, será convertido internamente para WatermarkingConfig.

Parâmetros que definem as variáveis de saída de generate

  • num_return_sequences (int, opcional) — O número de sequências retornadas, calculadas de forma independente, para cada elemento do lote.
  • output_attentions (bool) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions em tensores retornados para mais detalhes.
  • output_hidden_states (bool) — Indica se as camadas ocultas de todas as camadas devem ser retornadas. Consulte hidden_states em tensores retornados para mais detalhes.
  • output_scores (bool) — Indica se as pontuações de previsão devem ser retornadas. Consulte scores em tensores retornados para mais detalhes.
  • output_logits (bool) — Indica se os scores de logit de previsão não processados devem ser retornados. Consulte logits em tensors retornados para mais detalhes.
  • return_dict_in_generate (bool) — Indica se deve retornar um ModelOutput, em vez de retornar exclusivamente a sequência gerada. Essa flag deve ser definida como True para retornar o cache de geração (quando use_cache é True) ou saídas opcionais (veja as flags que começam com output_)

Tokens especiais que podem ser usados no momento da geração

  • pad_token_id (int, opcional) — O id do token de padding.
  • bos_token_id (int, opcional) — O id do token de início de sequência.
  • eos_token_id (Union[int, list[int]], opcional) — O id do token de fim de sequência. Opcionalmente, use uma lista para definir múltiplos tokens de fim de sequência.

Parâmetros de geração exclusivos para modelos encoder-decoder

  • encoder_no_repeat_ngram_size (int, opcional) — Se definido como int > 0, todos os ngrams desse tamanho que ocorrem em encoder_input_ids não podem ocorrer em decoder_input_ids.
  • decoder_start_token_id (int ou list[int], opcional) — Se um modelo encoder-decoder inicia a decodificação com um token diferente de bos, o id desse token ou uma lista de comprimento batch_size. Indicar uma lista permite usar ids de início diferentes para cada elemento do lote (por exemplo, modelos multilíngues com idiomas de destino diferentes em um único lote)

Parâmetros de geração exclusivos para a geração do assistente

  • is_assistant (bool) — Indica se o modelo é um modelo assistente (rascunho).
  • num_assistant_tokens (int, opcional) — Define o número de tokens especulativos que devem ser gerados pelo modelo assistente antes de serem verificados pelo modelo alvo em cada iteração. Valores maiores para num_assistant_tokens tornam a geração mais especulativa: se o modelo assistente for eficiente, maiores ganhos de velocidade podem ser alcançados; se o modelo assistente exigir muitas correções, os ganhos de velocidade serão menores.
  • num_assistant_tokens_schedule (str, opcional) — Define a agenda na qual o número máximo de tokens do assistente deve ser alterado durante a inferência.
    • "heuristic": Quando todos os tokens especulativos estão corretos, aumente num_assistant_tokens em 2; caso contrário, reduza em 1. O valor de num_assistant_tokens é persistente entre várias chamadas de geração com o mesmo modelo de assistente.
    • "heuristic_transient": Igual a "heuristic", mas num_assistant_tokens é redefinido para o valor inicial após cada chamada de geração.
    • "constant": num_assistant_tokens permanece inalterado durante a geração
  • assistant_confidence_threshold (float, opcional) — O limiar de confiança para o modelo assistente. Se a confiança do modelo assistente em sua previsão para o token atual for menor do que este limiar, o modelo assistente interrompe a iteração atual de geração de tokens, mesmo que o número de tokens especulativos (definido por num_assistant_tokens) ainda não tenha sido atingido. O limiar de confiança do assistente é ajustado ao longo das iterações especulativas para reduzir o número de passes de forward desnecessários do rascunho e do alvo, com viés para evitar falsos negativos. O valor de assistant_confidence_threshold é persistente entre múltiplas chamadas de geração com o mesmo modelo assistente. É uma versão não supervisionada do 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, opcional) — O número de tokens a serem exibidos como tokens candidatos.
  • max_matching_ngram_size (int, opcional) — O tamanho máximo de ngram a ser considerado para correspondência no prompt. O padrão é 2, se não for fornecido.
  • assistant_early_exit(int, optional) — Se definido como um inteiro positivo, o early exit do modelo será utilizado como um assistente. Pode ser usado apenas com modelos que suportam early exit (ou seja, modelos em que os logits das camadas intermediárias podem ser interpretados pelo LM head).
  • assistant_lookbehind(int, opcional) — Se definido como um inteiro positivo, o processo de re-encoding considerará adicionalmente os últimos assistant_lookbehind tokens do assistente para alinhar corretamente os tokens. Pode ser usado apenas com tokenizers diferentes em decodificação especulativa. Veja este blog para mais detalhes.
  • target_lookbehind(int, opcional) — Se definido como um inteiro positivo, o processo de re-encoding considerará adicionalmente os últimos target_lookbehind tokens de destino para alinhar corretamente os tokens. Pode ser usado apenas com tokenizers diferentes em speculative decoding. Veja este blog para mais detalhes.
  • assistant_ensemble_weight (float, opcional) — Ativa a verificação de ensemble estático no decodificação especulativa. Se definido para um valor em (0.0, 1.0), o verificador aceita tokens em relação à mistura w * p_target + (1 - w) * q_draft em vez de p_target, trocando um viés distribucional controlado por uma taxa de aceitação mais alta. O valor padrão é None, o que mantém a decodificação sem perdas. Exige que o modelo assistente retorne logits, portanto não é compatível com a decodificação por busca de prompt.
  • speculation_type (str, opcional) — O tipo de especulação solicitado. Os valores aceitos são dflash.

Parâmetros relacionados a desempenho e compilação

  • compile_config (CompileConfig, opcional) — Se estiver usando um cache compilável, isso controla como o generate irá compile a passagem direta para uma inferência mais rápida.
  • disable_compile (bool) — Se deve desabilitar a compilação automática da passagem direta (forward pass). A compilação automática ocorre quando critérios específicos são atendidos, incluindo o uso de um cache compilável. Abra uma issue se você encontrar a necessidade de usar essa flag.

Classe que armazena uma configuração para uma tarefa de geração. Uma chamada generate suporta os seguintes métodos de geração para modelos de decodificador de texto, texto-para-texto, fala-para-texto e visão-para-texto:

  • decodificação gulosa se num_beams=1 e do_sample=False
  • amostragem multinomial se num_beams=1 e do_sample=True
  • decodificação por busca em feixe se num_beams>1 e do_sample=False
  • amostragem multinomial com beam-search se num_beams>1 e do_sample=True
  • decodificação assistida se assistant_model ou prompt_lookup_num_tokens for passado para .generate()

Para saber mais sobre as estratégias de decodificação, consulte o guia de estratégias de geração de texto.

Um grande número dessas flags controla os logits ou os critérios de parada da geração. Verifique as classes relacionadas ao generate para obter uma descrição completa das manipulações possíveis, bem como exemplos de uso.

Nota: os campos de configuração que ainda são None serão substituídos por GenerationConfig._get_default_generation_params() durante o loop de geração. Se você quiser usar valores diferentes para esses campos, certifique-se de defini-los explicitamente na configuração de geração.

from_pretrained

< >

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

Parâmetros

  • pretrained_model_name (str ou os.PathLike) — Pode ser:
    • uma string, o model id de uma configuração de modelo pré-treinado hospedada em um repositório de modelos no huggingface.co.
    • um caminho para um diretório contendo um arquivo de configuração salvo usando o método save_pretrained(), por exemplo, ./my_model_directory/.
  • config_file_name (str ou os.PathLike, opcional, padrão "generation_config.json") — Nome do arquivo JSON de configuração de geração a ser carregado a partir de pretrained_model_name.
  • cache_dir (str ou os.PathLike, opcional) — Caminho para um diretório em que a configuração de um modelo pré-treinado baixado deve ser armazenada em cache, caso o cache padrão não deva ser usado.
  • force_download (bool, opcional, padrão False) — Indica se deve forçar o (re)download dos arquivos de configuração e substituir as versões em cache, caso existam.
  • proxies (dict[str, str], opcional) — Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Os proxies são usados em cada solicitação.
  • token (str ou bool, opcional) — O token a ser usado como autorização bearer HTTP para arquivos remotos. Se True, ou não especificado, usará o token gerado ao executar hf auth login (armazenado em ~/.huggingface).
  • revision (str, opcional, padrão é "main") — A versão específica do modelo a ser usada. Pode ser o nome de uma branch, o nome de uma tag ou um commit id, pois usamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto revision pode ser qualquer identificador permitido pelo git.

    Para testar um pull request que você fez no Hub, você pode passar revision="refs/pr/<pr_number>".

  • return_unused_kwargs (bool, opcional, padrão é False) — Se False, então esta função retorna apenas o objeto de configuração final.

    Se True, esta função retorna uma Tuple(config, unused_kwargs) em que unused_kwargs é um dicionário composto pelos pares de chave/valor cujas chaves não são atributos de configuração: ou seja, a parte de kwargs que não foi usada para atualizar config e é, de outra forma, ignorada.

  • subfolder (str, opcional, padrão "") — Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co, você pode especificar o nome da pasta aqui.
  • kwargs (dict[str, Any], opcional) — Os valores em kwargs de quaisquer chaves que sejam atributos de configuração serão usados para substituir os valores carregados. O comportamento em relação a pares de chave/valor cujas chaves não são atributos de configuração é controlado pelo parâmetro de palavra-chave return_unused_kwargs.

O objeto de configuração instanciado a partir deste modelo pré-treinado.

Instancie um GenerationConfig a partir de um arquivo de configuração de geração.

Exemplos:

>>> from transformers import GenerationConfig

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

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

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

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

>>> unused_kwargs
{'foo': False}

from_model_config

< >

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

Parâmetros

  • model_config (PreTrainedConfig | dict) — A configuração do modelo que será usada para instanciar a configuração de geração.

O objeto de configuração instanciado a partir desses parâmetros.

Instancia um GenerationConfig a partir de um PreTrainedConfig. Esta função é útil para converter objetos legados de PreTrainedConfig, que podem conter parâmetros de geração, em um GenerationConfig independente.

save_pretrained

< >

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

Parâmetros

  • save_directory (str ou os.PathLike) — Diretório onde o arquivo JSON de configuração será salvo (será criado se não existir).
  • config_file_name (str ou os.PathLike, opcional, padrão "generation_config.json") — Nome do arquivo JSON de configuração de geração a ser salvo em save_directory.
  • push_to_hub (bool, opcional, padrão False) — Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com repo_id (por padrão, será usado o nome de save_directory no seu namespace).
  • kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados ao método push_to_hub().

Salve um objeto de configuração de geração no diretório save_directory, para que ele possa ser recarregado usando o método de classe from_pretrained().

atualizar

< >

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

Parâmetros

  • defaults_only (bool, opcional, padrão False) — Se deve atualizar todas as chaves na config com kwargs ou apenas aquelas que estão definidas como None (ou seja, o valor padrão).
  • allow_custom_entries (bool, opcional, padrão False) — Se permite atualizar entradas personalizadas na configuração com kwargs caso não estejam presentes na configuração atual.
  • kwargs (dict[str, Any]) — Dicionário de atributos para atualizar temporariamente esta classe.

Retorna

dict[str, Any]

Dicionário contendo todos os pares de chave-valor que não foram usados para atualizar a instância.

Atualiza os atributos desta instância da classe com os atributos de kwargs, caso correspondam a atributos existentes, retornando todos os kwargs não utilizados.

validate

< >

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

Parâmetros

  • strict (bool) — Se True, levanta uma exceção para qualquer problema encontrado. Se False, apenas registra os problemas.
  • user_set_attributes (set[str], opcional) — Nomes dos atributos fornecidos explicitamente pelo chamador. Quando fornecido, os avisos de “problema menor” sobre combinações conflitantes de flags (por exemplo, flags apenas de amostragem definidas enquanto do_sample=False) são acionados apenas se a flag conflitante estiver neste conjunto — evitando avisos excessivos quando o valor foi herdado do generation_config.json padrão de um modelo. Quando None, todos os atributos definidos são considerados definidos pelo usuário (comportamento compatível com versões anteriores para chamadas diretas de validate()).

Valida os valores dos atributos da instância de GenerationConfig. Lança exceções na presença de parametrização que pode ser detectada como incorreta a partir apenas da instância de configuração.

Observe que alguns parâmetros não validados aqui são melhor validados em tempo de execução do generate, pois podem depender de outras entradas e/ou do modelo, como os parâmetros relacionados ao comprimento da geração.

get_generation_mode

< >

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

Parâmetros

  • assistant_model (PreTrainedModel, opcional) — O modelo assistente a ser usado para geração assistida. Se definido, o modo de geração será geração assistida.

Retorna

GenerationMode

O modo de geração acionado pela instância.

Retorna o modo de geração acionado pela instância de GenerationConfig.

GenerationMixin

classe transformers.GenerationMixin

< >

( )

Uma classe que contém todas as funções para geração de texto auto-regressiva, a ser usada como mixin em classes de modelo. Herdar desta classe faz com que o modelo tenha um comportamento especial relacionado à geração, como carregar um GenerationConfig no momento da inicialização ou garantir que os testes relacionados a generate sejam executados no CI do transformers.

Uma classe de modelo deve herdar de GenerationMixin para permitir a chamada de métodos como generate, ou quando ela define um método generate personalizado que depende de GenerationMixin, direta ou indiretamente, o que compartilha aproximadamente a mesma interface para métodos públicos como generate. Três exemplos:

  • LlamaForCausalLM deve herdar de GenerationMixin para permitir a chamada de generate e outros métodos públicos do mixin;
  • BlipForQuestionAnswering possui um método generate personalizado que compartilha aproximadamente a mesma interface de GenerationMixin.generate (ele tem alguns argumentos extras e a mesma saída). Essa função também chama GenerationMixin.generate indiretamente, por meio de um modelo interno. Dessa forma, BlipForQuestionAnswering deve herdar de GenerationMixin para se beneficiar de toda a automação relacionada à geração em nossa base de código;
  • BarkModel possui um método generate personalizado e um de seus modelos internos chama GenerationMixin.generate. No entanto, seu generate não compartilha a mesma interface que GenerationMixin.generate. Nesse caso, BarkModel NÃO deve herdar de GenerationMixin, pois isso quebra a interface de generate.

A classe expõe generate(), que pode ser usada para:

  • decodificação gulosa se num_beams=1 e do_sample=False
  • amostragem multinomial se num_beams=1 e do_sample=True
  • decodificação por busca em feixe se num_beams>1 e do_sample=False
  • amostragem multinomial com beam-search se num_beams>1 e do_sample=True
  • decodificação assistida se assistant_model ou prompt_lookup_num_tokens for passado para .generate()

Para saber mais sobre as estratégias de decodificação, consulte o guia de estratégias de geração de texto.

generate

< >

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

Parâmetros

  • inputs (torch.Tensor de forma variável dependendo da modalidade, opcional) — A sequência usada como prompt para a geração ou como entrada do modelo para o codificador. Se None, o método a inicializa com bos_token_id e um tamanho de lote de 1. Para modelos apenas de decodificador, inputs deve estar no formato de input_ids. Para modelos codificador-decodificador, inputs pode representar qualquer um de input_ids, input_values, input_features ou pixel_values.
  • generation_config (GenerationConfig, opcional) — A configuração de geração a ser usada como parametrização base para a chamada de geração. Os **kwargs passados para generate que correspondam aos atributos de generation_config os sobrescreverão. Se generation_config não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo generation_config.json, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de GenerationConfig, cuja documentação deve ser consultada para parametrizar a geração.
  • logits_processor (LogitsProcessorList, opcional) — Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de geração. Se um processador de logits for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Este recurso é destinado a usuários avançados.
  • stopping_criteria (StoppingCriteriaList, opcional) — Critérios de parada personalizados que complementam os critérios de parada padrão criados a partir dos argumentos e de uma configuração de geração. Se um critério de parada for passado que já foi criado com os argumentos ou com uma configuração de geração, um erro será lançado. Se o seu critério de parada depende da entrada scores, certifique-se de passar return_dict_in_generate=True, output_scores=True para generate. Este recurso é destinado a usuários avançados.
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]], opcional) — Se fornecida, esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Se não for fornecida, nenhuma restrição é aplicada. Esta função recebe 2 argumentos: o ID do lote batch_id e input_ids. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada ao ID do lote batch_id e aos tokens gerados anteriormente inputs_ids. Este argumento é útil para geração condicionada ao prefixo, conforme descrito em Autoregressive Entity Retrieval.
  • synced_gpus (bool, opcional) — Se deve continuar executando o loop while até max_length. A menos que seja sobrescrito, este sinalizador será definido como True ao usar FullyShardedDataParallel ou DeepSpeed ZeRO Stage 3 com múltiplas GPUs para evitar deadlock caso uma GPU termine a geração antes das outras. Caso contrário, o valor padrão é False.
  • assistant_model (PreTrainedModel, opcional) — Um modelo assistente que pode ser usado para acelerar a geração. O modelo assistente deve ter exatamente o mesmo tokenizer. A aceleração é obtida quando a previsão de tokens candidatos com o modelo assistente é muito mais rápida do que executar a geração com o modelo do qual você está chamando generate. Dessa forma, o modelo assistente deve ser muito menor.
  • streamer (BaseStreamer, opcional) — Objeto que será usado para transmitir as sequências geradas. Os tokens gerados são passados por streamer.put(token_ids) e o streamer é responsável por qualquer processamento adicional.
  • negative_prompt_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — O prompt negativo necessário para alguns processadores, como o CFG. O tamanho do lote deve corresponder ao tamanho do lote de entrada. Esta é uma funcionalidade experimental, sujeita a alterações na API que podem quebrar a compatibilidade em versões futuras.
  • negative_prompt_attention_mask (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Attention_mask para negative_prompt_ids.
  • custom_generate (str ou Callable, opcional) — Um dos seguintes:
    • str (nome do repositório no Hugging Face Hub): executa a função personalizada generate definida em custom_generate/generate.py nesse repositório, em vez do método padrão generate. O repositório substitui completamente a lógica de geração, e o tipo de retorno pode ser diferente.
    • str (caminho do repositório local): o mesmo que acima, mas a partir de um caminho local. Diretórios locais também exigem trust_remote_code=True porque o custom_generate/generate.py local é executado.
    • Callable: generate executará as etapas habituais de preparação da entrada e, em seguida, chamará a função fornecida para executar o loop de decodificação. Para mais informações, consulte a documentação.
  • kwargs (dict[str, Any], opcional) — Parametrização ad hoc de generation_config e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função forward do modelo. Se o modelo for um modelo encoder-decoder, os kwargs específicos do encoder não devem ter prefixo e os kwargs específicos do decoder devem ter o prefixo decoder_.

Retorna

ModelOutput ou torch.LongTensor

Um ModelOutput (se return_dict_in_generate=True ou quando config.return_dict_in_generate=True) ou um torch.LongTensor.

Se o modelo não for um modelo encoder-decoder (model.config.is_encoder_decoder=False), os tipos possíveis de ModelOutput são:

Se o modelo for um modelo encoder-decoder (model.config.is_encoder_decoder=True), os tipos possíveis de ModelOutput são:

Gera sequências de ids de tokens para modelos com uma cabeça de modelagem de linguagem.

A maioria dos parâmetros de controle de geração é definida em generation_config, que, se não for fornecida, será definida como a configuração de geração padrão do modelo. Você pode sobrescrever qualquer generation_config passando os parâmetros correspondentes para generate(), por exemplo, .generate(inputs, num_beams=4, do_sample=True).

Para uma visão geral das estratégias de geração e exemplos de código, consulte o guia a seguir.

compute_transition_scores

< >

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

Parâmetros

  • sequences (torch.LongTensor) — As sequências geradas. A segunda dimensão (sequence_length) é igual a max_length ou mais curta, caso todos os lotes tenham terminado antecipadamente devido ao eos_token_id.
  • scores (tuple(torch.Tensor)) — Pontuações de transição para cada token do vocabulário em cada etapa de geração. Pontuações de transição de feixe consistindo de log probabilidades de tokens condicionadas ao log softmax dos tokens gerados anteriormente neste feixe. Tupla de torch.Tensor com até max_new_tokens elementos (um elemento para cada token gerado), com cada tensor de forma (batch_size*num_beams, config.vocab_size).
  • beam_indices (torch.LongTensor, opcional) — Índices dos feixes do id do token gerado em cada etapa de geração. torch.LongTensor de forma (batch_size*num_return_sequences, sequence_length). Necessário apenas se num_beams>1 no momento da geração.
  • normalize_logits (bool, opcional, padrão False) — Se as logits devem ser normalizadas (que, por motivos de legado, podem não estar normalizadas).

Retorna

torch.Tensor

Um torch.Tensor de forma (batch_size*num_return_sequences, sequence_length) contendo as pontuações de transição (logits)

Calcula as pontuações de transição das sequências com base nas pontuações de geração (e nos índices de feixe, se a busca por feixe foi utilizada). Este é um método conveniente para obter rapidamente as pontuações dos tokens selecionados no momento da geração.

Exemplos:

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

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

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

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

ContinuousMixin

classe transformers.ContinuousMixin

< >

( )

Classe mixin para modelos adicionarem capacidades de lote contínuo. O lote contínuo tem três pontos de entrada:

  • init_continuous_batching, que é o ponto de entrada real para o loteamento contínuo
  • continuous_batching_context_manager, que por sua vez é um wrapper em torno de init_continuous_batching
  • generate_batch, que é realmente um wrapper em torno de continuous_batching_context_manager

Eles são definidos nessa ordem. Qualquer alteração feita em qualquer um desses três pontos de entrada deve ser refletida nos outros dois.

continuous_batching_context_manager

< >

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

Um gerenciador de contexto para usar com segurança o gerenciador de loteamento contínuo. Os argumentos são semelhantes aos de init_continuous_batching, exceto por:

  • block: se deve bloquear a thread ao parar o gerenciador. O valor padrão é True.
  • timeout: tempo máximo para aguardar a parada da thread. O padrão é None (sem tempo limite).
  • warmup: se deve pré-capturar os gráficos CUDA nos maiores tamanhos antes de executar. O padrão é True.

destroy_cached_continuous_batching_manager

< >

( )

Destrua o gerenciador de loteamento contínuo em cache e libere os recursos da GPU.

generate_batch

< >

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

Parâmetros

  • inputs — Lista de sequências de tokens de entrada (prompts)
  • generation_config — Configuração de geração opcional
  • continuous_batching_config — Configuração opcional de loteamento contínuo
  • record_timestamps — Se definido como true, as solicitações terão um timestamp para cada token gerado
  • progress_bar — Se definido como true, uma barra de progresso será exibida
  • persistent_manager — se o gerenciador deve ser mantido após o término da geração. O valor padrão é False.
  • warmup — se deve pré-capturar os gráficos CUDA antes de processar as solicitações. O valor padrão é True.

Retorna

dict[str, GenerationOutput]

um dicionário de ids de solicitação para objetos GenerationOutput

Gere sequências para um lote de prompts usando continuous batching.

init_continuous_batching

< >

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

Parâmetros

  • generation_config — Uma configuração de geração opcional, que pode conter um objeto CompileConfig
  • continuous_batching_config — Uma configuração opcional de loteamento contínuo
  • workload_hints — WorkloadHints opcional para ajudar o gerenciador de continuous batching a tomar melhores decisões para os valores padrão

Retorna

ContinuousBatchingManager

A instância do gerenciador para adicionar solicitações e recuperar resultados.

Inicialize um gerenciador para inferência com loteamento contínuo.

ContinuousBatchingManager

classe transformers.ContinuousBatchingManager

< >

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

Gerenciador para o processamento de solicitações de geração com loteamento contínuo. Ele fornece uma interface de usuário para o envio de solicitações de geração, a recuperação de resultados e o gerenciamento da thread de geração em segundo plano. Esta classe não deve ser criada diretamente, mas por meio de um dos seguintes pontos de entrada (todos métodos do mixin ContinuousMixin):

  • init_continuous_batching
  • continuous_batching_context_manager
  • generate_batch

add_request

< >

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

Parâmetros

  • input_ids — IDs dos tokens de entrada a serem usados como prompt
  • request_id — ID de solicitação personalizado opcional (gerado automaticamente se for None)
  • max_new_tokens — Número máximo de novos tokens a serem gerados
  • streaming — Se os tokens devem ser transmitidos conforme são gerados
  • record_timestamps — Se deve registrar timestamps para cada token gerado
  • eos_token_id — ID(s) do(s) token(s) de fim de sequência
  • logit_processor_kwargs — Argumentos de palavra-chave para o processador de logits.

Retorna

str | None

O ID da solicitação, se o processo for um driver de TP; caso contrário, None.

Adiciona uma nova solicitação de geração à fila. Se o processo não for um driver de TP, esta é uma operação sem efeito.

add_requests

< >

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

Função utilitária para agrupar add_request e retornar seus IDs. Consulte sua documentação para mais detalhes.

cancel_request

< >

( request_id: str )

Cancela uma solicitação pelo seu ID. Se chamado de um processo que não é um driver de TP, é uma operação nula: apenas os processos de driver de TP interagem com o gerenciador.

destroy

< >

( )

Encerre o gerenciador e libere os recursos distribuídos. É seguro chamar várias vezes. Após chamar este método, o gerenciador não pode ser reiniciado.

get_result

< >

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

Recupera um resultado da fila de saída. Se um ID for fornecido, retorna a primeira solicitação correspondente. Se um timeout for fornecido, retorna None após o tempo limite (em segundos).

is_running

< >

( )

Retorna True se a thread de geração em segundo plano foi iniciada e ainda está ativa.

join

< >

( stop_trigger_time: floattimeout: float | None = None )

Aguarde a conclusão da thread em segundo plano. O tempo de espera pode ser limitado usando o argumento timeout (em segundos).

pausar

< >

( )

Um gerenciador de contexto que pausa o loop de geração, permitindo que a thread chamadora utilize o modelo, tipicamente para atualizá-lo no local. A thread só entra neste contexto quando o loop está pausado, e o loop retoma ao sair, mantendo seu cache e suas solicitações em andamento: nada é drenado e nenhuma solicitação é perdida. Várias threads podem manter a pausa simultaneamente, e o loop retoma quando a última delas sai. Se o TP estiver ativado, todos os ranks devem entrar neste contexto; caso contrário, os outros ranks ficarão pendurados para sempre.

register_result_handler

< >

( request_id: strcallback: Callable )

Parâmetros

  • request_id (str) — O ID da solicitação para receber as saídas.
  • callback (callable) — Chamado com um GenerationOutput para cada resultado.

Registre um callback para a entrega de resultados (com streaming ou sem streaming).

O callback é chamado no loop de eventos por meio de call_soon_threadsafe sempre que um resultado é produzido para esta solicitação. Para solicitações com streaming, isso ocorre a cada token; para as não-streaming, apenas na conclusão. O manipulador é limpo automaticamente quando a solicitação termina.

request_id_iter

< >

( request_id: str )

Iterar sobre os resultados que correspondem a um id de solicitação específico (bloqueante).

Usa a fila de saída compartilhada com requeue. Para atendimento com alta concorrência, use register_result_handler em vez disso.

início

< >

( )

Inicie a thread de geração em segundo plano.

stop

< >

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

Interrompe a thread de geração em segundo plano. Se a flag block estiver definida como True, este método aguarda a parada da thread por um tempo máximo de timeout segundos (None significa sem tempo limite). Se a flag keep_for_next_session estiver definida como True, o gerenciador é armazenado em cache no modelo para uso futuro. Se a flag hard_stop estiver definida, a thread de geração em segundo plano será interrompida imediatamente e as pendentes solicitações falharão.

switch_to_cb_friendly_attn

< >

( model: ProtoPretrainedModelauto_switch_to_flash: bool = True )

Alterne a implementação de attn para uma compatível com CB. Se auto_switch_to_flash for True e a implementação de attn for SDPA ou eager, alterne também para flash, caso seja suportado e disponível.

warmup

< >

( )

Pré-captura os gráficos CUDA para os caminhos varlen e decode executando lotes fictícios. Inicializa o processador de lotes, caso ainda não tenha sido feito.

Agendador

classe transformers.generation.Scheduler

< >

( cache: PagedAttentionCachesafety_margin: floatmax_requests_per_batch: int )

Classe base abstrata para agendar solicitações no processador de lote contínuo. Os agendadores gerenciam o ciclo de vida das solicitações desde o momento em que são adicionadas à fila de espera até o momento em que são agendadas para processamento. Diferentes agendadores implementam diferentes estratégias para priorizar e agrupar solicitações.

add_waiting_request

< >

( state: RequestState )

Adiciona uma solicitação à lista de espera.

clear_cancelled_requests

< >

( )

Remove todas as solicitações canceladas das filas de ativos e de espera.

finish_request

< >

( request_id: str )

Conclui o processamento de uma solicitação e libera os blocos de cache alocados para ela. Este método é chamado quando uma solicitação termina a geração ou encontra um erro.

get_active_request_static_outputs

< >

( request_id: str )

Obtém os tokens gerados para uma solicitação ativa.

has_pending_requests

< >

( )

Verifica se há solicitações prontas para serem processadas.

request_is_cancelled

< >

( request_id: str )

Verifica se uma solicitação foi cancelada ou removida.

reset

< >

( )

Redefina o estado do agendador para um novo loop de geração.

schedule_batch

< >

( token_budget: intcache_budget: int )

Agenda as solicitações para o próximo lote com base nos orçamentos disponíveis de tokens e de cache. Este método seleciona quais solicitações devem ser processadas no lote atual, considerando os orçamentos e as regras de priorização do agendador. O token_budget é o número máximo de tokens que podem ser processados em um lote, e o cache_budget é o número máximo de entradas de cache KV que podem ser lidas em um lote. Retorna a lista de solicitações agendadas em sua forma de “FutureRequestState”, um booleano indicando se o caminho rápido de decodificação pode ser usado, o número total de tokens de consulta e o número máximo de tokens kv lidos.

set_request_cancellation

< >

( request_id: str )

Marca uma solicitação de cancelamento.

FIFOScheduler

classe transformers.generation.FIFOScheduler

< >

( cache: PagedAttentionCachesafety_margin: float | Nonemax_requests_per_batch: int )

Este agendador processa as solicitações na ordem em que chegam, o que significa que as solicitações de decodificação têm prioridade sobre as solicitações de pré-preenchimento.

PrefillFirstScheduler

classe transformers.generation.PrefillFirstScheduler

< >

( cache: PagedAttentionCachesafety_margin: float | Nonemax_requests_per_batch: int )

Agendador que prioriza solicitações de pré-preenchimento dividido sobre solicitações de decodificação. Este agendador garante que as solicitações de pré-preenchimento dividido (que são continuação de prompts parcialmente processados) sejam concluídas antes de processar novas solicitações de decodificação.

Update on GitHub