# Geração

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

- O [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) do PyTorch é implementado em [GenerationMixin](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin).

Você pode parametrizar o método generate com uma instância da classe [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.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](../generation_strategies). O guia também explica como usar recursos relacionados, como streaming de tokens.

## GenerationConfig[[transformers.GenerationConfig]]

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

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

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

**Parâmetros que controlam o comprimento da saída:**

max_length (`int`, *opcional*) : recomenda-se `max_new_tokens` 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`, caso também esteja 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 feixe, como beam-search. Aceita os seguintes valores: `True`, em que a geração para assim que houver `num_beams` candidatos completos; `False`, em que um heurístico é aplicado 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 o cálculo seja executado. 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 se o modelo as produzir.

**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`): 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 do último passado (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:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/pt/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/pt/internal/generation_utils#transformers.QuantizedCache)  Se nenhum for especificado, usaremos a cache padrão do modelo (que frequentemente é [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache)). Consulte nossa [documentação de cache](https://huggingface.co/docs/transformers/en/kv_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 com o maior comprimento de chamada esperado, para que chamadas repetidas de `generate()` com um prompt mais longo ou um `max_new_tokens` maior (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 somadas sejam iguais ou superiores a `top_p`, é 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 entropia da distribuição é preservada durante a amostragem. Deve ser um valor entre 0 e 1. Em cada etapa, os tokens são ordenados por probabilidade e é mantido o menor prefixo de tokens 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 dos tokens mais localmente típicos, cujas probabilidades somam `typical_p` ou mais, é mantido para a geração. Veja [este artigo](https://huggingface.co/papers/2202.00666) 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](https://huggingface.co/papers/2210.15191) 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 é considerado apenas 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, escalada 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](https://huggingface.co/papers/2210.15191) para mais detalhes.

repetition_penalty (`float`, *opcional*) : O parâmetro para a penalidade de repetição. 1.0 significa sem penalidade. Veja [este artigo](https://huggingface.co/papers/1909.05858) 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 para o comprimento, utilizada na geração baseada em feixe. Ela é aplicada como 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 são permitidos para serem gerados. Consulte [NoBadWordsLogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.NoBadWordsLogitsProcessor) para mais documentação e exemplos.

renormalize_logits (`bool`) : Se deve renormalizar os logits após aplicar 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 a 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](../model_doc/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 exponencialmente crescente, após a geração de uma certa quantidade de tokens. A tupla deve consistir em: `(start_index, decay_factor)`, em que `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á os log probs deles 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éses positivos aumentam as chances de a sequência ser selecionada, enquanto viéses negativos fazem o oposto. Consulte [SequenceBiasLogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.SequenceBiasLogitsProcessor) para mais documentação e exemplos.

token_healing (`bool`) : Corrigir os tokens finais dos prompts substituindo-os pelas 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 maior 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](/docs/transformers/main/pt/internal/generation_utils#transformers.SynthIDTextWatermarkingConfig) e [WatermarkingConfig](/docs/transformers/main/pt/internal/generation_utils#transformers.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 os estados ocultos de todas as camadas devem ser retornados. 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 as pontuações de logit de previsão não processadas devem ser retornadas ou não. Consulte `logits` em tensores retornados para mais detalhes.

return_dict_in_generate (`bool`) : Indica se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.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 diferentes idiomas de destino em um único lote)

**Parâmetros de geração exclusivos para geração de assistente:**

is_assistant (`bool`) : Indica se o modelo é um modelo de 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 aumentos de velocidade podem ser alcançados; se o modelo assistente exigir muitas correções, os aumentos de velocidade serão menores.

num_assistant_tokens_schedule (`str`, *opcional*) : Define a agenda na qual os tokens máximos do assistente devem ser alterados durante a inferência. - `"heuristic"`: Quando todos os tokens especulativos estiverem corretos, aumenta `num_assistant_tokens` em 2; caso contrário, reduz em 1. O valor de `num_assistant_tokens` é persistente entre múltiplas 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 inferior a esse 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 de rascunho e 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 .

prompt_lookup_num_tokens (`int`, *opcional*) : O número de tokens a serem gerados 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`, *opcional*) : Se definido como um inteiro positivo, a saída antecipada do modelo será utilizada como um assistente. Pode ser usado apenas com modelos que suportam saída antecipada (ou seja, modelos em que os logits das camadas intermediárias podem ser interpretados pela cabeça do LM).

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 speculative decoding. Veja este [blog](https://huggingface.co/blog/universal_assisted_generation) 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](https://huggingface.co/blog/universal_assisted_generation) para mais detalhes.

assistant_ensemble_weight (`float`, *opcional*) : Habilita a verificação de ensemble estático na 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 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*) : Ao usar um cache compilável, este parâmetro 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 caso identifique 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](../generation_strategies).

Um grande número dessas flags controla os logits ou os critérios de parada da geração. Verifique as [classes relacionadas ao generate](https://huggingface.co/docs/transformers/internal/generation_utils) 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[[transformers.GenerationConfig.from_pretrained]]

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

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

**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()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig.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 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 sobrescrever 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 HTTP bearer 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 id de commit, 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`, esta função retorna apenas o objeto de configuração final. Se `True`, esta função retorna uma `Tuple(config, unused_kwargs)`, onde *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 é, portanto, 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`.

**Retorna:** [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig)

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

Instancie um [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig) a partir de um arquivo de configuração de geração.

Exemplos:

```python
>>> from transformers import GenerationConfig

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

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

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

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

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

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

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

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

**Parâmetros:**

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

**Retorna:** [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig)

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

Instancia um [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig) a partir de um [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig). Esta função é útil para converter objetos legados de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig), que podem conter parâmetros de geração, em um [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig) independente.

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

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

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

**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()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.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()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig.from_pretrained).

#### atualizar[[transformers.GenerationConfig.update]]

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

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

**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[[transformers.GenerationConfig.validate]]

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

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

**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 exclusivas de amostragem definidas enquanto `do_sample=False`) são acionados apenas se a flag conflitante estiver neste conjunto — evitando avisos desnecessários 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](/docs/transformers/main/pt/main_classes/text_generation#transformers.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[[transformers.GenerationConfig.get_generation_mode]]

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

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

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

## GenerationMixin[[transformers.GenerationMixin]]

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

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

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

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`, diretamente ou indiretamente, e 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 de 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 de `GenerationMixin.generate`. Nesse caso, `BarkModel` NÃO deve herdar de `GenerationMixin`, pois isso quebra a interface de `generate`.

A classe expõe [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.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](../generation_strategies).

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

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

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

**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 entradas 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](/docs/transformers/main/pt/main_classes/text_generation#transformers.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](/docs/transformers/main/pt/main_classes/text_generation#transformers.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 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](https://huggingface.co/papers/2010.00904).

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 deadlocks 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 Streamer 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 local do repositório): o mesmo que acima, mas a partir de um caminho local. Diretórios locais também exigem `trust_remote_code=True`, pois 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](../../generation_strategies#custom-generation-methods).

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](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.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](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são:

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

Se o modelo for um modelo encoder-decoder (`model.config.is_encoder_decoder=True`), os tipos possíveis de [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são:

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

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

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

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

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

**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 do feixe consistindo em log probabilidades de tokens condicionados ao log softmax dos tokens previamente gerados 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 dos ids de tokens gerados 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 deve normalizar os logits (que, por motivos de legado, podem estar não normalizados).

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

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

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

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

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

## ContinuousMixin[[transformers.ContinuousMixin]]

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

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

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

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 nesta ordem. Qualquer alteração feita em qualquer um desses três pontos de entrada deve ser refletida nos outros dois.

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

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

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

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

```python
destroy_cached_continuous_batching_manager()
```

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

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

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

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

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

**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 persistido após o término da geração. O valor padrão é False.

warmup : se as grafos CUDA devem ser pré-capturados antes do processamento das 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[[transformers.ContinuousMixin.init_continuous_batching]]

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

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

**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 loteamento contínuo 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[[transformers.ContinuousBatchingManager]]

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

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

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

Gerenciador para o processamento em lote contínuo de solicitações de geração. 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[[transformers.ContinuousBatchingManager.add_request]]

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

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

**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 carimbos de data e hora para cada token gerado

eos_token_id : ID(s) do token 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[[transformers.ContinuousBatchingManager.add_requests]]

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

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

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

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

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

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

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

```python
destroy()
```

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

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

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

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

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

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

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

```python
is_running()
```

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

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

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

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

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

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

#### pausa[[transformers.ContinuousBatchingManager.pause]]

```python
pause()
```

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

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

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

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

**Parâmetros:**

request_id (*str*) : O ID da solicitação para o qual 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[[transformers.ContinuousBatchingManager.request_id_iter]]

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

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

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.

#### iniciar[[transformers.ContinuousBatchingManager.start]]

```python
start()
```

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

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

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

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

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

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 será 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 solicitações pendentes serão falhadas.

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

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

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

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

```python
warmup()
```

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

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

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

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

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

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

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

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

Adiciona uma solicitação à lista de espera.

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

```python
clear_cancelled_requests()
```

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

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

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

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

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

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

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

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

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

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

```python
has_pending_requests()
```

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

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

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

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

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

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

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

```python
reset()
```

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

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

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

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

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

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 "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[[transformers.generation.Scheduler.set_request_cancellation]]

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

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

Marca uma solicitação de cancelamento.

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

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

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

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

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

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

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

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

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