# Utilitários para geração

Esta página lista todas as funções utilitárias usadas por [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate).

## Gerar Saídas[[transformers.generation.GenerateDecoderOnlyOutput]]

A saída de [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) é uma instância de uma subclasse de [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput). Essa saída é uma estrutura de dados que contém todas as informações retornadas por [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate), mas que também pode ser usada como tupla ou dicionário.

Aqui está um exemplo:

```python
from transformers import GPT2Tokenizer, GPT2LMHeadModel

tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2LMHeadModel.from_pretrained("openai-community/gpt2")

inputs = tokenizer("Hello, my dog is cute and ", return_tensors="pt")
generation_output = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
```

O objeto `generation_output` é um [GenerateDecoderOnlyOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput), como podemos ver na documentação dessa classe abaixo, o que significa que ele possui os seguintes atributos:

- `sequences`: as sequências de tokens geradas
- `scores` (opcional): as pontuações de previsão da cabeça de modelagem de linguagem, para cada etapa de geração
- `hidden_states` (opcional): os estados ocultos do modelo, para cada etapa de geração
- `attentions` (opcional): os pesos de atenção do modelo, para cada etapa de geração

Aqui temos os `scores`, pois passamos `output_scores=True`, mas não temos `hidden_states` e `attentions`, porque não passamos `output_hidden_states=True` ou `output_attentions=True`.

Você pode acessar cada atributo da forma habitual e, se esse atributo não tiver sido retornado pelo modelo, você receberá `None`. Aqui, por exemplo, `generation_output.scores` são todas as pontuações de previsão geradas pela cabeça de modelagem de linguagem, e `generation_output.attentions` é `None`.

Ao usar nosso objeto `generation_output` como uma tupla, ele mantém apenas os atributos que não possuem valores `None`. Aqui, por exemplo, ele tem dois elementos, `loss` e depois `logits`, então

```python
generation_output[:2]
```

retornará, por exemplo, a tupla `(generation_output.sequences, generation_output.scores)`.

Ao usar nosso objeto `generation_output` como um dicionário, ele mantém apenas os atributos que não possuem valores `None`. Aqui, por exemplo, ele tem duas chaves que são `sequences` e `scores`.

Documentamos aqui todos os tipos de saída.

#### transformers.generation.GenerateDecoderOnlyOutput[[transformers.generation.GenerateDecoderOnlyOutput]]

```python
transformers.generation.GenerateDecoderOnlyOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

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

**Parâmetros:**

sequences (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : 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)` *opcional*, retornado quando `output_scores=True`) : Pontuações de previsão processadas da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax) em cada etapa de geração. Tupla de `torch.Tensor` com até `max_new_tokens` elementos (um elemento para cada token gerado), com cada tensor de forma `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *opcional*, retornado quando `output_logits=True`) : Pontuações de previsão não processadas da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax) em cada etapa de geração. Tupla de `torch.Tensor` com até `max_new_tokens` elementos (um elemento para cada token gerado), com cada tensor de forma `(batch_size, config.vocab_size)`.

attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opcional*, retornado quando `use_cache=True`) : Retorna o cache do modelo, usado para acelerar a decodificação. Diferentes modelos possuem um formato de cache diferente; consulte a documentação do modelo. Normalmente, uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache).

Saídas de modelos de geração somente com decodificador, ao usar métodos que não são de feixe.

#### transformers.generation.GenerateEncoderDecoderOutput[[transformers.generation.GenerateEncoderDecoderOutput]]

```python
transformers.generation.GenerateEncoderDecoderOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

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

**Parâmetros:**

sequences (`torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`) : 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)` *opcional*, retornado quando `output_scores=True`) : Pontuações de previsão processadas da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax) em cada etapa de geração. Tupla de `torch.Tensor` com até `max_new_tokens` elementos (um elemento para cada token gerado), com cada tensor de forma `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *opcional*, retornado quando `output_logits=True`) : Pontuações de previsão não processadas da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax) em cada etapa de geração. Tupla de `torch.Tensor` com até `max_new_tokens` elementos (um elemento para cada token gerado), com cada tensor de forma `(batch_size, config.vocab_size)`.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada do decodificador) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opcional*, retornado quando `use_cache=True`) : Retorna o cache do modelo, usado para acelerar a decodificação. Diferentes modelos possuem um formato de cache diferente; consulte a documentação do modelo. Normalmente, uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache).

Saídas de modelos de geração encoder-decoder, ao usar métodos que não são de feixe.

#### transformers.generation.GenerateBeamDecoderOnlyOutput[[transformers.generation.GenerateBeamDecoderOnlyOutput]]

```python
transformers.generation.GenerateBeamDecoderOnlyOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

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

**Parâmetros:**

sequences (`torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`) : 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`.

sequences_scores (`torch.Tensor` de forma `(batch_size*num_return_sequences)`, *opcional*, retornado quando `output_scores=True`) : Pontuações finais do feixe das `sequences` geradas.

scores (`tuple(torch.Tensor)` *opcional*, retornado quando `output_scores=True`) : Pontuações de transição de feixe para cada token do vocabulário em cada etapa de geração. Pontuações de transição de 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)`.

logits (`tuple(torch.Tensor)` *opcional*, retornado quando `output_logits=True`) : Pontuações de previsão não processadas da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax) em cada etapa de geração. 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*, retornado quando `output_scores=True`) : Índices de feixe do id do token gerado em cada etapa de geração. `torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`.

attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *opcional*, retornado quando `use_cache=True`) : Retorna o cache do modelo, usado para acelerar a decodificação. Diferentes modelos possuem um formato de cache diferente; consulte a documentação do modelo. Normalmente, uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache).

Saídas de modelos de geração apenas com decodificador, ao usar métodos de feixe.

#### transformers.generation.GenerateBeamEncoderDecoderOutput[[transformers.generation.GenerateBeamEncoderDecoderOutput]]

```python
transformers.generation.GenerateBeamEncoderDecoderOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

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

**Parâmetros:**

sequences (`torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`) : 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`.

sequences_scores (`torch.Tensor` de forma `(batch_size*num_return_sequences)`, *opcional*, retornado quando `output_scores=True`) : Pontuações finais do feixe das `sequences` geradas.

scores (`tuple(torch.Tensor)` *opcional*, retornado quando `output_scores=True`) : Pontuações de transição de feixe para cada token do vocabulário em cada etapa de geração. Pontuações de transição de feixe consistindo em log probabilidades de tokens condicionados 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)`.

logits (`tuple(torch.Tensor)` *opcional*, retornado quando `output_logits=True`) : Pontuações de previsão não processadas da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax) em cada etapa de geração. Tupla de `torch.Tensor` com até `max_new_tokens` elementos (um elemento para cada token gerado), com cada tensor tendo a forma `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *opcional*, retornado quando `output_scores=True`) : Índices de feixe do id do token gerado em cada etapa de geração. `torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada do decodificador) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com formato `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla (um elemento para cada token gerado) de tuplas (um elemento para cada camada do decodificador) de `torch.Tensor` com forma `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *opcional*, retornado quando `use_cache=True`) : Retorna o cache do modelo, usado para acelerar a decodificação. Diferentes modelos possuem um formato de cache diferente; consulte a documentação do modelo. Normalmente, uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache).

Saídas de modelos de geração encoder-decoder, ao usar métodos de feixe.

## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

Um [LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) pode ser usado para modificar as pontuações de previsão da cabeça de um modelo de linguagem para geração.

#### transformers.AlternatingCodebooksLogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

```python
transformers.AlternatingCodebooksLogitsProcessor(input_start_len: int, semantic_vocab_size: int, codebook_size: int)
```

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

**Parâmetros:**

input_start_len (`int`) : O comprimento da sequência de entrada inicial.

semantic_vocab_size (`int`) : Tamanho do vocabulário da parte semântica, ou seja, o número de tokens associados ao vocabulário semântico.

codebook_size (`int`) : Número de tokens associados ao codebook.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe a geração alternada entre os dois codebooks do Bark.

Este processador de logits é compatível exclusivamente com o submodelo fino do [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark). Consulte a documentação do modelo para exemplos.

#### __call__[[transformers.AlternatingCodebooksLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

#### transformers.ClassifierFreeGuidanceLogitsProcessor[[transformers.ClassifierFreeGuidanceLogitsProcessor]]

```python
transformers.ClassifierFreeGuidanceLogitsProcessor(guidance_scale)
```

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

**Parâmetros:**

guidance_scale (float) : A escala de orientação para orientação livre de classificador (CFG). O CFG é ativado definindo `guidance_scale > 1`. Uma escala de orientação mais alta incentiva o modelo a gerar amostras mais estreitamente ligadas ao prompt de entrada, geralmente em detrimento de uma qualidade inferior.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) para classifier free guidance (CFG). As pontuações são divididas ao longo da dimensão do lote, em que a primeira metade corresponde aos logits condicionais (previstos a partir do prompt de entrada) e a segunda metade corresponde aos logits incondicionais (previstos a partir de um prompt vazio ou 'nulo'). O processador calcula uma média ponderada entre os logits condicionais e incondicionais, parametrizada pelo `guidance_scale`.

Veja [o artigo](https://huggingface.co/papers/2306.05284) para mais informações.

Este processador de logits é compatível exclusivamente com [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen)

Exemplos:

```python
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration

>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")

>>> inputs = processor(
...     text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
...     padding=True,
...     return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```

#### __call__[[transformers.ClassifierFreeGuidanceLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.EncoderNoRepeatNGramLogitsProcessor[[transformers.EncoderNoRepeatNGramLogitsProcessor]]

```python
transformers.EncoderNoRepeatNGramLogitsProcessor(encoder_ngram_size: int, encoder_input_ids: LongTensor)
```

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

**Parâmetros:**

encoder_ngram_size (`int`) : Todos os n-gramas de tamanho `ngram_size` podem ocorrer apenas nos ids de entrada do codificador.

encoder_input_ids (`int`) : O encoder_input_ids que não deve ser repetido dentro dos ids do decoder.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que funciona de forma semelhante ao [NoRepeatNGramLogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor), mas aplicado exclusivamente para evitar a repetição de n-gramas presentes no prompt.

Ele foi projetado para promover a conversa em um modelo de linguagem, impedindo a geração de n-gramas presentes em rodadas anteriores da conversa.

Exemplos:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("Alice: I love cats. What do you love?\nBob:", return_tensors="pt")

>>> # With greedy decoding, we see Bob repeating Alice's opinion. If Bob was a chatbot, it would be a poor one.
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: I love cats. What do you

>>> # With this logits processor, we can prevent Bob from repeating Alice's opinion.
>>> outputs = model.generate(**inputs, encoder_no_repeat_ngram_size=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: My cats are very cute.
```

#### __call__[[transformers.EncoderNoRepeatNGramLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.EncoderRepetitionPenaltyLogitsProcessor[[transformers.EncoderRepetitionPenaltyLogitsProcessor]]

```python
transformers.EncoderRepetitionPenaltyLogitsProcessor(penalty: float, encoder_input_ids: LongTensor)
```

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

**Parâmetros:**

penalty (`float`) : O parâmetro para a penalidade de repetição. 1.0 significa sem penalidade. Acima de 1.0 recompensa os tokens do prompt. Entre 0.0 e 1.0 penaliza os tokens do prompt.

encoder_input_ids (`torch.LongTensor`) : O encoder_input_ids que deve ser repetido dentro dos ids do decoder.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que funciona de forma semelhante ao [RepetitionPenaltyLogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor), mas com uma penalidade *inversa* aplicada aos tokens presentes no prompt. Em outras palavras, uma penalidade acima de 1,0 aumenta as chances de selecionar tokens que estavam presentes no prompt.

Ele foi projetado para evitar alucinação em tarefas baseadas na entrada, como a sumarização. Embora originalmente destinado a modelos encoder-decoder, ele também pode ser usado com modelos apenas de decoder, como LLMs.

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer(["Alice and Bob. The third member's name was"], return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
Alice and Bob. The third member's name was not mentioned.

>>> # With the `encoder_repetition_penalty` argument we can trigger this logits processor in `generate`, which can
>>> # promote the use of prompt tokens ("Bob" in this example)
>>> gen_out = model.generate(**inputs, encoder_repetition_penalty=1.2)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
Alice and Bob. The third member's name was Bob. The third member's name was Bob.
```

#### __call__[[transformers.EncoderRepetitionPenaltyLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.EpsilonLogitsWarper[[transformers.EpsilonLogitsWarper]]

```python
transformers.EpsilonLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

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

**Parâmetros:**

epsilon (`float`) : Se definido para > 0, apenas os tokens com probabilidades `epsilon` ou superiores são mantidos para a geração.

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores filtrados serão definidos como este valor float.

min_tokens_to_keep (`int`, *opcional*, padrão 1) : Número mínimo de tokens que não podem ser filtrados.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que executa amostragem por epsilon, ou seja, restringe-se a tokens com `prob >= epsilon`. Se nenhum token satisfizer essa restrição, utiliza os min_tokens_to_keep tokens maiores. Consulte [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) para mais informações.

Exemplos:
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With epsilon sampling, the output gets restricted to high-probability tokens. Note that this is similar to
>>> # Top P sampling, which restricts tokens based on their cumulative probability.
>>> # Pro tip: The paper recommends using `epsilon_cutoff` values between 3e-4 and 9e-4
>>> outputs = model.generate(**inputs, do_sample=True, epsilon_cutoff=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.EpsilonLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.EtaLogitsWarper[[transformers.EtaLogitsWarper]]

```python
transformers.EtaLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1, device: str = 'cpu')
```

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

**Parâmetros:**

epsilon (`float`) : Um valor float no intervalo (0, 1). Hiperparâmetro usado para calcular o valor de corte dinâmico, `eta`. Os valores sugeridos no artigo variam de 3e-4 a 4e-3, dependendo do tamanho do modelo.

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores encontrados abaixo do valor de corte dinâmico, `eta`, são definidos para este valor float. Este parâmetro é útil quando os logits precisam ser modificados para tokens de probabilidade muito baixa que devem ser excluídos completamente da geração.

min_tokens_to_keep (`int`, *opcional*, padrão 1) : Especifica o número mínimo de tokens que devem ser mantidos para a geração, independentemente de suas probabilidades. Por exemplo, se `min_tokens_to_keep` for definido como 1, pelo menos um token será sempre mantido para a geração, mesmo que todos os tokens tenham probabilidades abaixo do limite `eta`.

device (`str`, *opcional*, padrão `"cpu"`) : O dispositivo para alocar os tensores.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que executa o eta-sampling, uma técnica para filtrar tokens com probabilidades abaixo de um valor de corte dinâmico, `eta`, calculado com base em uma combinação do hiperparâmetro `epsilon` e da entropia das probabilidades dos tokens, ou seja, `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. Seleciona os maiores min_tokens_to_keep tokens caso nenhum token satisfaça essa restrição. Aborda o problema da baixa qualidade em amostras longas de texto geradas por modelos de linguagem neurais, resultando em um texto mais coerente e fluente. Consulte [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) para mais informações. Observação: `do_sample` deve ser definido como `True` para que este `LogitsProcessor` funcione.

Exemplos:
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With eta sampling, the output gets restricted to high-probability tokens. You can see it as a dynamic form of
>>> # epsilon sampling that adapts its cutoff probability based on the entropy (high entropy = lower cutoff).
>>> # Pro tip: The paper recommends using `eta_cutoff` values between 3e-4 to 4e-3
>>> outputs = model.generate(**inputs, do_sample=True, eta_cutoff=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.EtaLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.ExponentialDecayLengthPenalty[[transformers.ExponentialDecayLengthPenalty]]

```python
transformers.ExponentialDecayLengthPenalty(exponential_decay_length_penalty: tuple, eos_token_id: typing.Union[int, list[int], torch.Tensor], input_ids_seq_length: int)
```

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

**Parâmetros:**

exponential_decay_length_penalty (`tuple(int, float)`) : Esta 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

eos_token_id (`Union[int, list[int], torch.Tensor]`) : O(s) id(s) do token *end-of-sequence*.

input_ids_seq_length (`int`) : O comprimento da sequência de entrada.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que aumenta exponencialmente a pontuação do `eos_token_id` após o `start_index` ter sido atingido. Isso permite gerar sequências mais curtas sem um corte rígido, permitindo que o `eos_token` seja previsto em uma posição significativa.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")

>>> text = "Just wanted to let you know, I"
>>> inputs = tokenizer(text, return_tensors="pt")

>>> # Let's consider that we want short sentences, so we limit `max_length=30`. However, we observe that the answer
>>> # tends to end abruptly.
>>> set_seed(1)
>>> outputs = model.generate(**inputs, do_sample=True, temperature=0.9, max_length=30, pad_token_id=50256)
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was
published in 2010. Although

>>> # To promote the appearance of the EOS token at the right time, we add the `exponential_decay_length_penalty =
>>> # (start_index, decay_factor)`. Instead of cutting at max_tokens, the output comes to an end before and usually
>>> # with more meaning. What happens is that starting from `start_index` the EOS token score will be increased
>>> # by `decay_factor` exponentially. However, if you set a high decay factor, you may also end up with abruptly
>>> # ending sequences.
>>> set_seed(1)
>>> outputs = model.generate(
...     **inputs,
...     do_sample=True,
...     temperature=0.9,
...     max_length=30,
...     pad_token_id=50256,
...     exponential_decay_length_penalty=(15, 1.6),
... )
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network
which<|endoftext|>

>>> # With a small decay factor, you will have a higher chance of getting a meaningful sequence.
>>> set_seed(1)
>>> outputs = model.generate(
...     **inputs,
...     do_sample=True,
...     temperature=0.9,
...     max_length=30,
...     pad_token_id=50256,
...     exponential_decay_length_penalty=(15, 1.01),
... )
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was
published in 2010.<|endoftext|>
```

#### __call__[[transformers.ExponentialDecayLengthPenalty.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.ForcedBOSTokenLogitsProcessor[[transformers.ForcedBOSTokenLogitsProcessor]]

```python
transformers.ForcedBOSTokenLogitsProcessor(bos_token_id: int)
```

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

**Parâmetros:**

bos_token_id (`int`) : O id do token a ser forçado como o primeiro token gerado.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe o token especificado como o primeiro token gerado. Usado com modelos encoder-decoder.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

>>> model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")

>>> inputs = tokenizer("Translate from English to German: I love cats.", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=10)
>>> print(tokenizer.batch_decode(outputs)[0])
<pad> Ich liebe Kitty.</s>

>>> # We can use `forced_bos_token_id` to force the start of generation with an encoder-decoder model
>>> # (including forcing it to end straight away with an EOS token)
>>> outputs = model.generate(**inputs, max_new_tokens=10, forced_bos_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(outputs)[0])
<pad></s>
```

#### __call__[[transformers.ForcedBOSTokenLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.ForcedEOSTokenLogitsProcessor[[transformers.ForcedEOSTokenLogitsProcessor]]

```python
transformers.ForcedEOSTokenLogitsProcessor(max_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

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

**Parâmetros:**

max_length (`int`) : O comprimento máximo da sequência a ser gerada.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : O(s) id(s) do token *end-of-sequence*.

device (`str`, *opcional*, padrão `"cpu"`) : O dispositivo para alocar os tensores.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe o token especificado como o último token gerado quando `max_length` é atingido.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=10)
>>> print(tokenizer.batch_decode(outputs)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8

>>> # `forced_eos_token_id` ensures the generation ends with a EOS token
>>> outputs = model.generate(**inputs, max_new_tokens=10, forced_eos_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(outputs)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7,<|endoftext|>
```

#### __call__[[transformers.ForcedEOSTokenLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.InfNanRemoveLogitsProcessor[[transformers.InfNanRemoveLogitsProcessor]]

```python
transformers.InfNanRemoveLogitsProcessor()
```

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

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que remove todos os valores `nan` e `inf` para evitar que o método de geração falhe. Observe que o uso do processador de logits deve ser feito apenas quando necessário, pois pode tornar o método de geração mais lento.

Este processador de logits não possui um exemplo de `generate`, pois não deve existir uma combinação correta de flags que justifique seu uso.

#### __call__[[transformers.InfNanRemoveLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.LogitNormalization[[transformers.LogitNormalization]]

```python
transformers.LogitNormalization()
```

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

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) para normalizar as pontuações usando log-softmax. É importante normalizar as pontuações durante a busca por feixe, após a aplicação dos processadores ou warpers de logits, pois o algoritmo de busca utilizado nesta biblioteca não o faz (ele apenas o faz antes, mas eles podem precisar de renormalização), embora ele ainda suponha que as pontuações estejam normalizadas ao comparar as hipóteses.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> import torch

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt")

>>> # By default, the scores are not normalized -- the sum of their exponentials is NOT a normalized probability
>>> # distribution, summing to 1
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4))
False

>>> # Normalizing them may have a positive impact on beam methods, or when using the scores on your application
>>> outputs = model.generate(**inputs, renormalize_logits=True, return_dict_in_generate=True, output_scores=True)
>>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4))
True
```

#### __call__[[transformers.LogitNormalization.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.LogitsProcessor[[transformers.LogitsProcessor]]

```python
transformers.LogitsProcessor()
```

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

Classe base abstrata para todos os processadores de logits que podem ser aplicados durante a geração.

#### __call__[[transformers.LogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.LogitsProcessorList[[transformers.LogitsProcessorList]]

```python
transformers.LogitsProcessorList(iterable = ())
```

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

Esta classe pode ser usada para criar uma lista de [LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) para, em seguida, processar um tensor de entrada `scores`. Esta classe herda de list e adiciona um método *__call__* específico para aplicar cada [LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) às entradas.

#### __call__[[transformers.LogitsProcessorList.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionais específicos para um processador de logits.

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.MinLengthLogitsProcessor[[transformers.MinLengthLogitsProcessor]]

```python
transformers.MinLengthLogitsProcessor(min_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

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

**Parâmetros:**

min_length (`int`) : O comprimento mínimo abaixo do qual a pontuação de `eos_token_id` é definida como `-float("Inf")`.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : O(s) id(s) do token *end-of-sequence*.

device (`str`, *opcional*, padrão `"cpu"`) : O dispositivo para alocar os tensores.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe um comprimento mínimo definindo a probabilidade de EOS como 0. Observe que, para modelos apenas de decodificador, como a maioria dos LLMs, o comprimento inclui o prompt.

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("A number:", return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting `min_length` to a value smaller than the uncontrolled output length has no impact
>>> gen_out = model.generate(**inputs, min_length=3)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting a larger `min_length` will force the model to generate beyond its natural ending point, which is not
>>> # necessarily incorrect
>>> gen_out = model.generate(**inputs, min_length=10)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one thousand, nine hundred and ninety-four
```

#### __call__[[transformers.MinLengthLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.MinNewTokensLengthLogitsProcessor[[transformers.MinNewTokensLengthLogitsProcessor]]

```python
transformers.MinNewTokensLengthLogitsProcessor(prompt_length_to_skip: int, min_new_tokens: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

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

**Parâmetros:**

prompt_length_to_skip (`int`) : O comprimento dos tokens de entrada. Não é um argumento válido quando usado com `generate`, pois o comprimento de entrada será atribuído automaticamente.

min_new_tokens (`int`) : O comprimento mínimo de *novos* tokens abaixo do qual a pontuação de `eos_token_id` é definida como `-float("Inf")`.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : O(s) id(s) do token *end-of-sequence*.

device (`str`, *opcional*, padrão `"cpu"`) : O dispositivo para alocar os tensores.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe um comprimento mínimo de novos tokens, definindo a probabilidade do token EOS (End-Of-Sequence) como 0. Diferentemente de [MinLengthLogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.MinLengthLogitsProcessor), este processador ignora o prompt.

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer(["A number:"], return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting `min_new_tokens` will force the model to generate beyond its natural ending point, which is not
>>> # necessarily incorrect
>>> gen_out = model.generate(**inputs, min_new_tokens=2)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one thousand
```

#### __call__[[transformers.MinNewTokensLengthLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.MinPLogitsWarper[[transformers.MinPLogitsWarper]]

```python
transformers.MinPLogitsWarper(min_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

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

**Parâmetros:**

min_p (`float`) : 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 à configuração de `top_p` na faixa de 0,99 a 0,8 (use o oposto dos valores normais de `top_p`).

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores filtrados serão definidos como este valor float.

min_tokens_to_keep (`int`, *opcional*, padrão 1) : Número mínimo de tokens que não podem ser filtrados.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que executa min-p, ou seja, mantém todos os tokens que estão acima de uma probabilidade mínima, escalada pela probabilidade do token mais provável. Como resultado, o filtro se torna mais agressivo na presença de tokens de alta probabilidade, o que é um sinal de uma saída confiante da qual não devemos nos desviar.

Frequentemente usado em conjunto com [TemperatureLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TemperatureLogitsWarper). Utilizado como alternativa para [TopPLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TopPLogitsWarper) e [TopKLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TopKLogitsWarper).

Criado por @menhguin e @kalomaze (nomes de usuário no GitHub). Código adaptado de [este PR externo](https://github.com/oobabooga/text-generation-webui/pull/4449/files)

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With `min_p` sampling, the output gets restricted to high-probability tokens.
>>> # Pro tip: In practice, LLMs use `min_p` in the 0.01-0.2 range.
>>> outputs = model.generate(**inputs, do_sample=True, min_p=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.MinPLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

#### transformers.NoBadWordsLogitsProcessor[[transformers.NoBadWordsLogitsProcessor]]

```python
transformers.NoBadWordsLogitsProcessor(bad_words_ids: list, eos_token_id: typing.Union[int, list[int], torch.Tensor, NoneType] = None)
```

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

**Parâmetros:**

bad_words_ids (`list[list[int]]`) : Lista de listas de ids de tokens que não são permitidos para serem gerados.

eos_token_id (`Union[int, list[int], torch.Tensor]`, *opcional*) : O(s) id(s) do token de *fim de sequência*.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe que sequências especificadas nunca sejam selecionadas.

Para obter os ids dos tokens das palavras que não devem aparecer no texto gerado, certifique-se de definir `add_prefix_space=True` ao inicializar o tokenizer e usar `tokenizer(bad_words, add_special_tokens=False).input_ids`. O argumento `add_prefix_space` é suportado apenas por alguns tokenizers lentos, pois o comportamento de prefixação dos tokenizers rápidos vem do `pre tokenizers`. Leia mais [aqui](https://huggingface.co/docs/tokenizers/api/pre-tokenizers).

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["In a word, the cake is a"], return_tensors="pt")

>>> output_ids = model.generate(inputs["input_ids"], max_new_tokens=5, pad_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0])
In a word, the cake is a bit of a mess.

>>> # Now let's take the bad words out. Please note that the tokenizer is initialized differently
>>> tokenizer_with_prefix_space = AutoTokenizer.from_pretrained("openai-community/gpt2", add_prefix_space=True)

>>> def get_tokens_as_list(word_list):
...     "Converts a sequence of words into a list of tokens"
...     tokens_list = []
...     for word in word_list:
...         tokenized_word = tokenizer_with_prefix_space([word], add_special_tokens=False).input_ids[0]
...         tokens_list.append(tokenized_word)
...     return tokens_list

>>> bad_words_ids = get_tokens_as_list(word_list=["mess"])
>>> output_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=5, bad_words_ids=bad_words_ids, pad_token_id=tokenizer.eos_token_id
... )
>>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0])
In a word, the cake is a bit of a surprise.
```

#### __call__[[transformers.NoBadWordsLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.NoRepeatNGramLogitsProcessor[[transformers.NoRepeatNGramLogitsProcessor]]

```python
transformers.NoRepeatNGramLogitsProcessor(ngram_size: int)
```

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

**Parâmetros:**

ngram_size (`int`) : Todos os n-gramas de tamanho `ngram_size` podem ocorrer apenas uma vez.

N-grams são grupos de "n" palavras, caracteres ou tokens consecutivos extraídos de uma sequência de texto. Dada a frase: "She runs fast", os bi-grams (n=2) seriam ("she", "runs") e ("runs", "fast"). Na geração de texto, evitar repetições de sequências de palavras fornece uma saída mais diversa. Este [LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) impõe a não repetição de n-grams definindo as pontuações dos tokens proibidos como infinito negativo, o que elimina esses tokens da consideração ao processar as pontuações subsequentemente. Observe que, para modelos apenas de decodificador, como a maioria dos LLMs, o prompt também é considerado para obter os n-grams. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345).

Use penalidades de n-gramas com cautela. Por exemplo, penalizar 2-gramas (bigramas) em um artigo sobre a cidade de Nova York pode levar a resultados indesejados em que o nome da cidade aparece apenas uma vez em todo o texto. [Referência](https://huggingface.co/blog/how-to-generate)

Exemplos:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
>>> inputs = tokenizer(["Today I"], return_tensors="pt")

>>> output = model.generate(**inputs)
>>> print(tokenizer.decode(output[0], skip_special_tokens=True))
Today I'm not sure if I'm going to be able to do it.

>>> # Now let's add ngram size using `no_repeat_ngram_size`. This stops the repetitions ("I'm") in the output.
>>> output = model.generate(**inputs, no_repeat_ngram_size=2)
>>> print(tokenizer.decode(output[0], skip_special_tokens=True))
Today I'm not sure if I can get a better understanding of the nature of this issue
```

#### __call__[[transformers.NoRepeatNGramLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.PrefixConstrainedLogitsProcessor[[transformers.PrefixConstrainedLogitsProcessor]]

```python
transformers.PrefixConstrainedLogitsProcessor(prefix_allowed_tokens_fn: Callable, num_beams: int)
```

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

**Parâmetros:**

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : Esta função restringe a busca por feixe apenas aos tokens permitidos em cada etapa. Esta função recebe 2 argumentos, `inputs_ids` e o ID do lote `batch_id`. Ela deve retornar uma lista com os tokens permitidos para a próxima etapa de geração, condicionada aos tokens gerados anteriormente `inputs_ids` e ao ID do lote `batch_id`.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impõe geração restrita e é útil para geração restrita condicionada por prefixo. Consulte [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) para mais informações.

Exemplos:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("Alice and Bob", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=5)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice and Bob are friends

>>> # We can constrain it with `prefix_allowed_tokens_fn` to force a certain behavior based on a prefix.
>>> # For instance, we can force an entire entity to be generated when its beginning is detected.
>>> entity = tokenizer(" Bob Marley", return_tensors="pt").input_ids[0]  # 3 tokens
>>> def prefix_allowed_tokens_fn(batch_id, input_ids):
...     '''
...     Attempts to generate 'Bob Marley' when 'Bob' is detected.
...     In this case, `batch_id` is not used, but you can set rules for each batch member.
...     '''
...     if input_ids[-1] == entity[0]:
...         return [entity[1].item()]
...     elif input_ids[-2] == entity[0] and input_ids[-1] == entity[1]:
...         return [entity[2].item()]
...     return list(range(tokenizer.vocab_size))  # If no match, allow all tokens

>>> outputs = model.generate(**inputs, max_new_tokens=5, prefix_allowed_tokens_fn=prefix_allowed_tokens_fn)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice and Bob Marley
```

#### __call__[[transformers.PrefixConstrainedLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.RepetitionPenaltyLogitsProcessor[[transformers.RepetitionPenaltyLogitsProcessor]]

```python
transformers.RepetitionPenaltyLogitsProcessor(penalty: float, prompt_ignore_length: typing.Union[int, torch.Tensor, NoneType] = None)
```

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

**Parâmetros:**

penalty (`float`) : O parâmetro para a penalidade de repetição. 1.0 significa sem penalidade. Valores acima de 1.0 penalizam tokens gerados anteriormente. Valores entre 0.0 e 1.0 recompensam tokens gerados anteriormente.

prompt_ignore_length (`int` ou `torch.LongTensor`, *opcional*) : Número de tokens iniciais a serem ignorados, especificado opcionalmente por elemento do lote.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que impede a repetição de tokens anteriores por meio de uma penalidade. Essa penalidade é aplicada no máximo uma vez por token. Observe que, para modelos apenas de decodificador, como a maioria dos LLMs, os tokens considerados incluem o prompt por padrão.

No [artigo](https://huggingface.co/papers/1909.05858) original, os autores sugerem o uso de uma penalidade em torno de 1,2 para alcançar um bom equilíbrio entre a geração fiel e a ausência de repetição. Para penalizar e reduzir a repetição, use valores de `penalty` acima de 1,0, em que um valor maior penaliza com mais força. Para recompensar e incentivar a repetição, use valores de `penalty` entre 0,0 e 1,0, em que um valor menor recompensa com mais força.

Exemplos:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, RepetitionPenaltyLogitsProcessor

>>> # Initializing the model and tokenizer for it
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
>>> inputs = tokenizer(["I'm not going to"], return_tensors="pt")

>>> # This shows a normal generate without any specific parameters
>>> summary_ids = model.generate(**inputs)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'm going to be able to do that

>>> # This generates a penalty for repeated tokens
>>> penalized_ids = model.generate(**inputs, repetition_penalty=1.1)
>>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'll just have to go out and play

>>> # We can also exclude the input prompt by creating an instance of this class
>>> # with a `prompt_ignore_length` and passing it as a custom logit processor
>>> rep_pen_processor = RepetitionPenaltyLogitsProcessor(
...     penalty=1.1,
...     prompt_ignore_length=inputs["input_ids"].shape[-1]
... )
>>> penalized_ids = model.generate(**inputs, logits_processor=[rep_pen_processor])
>>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'm going to have to go through a lot of things, and
```

#### __call__[[transformers.RepetitionPenaltyLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.SequenceBiasLogitsProcessor[[transformers.SequenceBiasLogitsProcessor]]

```python
transformers.SequenceBiasLogitsProcessor(sequence_bias: list)
```

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

**Parâmetros:**

sequence_bias (`list[list[Union[list[int], float]]]`) : Lista de listas que mapeia uma sequência de tokens para seu termo de viés (por exemplo, `[[[10, 45], -2.0], [[64], -7.5]]`). Viéses positivos aumentam as chances de a sequência ser selecionada, enquanto viéses negativos fazem o oposto. Se uma sequência tiver comprimento 1, seu viés será sempre aplicado. Caso contrário, o viés será aplicado apenas se a sequência em questão estiver prestes a ser concluída (na etapa de seleção de tokens após a aplicação deste processador).

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que aplica um viés aditivo em sequências. O viés é aplicado ao último token de uma sequência quando o próximo token gerado pode completá-la. Consequentemente, para aproveitar ao máximo o viés em sequências com mais de um token, considere usar métodos de feixe (para lidar de forma elegante com sequências parcialmente completas que possuem um viés negativo) e aplicar o viés aos seus prefixos (para garantir que o viés seja aplicado mais cedo).

Em nível de token, enviesar uma palavra é diferente de enviesar uma palavra com um espaço antes dela. Se você quiser enviesar "foo" no meio de uma frase, provavelmente deverá adicionar um espaço de prefixo e enviesar " foo" em vez disso. Consulte a seção de tokenização do nosso curso de NLP para entender o motivo: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
>>> inputs = tokenizer(["The full name of Donald is Donald"], return_tensors="pt")

>>> summary_ids = model.generate(inputs["input_ids"], max_new_tokens=4, do_sample=False)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Trump Sr.

>>> def get_tokens(word):
...     return tokenizer([word], add_special_tokens=False).input_ids[0]

>>> # IMPORTANT: Remember our tip about adding spaces before words to bias them correctly.
>>> sequence_bias = [[get_tokens("Trump"), -10.0],]  # will fail to apply bias
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Trump Sr.

>>> sequence_bias = [[get_tokens(" Trump"), -10.0],]  # will work
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Harper. He

>>> # We can also add a positive bias to nudge the model towards specific tokens or continuations. This technique
>>> # is also more effective when paired up with beam search.
>>> sequence_bias = [[get_tokens(" Donald Duck"), 10.0],]
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, num_beams=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald Duck. He is
```

#### __call__[[transformers.SequenceBiasLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.SuppressTokensAtBeginLogitsProcessor[[transformers.SuppressTokensAtBeginLogitsProcessor]]

```python
transformers.SuppressTokensAtBeginLogitsProcessor(begin_suppress_tokens, begin_index, device: str = 'cpu')
```

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

[SuppressTokensAtBeginLogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor) suprime uma lista de tokens assim que a função `generate` começa a gerar, usando os tokens `begin_index`. Isso deve garantir que os tokens definidos por `begin_suppress_tokens` não sejam gerados no início. Originalmente criado para o [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

Exemplos:

```python
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")

>>> # Whisper has `begin_suppress_tokens` set by default (= `[220, 50256]`). 50256 is the EOS token, so this means
>>> # it can't generate and EOS token in the first iteration, but it can in the others.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(outputs.scores[0][0, 50256])
tensor(-inf)
>>> print(outputs.scores[-1][0, 50256])  # in other places we can see some probability mass for EOS
tensor(29.9010)

>>> # If we disable `begin_suppress_tokens`, we can generate EOS in the first iteration.
>>> outputs = model.generate(
...     **inputs, return_dict_in_generate=True, output_scores=True, begin_suppress_tokens=None
... )
>>> print(outputs.scores[0][0, 50256])
tensor(11.2027)
```

#### __call__[[transformers.SuppressTokensAtBeginLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.SuppressTokensLogitsProcessor[[transformers.SuppressTokensLogitsProcessor]]

```python
transformers.SuppressTokensLogitsProcessor(suppress_tokens, device: str = 'cpu')
```

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

Este processador pode ser usado para suprimir uma lista de tokens. O processador definirá os log probs deles como `-inf` para que não sejam gerados. Originalmente criado para o [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

Exemplos:

```python
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")

>>> # Whisper has a long list of suppressed tokens. For instance, in this case, the token 1 is suppressed by default.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(outputs.scores[1][0, 1])  # 1 (and not 0) is the first freely generated token
tensor(-inf)

>>> # If we disable `suppress_tokens`, we can generate it.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True, suppress_tokens=None)
>>> print(outputs.scores[1][0, 1])
tensor(6.0678)
```

#### __call__[[transformers.SuppressTokensLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.SynthIDTextWatermarkLogitsProcessor[[transformers.SynthIDTextWatermarkLogitsProcessor]]

```python
transformers.SynthIDTextWatermarkLogitsProcessor(ngram_len: int, keys: list, sampling_table_size: int, sampling_table_seed: int, context_history_size: int, device: device, skip_first_ngram_calls: bool = False, debug_mode: bool = False)
```

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

**Parâmetros:**

ngram_len (`int`) : Comprimento do n-grama.

keys (`list[int]`) : Uma sequência de chaves de marca d'água, uma para cada profundidade.

sampling_table_size (`int`) : Tamanho da tabela de amostragem.

sampling_table_seed (`int`) : Semente aleatória para gerar a tabela de amostragem.

context_history_size (`int`) : Tamanho do tensor para manter o controle dos contextos vistos.

device (`torch.device`) : Dispositivo a ser usado.

skip_first_ngram_calls (`bool`, *opcional*, padrão `False`) : Se deve ignorar as primeiras chamadas de ngram.

debug_mode (`bool`, *opcional*, padrão `False`) : Os logits são modificados para um uniforme obtido antes da aplicação da modificação de marca d'água. Isso serve para testar a implementação.

Processador de logits que implementa técnicas de marca d'água para modelos de geração de texto. Esta classe facilita a aplicação da marca d'água de texto SynthID, um método para incorporar sinais imperceptíveis em textos gerados, auxiliando na detecção de conteúdo sintético. Ele opera manipulando sutilmente as probabilidades de seleção de tokens durante a geração de texto, de uma forma que pode ser recuperada com confiabilidade posteriormente para verificação.

Principais recursos:
* **Gestão de estado:** Mantém o estado interno para rastrear sequências de tokens e gerar chaves de marca d'água
dinamicamente.

* **Geração de chaves:** Calcula hashes com base em sequências de tokens e parâmetros de marca d'água para criar chaves únicas
para cada posição.

* **Amostragem de valores G:** Utiliza uma tabela de amostragem pré-computada para amostrar valores de marca d'água (valores g) com base em
as chaves geradas.

* **Ajuste de pontuação:** aplica os valores g calculados para modificar as probabilidades dos tokens durante a geração, incorporando
marca d'água.

* **Tratamento de repetição de contexto:** Incorpora lógica para evitar a marcação de tokens em contextos repetidos,
preservando a naturalidade.

* **Mascaramento de tokens EOS:** Suporta a mascaramento de tokens de fim de frase para evitar sua inclusão na marca d'água
cálculos.

* **Funções utilitárias:** Fornece funções para calcular valores de g diretamente, verificar repetição de contexto, criar
Máscaras de tokens EOS e estimativa dos valores g médios esperados.

Consulte o URL do artigo: https://www.nature.com/articles/s41586-024-08025-4 para mais detalhes sobre isso.

Exemplos:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

>>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left")
>>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b')

>>> # SynthID Text configuration
>>> watermarking_config = SynthIDTextWatermarkingConfig(
...     keys=[654, 400, 836, 123, 340, 443, 597, 160, 57],
...     ngram_len=5,
... )

>>> # Generation with watermarking
>>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True)
>>> output_sequences = model.generate(
...     **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10
... )
>>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True)
```

#### __call__[[transformers.SynthIDTextWatermarkLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.TemperatureLogitsWarper[[transformers.TemperatureLogitsWarper]]

```python
transformers.TemperatureLogitsWarper(temperature: float)
```

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

**Parâmetros:**

temperature (`float`) : Valor float estritamente positivo usado para modular a distribuição de logits. Um valor menor que `1` diminui a aleatoriedade (e vice-versa), sendo `0` equivalente a deslocar toda a massa de probabilidade para o token mais provável.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) para temperatura (escalonamento exponencial da distribuição de probabilidade de saída), o que significa, na prática, que ele pode controlar a aleatoriedade dos tokens previstos. Frequentemente usado em conjunto com [TopPLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TopPLogitsWarper) e [TopKLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TopKLogitsWarper).

Certifique-se de que `do_sample=True` esteja incluído nos argumentos de `generate`; caso contrário, o valor de temperature não terá nenhum efeito.

Exemplos:

```python
>>> import torch
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(0)  # for reproducibility

>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> model.config.pad_token_id = model.config.eos_token_id
>>> inputs = tokenizer(["Hugging Face Company is"], return_tensors="pt")

>>> # With temperature=1.0, the default, we consistently get random outputs due to random sampling.
>>> generate_kwargs = {"max_new_tokens": 10, "do_sample": True, "temperature": 1.0, "num_return_sequences": 2}
>>> outputs = model.generate(**inputs, **generate_kwargs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Hugging Face Company is one of these companies that is going to take a',
"Hugging Face Company is a brand created by Brian A. O'Neil"]

>>> # However, with temperature close to 0, it approximates greedy decoding strategies (invariant)
>>> generate_kwargs["temperature"] = 0.0001
>>> outputs = model.generate(**inputs, **generate_kwargs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Hugging Face Company is a company that has been around for over 20 years',
'Hugging Face Company is a company that has been around for over 20 years']
```

#### __call__[[transformers.TemperatureLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.TopHLogitsWarper[[transformers.TopHLogitsWarper]]

```python
transformers.TopHLogitsWarper(top_h: float, filter_value: float = -inf)
```

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

**Parâmetros:**

top_h (`float`) : Coeficiente de escala para o limiar baseado em entropia (`tau`). Deve estar no intervalo `(0, 1]`.

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores filtrados serão definidos como este valor float.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que implementa a amostragem Top-H, um método de decodificação que seleciona adaptativamente um subconjunto de tokens de alta probabilidade com base em restrições de entropia e probabilidade cumulativa.

Este método determina dinamicamente quantos tokens devem ser mantidos, analisando a diferença de entropia da distribuição selecionada, equilibrando assim a exploração e a exploração. Isso garante que o texto gerado mantenha tanto a diversidade quanto a coerência.

Referência: Para mais detalhes, consulte *Top-H Decoding: Adapting the Creativity and Coherence with Bounded Entropy in Text Generation* (NeurIPS 2025): https://arxiv.org/abs/2509.02510

Exemplo:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> outputs = model.generate(**inputs, do_sample=True, top_h=0.4)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.TopHLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : IDs dos tokens de entrada.

scores (`torch.Tensor` de forma `(batch_size, vocab_size)`) : Logits brutos do modelo.

**Retorna:** `torch.Tensor` de forma `(batch_size, vocab_size)`

Logits processados em que tokens inválidos são mascarados com `-inf`.

Filtra os logits usando amostragem Top-H.

#### transformers.TopKLogitsWarper[[transformers.TopKLogitsWarper]]

```python
transformers.TopKLogitsWarper(top_k: int, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

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

**Parâmetros:**

top_k (`int`) : O número de tokens do vocabulário com maior probabilidade a serem mantidos para a filtragem top-k.

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores filtrados serão definidos como este valor float.

min_tokens_to_keep (`int`, *opcional*, padrão 1) : Número mínimo de tokens que não podem ser filtrados.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que executa top-k, ou seja, restringe-se aos k elementos de maior probabilidade. Frequentemente usado em conjunto com [TemperatureLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TemperatureLogitsWarper) e [TopPLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TopPLogitsWarper).

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: A, B, C, D", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: A, B, C, D, E — S — O, P — R

>>> # With `top_k` sampling, the output gets restricted the k most likely tokens.
>>> # Pro tip: In practice, LLMs use `top_k` in the 5-50 range.
>>> outputs = model.generate(**inputs, do_sample=True, top_k=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: A, B, C, D, E, F, G, H, I
```

#### __call__[[transformers.TopKLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.TopPLogitsWarper[[transformers.TopPLogitsWarper]]

```python
transformers.TopPLogitsWarper(top_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

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

**Parâmetros:**

top_p (`float`) : Se definido como < 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.

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores filtrados serão definidos como este valor float.

min_tokens_to_keep (`int`, *opcional*, padrão 1) : Número mínimo de tokens que não podem ser filtrados.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que executa top-p, ou seja, restringe aos tokens principais cuja soma é prob_cut_off <= prob_cut_off. Frequentemente usado em conjunto com [TemperatureLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TemperatureLogitsWarper) e [TopKLogitsWarper](/docs/transformers/main/pt/internal/generation_utils#transformers.TopKLogitsWarper).

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With `top_p` sampling, the output gets restricted to high-probability tokens.
>>> # Pro tip: In practice, LLMs use `top_p` in the 0.9-0.95 range.
>>> outputs = model.generate(**inputs, do_sample=True, top_p=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.TopPLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.TypicalLogitsWarper[[transformers.TypicalLogitsWarper]]

```python
transformers.TypicalLogitsWarper(mass: float = 0.9, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

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

**Parâmetros:**

mass (`float`, *opcional*, padrão 0.9) : Valor de typical_p entre 0 e 1, inclusive, padrão 0.9.

filter_value (`float`, *opcional*, padrão: -inf) : Todos os valores filtrados serão definidos como este valor float.

min_tokens_to_keep (`int`, *opcional*, padrão 1) : Número mínimo de tokens que não podem ser filtrados.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que executa a decodificação típica. Inspirado em como os humanos usam a linguagem, ele prioriza tokens cuja log probabilidade está próxima da entropia da distribuição de probabilidade dos tokens. Isso significa que os tokens mais prováveis podem ser descartados no processo.

Veja [Decodificação típica para geração de linguagem natural](https://huggingface.co/papers/2202.00666) para mais informações.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("1, 2, 3", return_tensors="pt")

>>> # We can see that greedy decoding produces a sequence of numbers
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

>>> # For this particular seed, we can see that sampling produces nearly the same low-information (= low entropy)
>>> # sequence
>>> set_seed(18)
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
1, 2, 3, 4, 5, 6, 7, 8, 9 and 10

>>> # With `typical_p` set, the most obvious sequence is no longer produced, which may be good for your problem
>>> set_seed(18)
>>> outputs = model.generate(
...     **inputs, do_sample=True, typical_p=0.1, return_dict_in_generate=True, output_scores=True
... )
>>> print(tokenizer.batch_decode(outputs.sequences, skip_special_tokens=True)[0])
1, 2, 3 and 5

>>> # We can see that the token corresponding to "4" (token 934) in the second position, the most likely token
>>> # as seen with greedy decoding, was entirely blocked out
>>> print(outputs.scores[1][0, 934])
tensor(-inf)
```

#### __call__[[transformers.TypicalLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor]]

```python
transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor(guidance_scale: float, model, unconditional_ids: typing.Optional[torch.LongTensor] = None, unconditional_attention_mask: typing.Optional[torch.LongTensor] = None, use_cache: bool = True)
```

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

**Parâmetros:**

guidance_scale (`float`) : A escala de orientação para a orientação livre de classificador (CFG). O CFG é ativado ao definir `guidance_scale != 1`. Uma escala de orientação maior incentiva o modelo a gerar amostras mais estreitamente ligadas ao prompt de entrada, geralmente em detrimento de uma qualidade inferior. Um valor menor que 1 tem o efeito oposto, fazendo com que o prompt negativo fornecido com negative_prompt_ids (se houver) atue como um prompt positivo.

model (`PreTrainedModel`): O modelo que calcula as pontuações incondicionais. Presume-se que seja o mesmo que calcula as pontuações condicionais. Ambos os modelos devem usar o mesmo tokenizer.

unconditional_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário para o ramo incondicional. Se não definido, usará por padrão o último token do prompt.

unconditional_attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara de atenção para unconditional_ids.

use_cache (`bool`, *opcional*, padrão `True`) : Se deve fazer cache das chaves/valores durante a passagem de propagação para frente do prompt negativo.

Processador de logits para Classifier-Free Guidance (CFG). O processador calcula uma média ponderada entre as pontuações dos logits condicionais ao prompt e dos logits incondicionais (ou negativos) ao prompt, parametrizada pelo `guidance_scale`. As pontuações incondicionais são calculadas internamente ao solicitar ao `model` o ramo `unconditional_ids`.

Veja [o artigo](https://huggingface.co/papers/2306.17806) para mais informações.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["Today, a dragon flew over Paris, France,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=1.5)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Today, a dragon flew over Paris, France, killing at least 50 people and injuring more than 100'

>>> # with a negative prompt
>>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=2, negative_prompt_ids=neg_inputs["input_ids"])
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Today, a dragon flew over Paris, France, killing at least 130 people. French media reported that'

>>> # with a positive prompt
>>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=0, negative_prompt_ids=neg_inputs["input_ids"])
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
"Today, a dragon flew over Paris, France, and I'm very happy to be here. I"
```

#### __call__[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor.__call__]]

```python
__call__(input_ids, scores)
```

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

#### transformers.WhisperTimeStampLogitsProcessor[[transformers.WhisperTimeStampLogitsProcessor]]

```python
transformers.WhisperTimeStampLogitsProcessor(generate_config: GenerationConfig, begin_index: int, _detect_timestamp_from_logprob: bool | None = None)
```

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

**Parâmetros:**

generate_config (`GenerateConfig`) : A configuração de geração usada para gerar a saída. Os seguintes parâmetros são obrigatórios: eos_token_id (`int`, *opcional*, padrão 50257): O id do token de *fim de sequência*. no_timestamps_token_id (`int`, *opcional*, padrão 50363): O id do token `"<|notimestamps|>"`. max_initial_timestamp_index (`int`, *opcional*, padrão 1): Usado para definir o valor máximo do timestamp inicial. Isso é usado para impedir que o modelo preveja timestamps muito distantes no futuro.

begin_index (`int`) : Índice do token do primeiro token gerado pelo modelo.

_detect_timestamp_from_logprob (`bool`, *opcional*) : Se os timestamps podem ser previstos a partir dos logprobs sobre todos os timestamps.

[LogitsProcessor](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessor) que modifica os logits para a geração de timestamps na transcrição. Quando os tokens de entrada atingem um limiar específico, o processador define as pontuações como infinito negativo. O processador garante que os tokens de timestamp apareçam em pares, mascarando os logits que quebrariam esse padrão de pareamento. Isso é feito para manter a consistência e a estrutura dos timestamps gerados. Ele também garante que, quando a probabilidade prevista de amostragem de qualquer token de timestamp for maior que a de qualquer token individual não-timestamp, os logits não-timestamp sejam definidos como infinito negativo. Isso é feito para garantir a geração de timestamps em vez de outros tokens potenciais.

Veja [o artigo](https://huggingface.co/papers/2212.04356) para mais informações.

Exemplos:
``` python
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration, GenerationConfig
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[3]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> #Displaying timestamps
>>> generated_ids = model.generate(inputs=input_features, return_timestamps=True)
>>> transcription = processor.batch_decode(generated_ids, decode_with_timestamps=True)[0]
>>> print("Transcription:", transcription)
Transcription: <|startoftranscript|><|0.00|> He has grave doubts whether Sir Frederick Layton's work is really Greek after all, and can<|6.44|><|6.44|> discover in it but little of rocky Ithaca.<|9.44|><|endoftext|>

>>> #No timestamps & change EOS:
>>> #This allows the user to select a specific token to terminate the sequence on, in this case it's the word "can"(460)
>>> model.generation_config.eos_token_id = 460
>>> generated_ids = model.generate(inputs=input_features,return_timestamps=False)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print("Transcription:", transcription)
Transcription:  He has grave doubts whether Sir Frederick Layton's work is really Greek after all and can
```

#### __call__[[transformers.WhisperTimeStampLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

#### transformers.WatermarkLogitsProcessor[[transformers.WatermarkLogitsProcessor]]

```python
transformers.WatermarkLogitsProcessor(vocab_size, device, greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1)
```

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

**Parâmetros:**

vocab_size (`int`) : O vocab_size do tokenizer do modelo. Usado para calcular a proporção de tokens "green".

device (`str`) : O dispositivo onde o modelo é alocado.

greenlist_ratio (`float`, opcional, *opcional*, padrão 0,25): A proporção de tokens "verdes" em relação ao tamanho do vocabulário. O valor padrão é 0,25.

bias (`float`, opcional, *opcional*, padrão 2.0) : O viés adicionado aos logits dos tokens "verdes" selecionados. Considere reduzir o `bias` se a qualidade da geração de texto degradar. Os valores recomendados estão na faixa de [0,5, 2,0]. Padrão: 2,0.

hashing_key (`int`, opcional, *opcional*, padrão 15485863) : Chave usada para hash. Se você implantar essa marca d'água, recomendamos o uso de outra chave privada. O padrão é 15485863 (o milionésimo número primo).

seeding_scheme (`str`, opcional, *optional*, padrão `"lefthash"`) : O esquema de semeadura usado para selecionar os tokens "green". Aceita os valores: - "lefthash" (padrão): a seleção dos tokens "green" depende do último token (Algoritmo 2 do artigo) - "selfhash": a seleção dos tokens "green" depende do próprio token atual (Algoritmo 3 do artigo) A desvantagem desse esquema é que ele considera todos os possíveis tokens seguintes e pode ser mais lento que "lefthash". O comprimento do contexto dos tokens anteriores a ser usado no semeadura. Um comprimento de contexto maior torna a marca d'água mais robusta.

context_width (`int`, *opcional*, padrão 1) : O número de tokens anteriores a serem usados ao definir a semente.

Processador de logits para marcação d'água em texto gerado. O processador modifica as pontuações de saída do modelo adicionando um pequeno viés a um conjunto aleatório de tokens "green" antes de gerar o próximo token. O processo de seleção dos tokens "green" depende do `seeding_scheme` utilizado. O código foi baseado no [repositório original](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

O texto gerado por este `LogitsProcessor` pode ser detectado usando `WatermarkDetector`. Consulte [__call__()](/docs/transformers/main/pt/internal/generation_utils#transformers.WatermarkDetector.__call__) para mais detalhes,

Veja [o artigo](https://huggingface.co/papers/2306.04634) para mais informações.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkingConfig

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["Alice and Bob are"], return_tensors="pt")

>>> # normal generation
>>> out = model.generate(inputs["input_ids"], max_length=20, do_sample=False)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Alice and Bob are both in the same room.\n\n"I\'m not sure if you\'re'

>>> # watermarked generation
>>> watermarking_config = WatermarkingConfig(bias=2.5, context_width=2, seeding_scheme="selfhash")
>>> out = model.generate(inputs["input_ids"], watermarking_config=watermarking_config, max_length=20, do_sample=False)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Alice and Bob are both still alive and well and the story is pretty much a one-hour adventure'

>>> # to detect watermarked text use the WatermarkDetector class
>>> from transformers import WatermarkDetector
>>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config= watermarking_config)
>>> detection_preds = detector(out)
>>> detection_preds
array([ True])
```

#### __call__[[transformers.WatermarkLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. [O que são IDs de entrada?](../glossary#input-ids)

scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem. Estas podem ser logits para cada vocabulário quando não se usa busca por feixe ou log softmax para cada token do vocabulário quando se usa busca por feixe

**Retorna:** `torch.Tensor` de forma `(batch_size, config.vocab_size)`

As pontuações de previsão processadas.

## StoppingCriteria[[transformers.StoppingCriteria]]

Uma [StoppingCriteria](/docs/transformers/main/pt/internal/generation_utils#transformers.StoppingCriteria) pode ser usada para alterar quando interromper a geração (além do token EOS). Observe que isso está disponível exclusivamente para nossas implementações em PyTorch.

#### transformers.StoppingCriteria[[transformers.StoppingCriteria]]

```python
transformers.StoppingCriteria()
```

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

Classe base abstrata para todos os critérios de parada que podem ser aplicados durante a geração.

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

#### __call__[[transformers.StoppingCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem, como uma tupla com um tensor por etapa de geração, cada um com a forma `(batch_size, config.vocab_size)`. Essas podem ser pontuações para cada token do vocabulário antes do SoftMax ou pontuações para cada token do vocabulário após o SoftMax. Se esse critério de parada depender da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`, caso contrário, `None` será passado.

kwargs (`dict[str, Any]`, *opcional*) : kwargs específicos de critérios adicionais de parada.

**Retorna:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`)

`True` indica que devemos interromper a geração para uma linha específica. `False` indica que devemos continuar.

#### transformers.StoppingCriteriaList[[transformers.StoppingCriteriaList]]

```python
transformers.StoppingCriteriaList(iterable = ())
```

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

#### __call__[[transformers.StoppingCriteriaList.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem, como uma tupla com um tensor por etapa de geração, cada um com a forma `(batch_size, config.vocab_size)`. Essas podem ser pontuações para cada token do vocabulário antes do SoftMax ou pontuações para cada token do vocabulário após o SoftMax. Se esse critério de parada depende da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`, caso contrário, `None` é passado.

kwargs (`dict[str, Any]`, *opcional*) : kwargs específicos de critérios adicionais de parada.

**Retorna:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`)

`True` indica que devemos interromper a geração para uma linha específica. `False` indica que devemos continuar.

#### transformers.MaxLengthCriteria[[transformers.MaxLengthCriteria]]

```python
transformers.MaxLengthCriteria(max_length: int, max_position_embeddings: int | None = None)
```

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

**Parâmetros:**

max_length (`int`) : O comprimento máximo que a sequência de saída pode ter em número de tokens.

max_position_embeddings (`int`, *opcional*) : O comprimento máximo do modelo, conforme definido pelo atributo `config.max_position_embeddings` do modelo.

Esta classe pode ser usada para interromper a geração sempre que o número total de tokens gerados exceder `max_length`. Lembre-se de que, para transformers do tipo apenas decodificador, isso incluirá os tokens iniciais do prompt.

#### __call__[[transformers.MaxLengthCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem, como uma tupla com um tensor por etapa de geração, cada um com a forma `(batch_size, config.vocab_size)`. Essas podem ser pontuações para cada token do vocabulário antes do SoftMax ou pontuações para cada token do vocabulário após o SoftMax. Se esse critério de parada depender da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`, caso contrário, `None` será passado.

kwargs (`dict[str, Any]`, *opcional*) : kwargs específicos de critérios adicionais de parada.

**Retorna:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`)

`True` indica que devemos interromper a geração para uma linha específica. `False` indica que devemos continuar.

#### transformers.MaxTimeCriteria[[transformers.MaxTimeCriteria]]

```python
transformers.MaxTimeCriteria(max_time: float, initial_timestamp: float | None = None)
```

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

**Parâmetros:**

max_time (`float`) : O tempo máximo permitido, em segundos, para a geração.

initial_timestamp (`float`, *opcional*, padrão `time.time()`) : O início do tempo permitido para a geração.

Esta classe pode ser usada para interromper a geração sempre que a geração completa exceder um determinado tempo. Por padrão, a contagem do tempo começa quando você inicializa esta função. Você pode sobrescrever esse comportamento passando um `initial_timestamp`.

#### __call__[[transformers.MaxTimeCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem, como uma tupla com um tensor por etapa de geração, cada um com a forma `(batch_size, config.vocab_size)`. Essas podem ser pontuações para cada token do vocabulário antes do SoftMax ou pontuações para cada token do vocabulário após o SoftMax. Se esse critério de parada depender da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`, caso contrário, `None` será passado.

kwargs (`dict[str, Any]`, *opcional*) : kwargs específicos de critérios adicionais de parada.

**Retorna:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`)

`True` indica que devemos interromper a geração para uma linha específica. `False` indica que devemos continuar.

#### transformers.StopStringCriteria[[transformers.StopStringCriteria]]

```python
transformers.StopStringCriteria(tokenizer: PreTrainedTokenizerBase, stop_strings: str | list[str])
```

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

**Parâmetros:**

tokenizer (`PreTrainedTokenizer`) : O tokenizer associado ao modelo (necessário para extrair o vocabulário e tokenizar as sequências de término)

stop_strings (`Union[str, list[str]]`) : Uma lista de strings que devem encerrar a geração. Se uma string for passada, ela será tratada como uma lista com um único elemento.

Esta classe pode ser usada para interromper a geração sempre que sequências de strings específicas forem geradas. Ela pré-processa as strings junto com o vocabulário do tokenizer para encontrar as posições em que os tokens podem completar validamente as strings de parada.

A geração é interrompida assim que um token é gerado que completa qualquer uma das strings de parada. Queremos capturar qualquer instância em que a string de parada esteja presente na saída decodificada, o que significa que também devemos capturar casos com "sobras" em uma ou ambas as extremidades. Para tornar isso mais concreto, para a string de parada "stop", qualquer uma das seguintes sequências de tokens acionaria a correspondência:

- ["st", "op"]
- ["stop"]
- ["st", "opera"]
- ["sto", "pper"]
- ["las", "topper"]
- ["s", "para", "pped"]

Observe que uma correspondência só será acionada se a string de parada estiver no final da sequência gerada. Em outras palavras, essas sequências não acionarão uma correspondência:

- ["stop", "at"]
- ["st", "op", "at"]
- ["st", "opera", "ção"]

A razão pela qual esses não correspondem é que a string de parada não se sobrepõe ao token final. Se você puder remover um ou mais tokens do final da sequência sem destruir a string de parada, então esse critério não corresponderá a essa string de parada. Isso é por design; como essa verificação é executada após cada token ser gerado, não podemos perder uma string de parada válida se uma for gerada, mas não queremos interromper a geração apenas porque a string de parada existe em algum lugar nos input_ids de entrada anteriores.

Mas, afinal, como a correspondência é realizada? Fazemos isso de uma forma bastante confusa, pois queremos que todo o processo de correspondência seja compilável com Torch ou XLA, o que significa que não podemos usar métodos de string padrão. No entanto, é possível, com algum trabalho, realizar a correspondência de strings com operações puras de tensor. Começaremos descrevendo o algoritmo que usamos com operações de string padrão e, ao final, explicaremos como isso é convertido em operações puras de tensor.

A chave do algoritmo é uma observação: como a string de parada deve se sobrepor ao final da sequência de tokens, podemos começar pelo final da sequência e trabalhar para trás. Especificamente, verificamos se há uma sobreposição entre o início do token final e o final da stop_string, ou, dito de outra forma, se stop_string[-i:] == token[:i] para algum i > 0. Se você olhar para os exemplos positivos acima, verá que o último token em todos eles satisfaz essa propriedade:

- ["st", "op"] (a sobreposição é "op", comprimento da sobreposição == 2)
- ["stop"]  (a sobreposição é "stop", comprimento da sobreposição == 4)
- ["st", "opera"] (a sobreposição é "op", comprimento da sobreposição == 2)
- ["sto", "pper"] (a sobreposição é "p", comprimento da sobreposição == 1)
- ["las", "topper"] (a sobreposição é "top", comprimento da sobreposição == 3)
- ["s", "to", "pped"] (a sobreposição é "p", comprimento da sobreposição == 1)

É impossível construir uma sequência correspondente que não possua essa propriedade (sinta-se à vontade para verificar isso por conta própria). No entanto, embora essa sobreposição entre o início do token final e o fim da string de parada seja necessária para uma correspondência, ela não é suficiente. Também precisamos verificar se o restante da sequência de tokens é consistente com a string de parada.

Como fazemos isso? Vamos usar ["s", "to", "pped"] como exemplo. Sabemos que o token final, "pped", tem uma sobreposição de 1 com a string de parada, "stop". Em seguida, voltamos ao token anterior, "to". Como já correspondemos 1 caractere da string de parada, o restante a ser verificado é "sto". Verificamos que o próximo token "to" corresponde ao final do restante, o que é verdade. Agora correspondemos 3 caracteres da string de parada, e o restante a ser correspondido é "s". Voltamos novamente ao token anterior, que também é "s". Esta é uma correspondência, e assim correspondemos a string de parada inteira.

Mas como funciona quando os tokens ultrapassam o início da string de parada? Vamos considerar o exemplo ["las", "topper"]. O token final, "topper", tem uma sobreposição de 3 com a string de parada, "stop". Portanto, a parte restante da string de parada a ser correspondida é "s". Voltamos ao token anterior, "las". Como o restante a ser correspondido é apenas "s", com comprimento 1, consideramos apenas o último caractere do token, que é "s". Isso corresponde à string de parada, e assim a string inteira é correspondida.

Como calculamos essas correspondências com operações de tensor? Simplesmente: precomputamos de forma eficiente as informações necessárias para todos os tokens! Para cada token, calculamos:
- Sua sobreposição com o final da string de parada, se houver
- As posições dentro da string de parada onde o token corresponde, incluindo correspondências que se estendem além do início.
- O comprimento total do token

Por exemplo, para o token "pped", calcularíamos um sobreposição final de 1, nenhuma posição de correspondência interna e um comprimento de 4. Para o token "to", calcularíamos nenhuma sobreposição final, uma única posição de correspondência interna de 1 (contando a partir do final) e um comprimento de 2. Para o token "s", calcularíamos nenhuma sobreposição final, uma única posição de correspondência interna de 3 (novamente contando a partir do final) e um comprimento de 1.

Desde que tenhamos essas informações, podemos executar o algoritmo acima sem nenhuma operação de comparação de strings. Basta executar as seguintes etapas:
- Verifique se o token final tem uma sobreposição de fim com a string de início
- Continue para trás, mantendo o registro de quanto da string de parada já foi correspondido até o momento
- Em cada ponto, verifique se o próximo token tem a posição atual como uma de suas posições válidas
- Continue até que uma correspondência falhe ou até que a string de parada inteira seja completamente correspondida

Novamente, considere ["s", "to", "pped"] como exemplo. "pped" tem uma sobreposição final de 1, então podemos iniciar uma correspondência. Já correspondemos 1 caractere até agora, então verificamos se o próximo token, "to", tem 1 como uma posição válida (novamente, contando a partir do final). Ele tem, então adicionamos o comprimento de "to" ao nosso rastreador de posição. Agora correspondemos 3 caracteres, então verificamos se o próximo token, "s", tem 3 como uma posição válida. Ele tem, então adicionamos seu comprimento ao rastreador de posição. O rastreador de posição agora é 4, que é o comprimento da string de parada. Correspondemos a string de parada inteira.

No segundo caso, ["las", "topper"], "topper" tem uma sobreposição final de 3, então podemos iniciar uma correspondência. Já correspondemos 3 caracteres até agora, então verificamos se o próximo token "las" tem 3 como uma posição válida. Ele tem, porque permitimos que os tokens correspondam a posições que excedem o início da string de parada. Adicionamos seu comprimento ao rastreador de posição. O rastreador de posição agora é 6, que é maior que o comprimento da string de parada! Não entre em pânico, porém - isso também conta como uma correspondência da string de parada. Correspondemos a string de parada inteira.

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2")
>>> inputs = tokenizer("The biggest states in the USA by land area:", return_tensors="pt")

>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
The biggest states in the USA by land area:
- Alaska
- Texas
- California

>>> # Passing one or more stop strings will halt generation after those strings are emitted
>>> # Note that generating with stop strings requires you to pass the tokenizer too
>>> gen_out = model.generate(**inputs, stop_strings=["Texas"], tokenizer=tokenizer)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
The biggest states in the USA by land area:
- Alaska
- Texas
```

#### __call__[[transformers.StopStringCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem, como uma tupla com um tensor por etapa de geração, cada um com a forma `(batch_size, config.vocab_size)`. Essas podem ser pontuações para cada token do vocabulário antes do SoftMax ou pontuações para cada token do vocabulário após o SoftMax. Se esse critério de parada depender da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`, caso contrário `None` será passado.

kwargs (`dict[str, Any]`, *opcional*) : kwargs específicos de critérios adicionais de parada.

**Retorna:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`)

`True` indica que devemos interromper a geração para uma linha específica. `False` indica que devemos continuar.

#### transformers.EosTokenCriteria[[transformers.EosTokenCriteria]]

```python
transformers.EosTokenCriteria(eos_token_id: typing.Union[int, list[int], torch.Tensor])
```

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

**Parâmetros:**

eos_token_id (`Union[int, list[int], torch.Tensor]`) : O(s) id(s) do token *end-of-sequence*.

Esta classe pode ser usada para interromper a geração sempre que o token de "fim de sequência" for gerado. Por padrão, ela usa o `model.generation_config.eos_token_id`.

#### __call__[[transformers.EosTokenCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, new_token_length: int = 1, **kwargs)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Pontuações de previsão de uma cabeça de modelagem de linguagem, como uma tupla com um tensor por etapa de geração, cada um com a forma `(batch_size, config.vocab_size)`. Essas podem ser pontuações para cada token do vocabulário antes do SoftMax ou pontuações para cada token do vocabulário após o SoftMax. Se esse critério de parada depender da entrada `scores`, certifique-se de passar `return_dict_in_generate=True, output_scores=True` para `generate`, caso contrário, `None` será passado.

new_token_length (`int`, *opcional*, padrão `1`) : O número de tokens que serão verificados em relação aos critérios. Os `new_token_length` tokens mais recentes de cada item do lote serão verificados.

kwargs (`dict[str, Any]`, *opcional*) : kwargs específicos de critérios adicionais de parada.

**Retorna:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`)

`True` indica que devemos interromper a geração para uma linha específica. `False` indica que devemos continuar.

## Streamers[[transformers.TextStreamer]]

#### transformers.TextStreamer[[transformers.TextStreamer]]

```python
transformers.TextStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, **decode_kwargs: Any)
```

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

**Parâmetros:**

tokenizer (`AutoTokenizer`) : O tokenizer usado para decodificar os tokens.

skip_prompt (`bool`, *opcional*, padrão `False`) : Se deve ou não ignorar o prompt para `.generate()`. Útil, por exemplo, para chatbots.

decode_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave adicionais para passar ao método `decode` do tokenizer.

Streamer de texto simples que imprime o(s) token(s) no stdout assim que palavras inteiras são formadas.

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextStreamer(tok)

>>> # Despite returning the usual output, the streamer will also print the generated text to stdout.
>>> _ = model.generate(**inputs, streamer=streamer, max_new_tokens=20)
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,
```

#### fim[[transformers.TextStreamer.end]]

```python
end()
```

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

Limpa o cache restante e imprime uma nova linha no stdout.

#### on_finalized_text[[transformers.TextStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

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

Imprime o novo texto no stdout. Se o stream estiver terminando, também imprime uma quebra de linha.

#### put[[transformers.TextStreamer.put]]

```python
put(value)
```

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

Recebe tokens, decodifica-os e os imprime no stdout assim que formam palavras inteiras.

#### transformers.TextIteratorStreamer[[transformers.TextIteratorStreamer]]

```python
transformers.TextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any)
```

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

**Parâmetros:**

tokenizer (`AutoTokenizer`) : O tokenizer usado para decodificar os tokens.

skip_prompt (`bool`, *opcional*, padrão `False`) : Se deve ou não ignorar o prompt para `.generate()`. Útil, por exemplo, para chatbots.

timeout (`float`, *opcional*) : O tempo limite para a fila de texto. Se `None`, a fila bloqueará indefinidamente. Útil para lidar com exceções em `.generate()`, quando chamado em uma thread separada.

decode_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave adicionais para passar ao método `decode` do tokenizer.

Streamer que armazena texto pronto para impressão em uma fila, para ser usado por um aplicativo a jusante como um iterador. Isso é útil para aplicativos que se beneficiam do acesso ao texto gerado de forma não bloqueante (por exemplo, em um demonstração interativa do Gradio).

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
>>> from threading import Thread

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextIteratorStreamer(tok)

>>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
>>> generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20)
>>> thread = Thread(target=model.generate, kwargs=generation_kwargs)
>>> thread.start()
>>> generated_text = ""
>>> for new_text in streamer:
...     generated_text += new_text
>>> generated_text
'An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,'
```

#### on_finalized_text[[transformers.TextIteratorStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

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

Coloque o novo texto na fila. Se o stream estiver terminando, coloque também um sinal de parada na fila.

#### transformers.AsyncTextIteratorStreamer[[transformers.AsyncTextIteratorStreamer]]

```python
transformers.AsyncTextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any)
```

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

**Parâmetros:**

tokenizer (`AutoTokenizer`) : O tokenizer usado para decodificar os tokens.

skip_prompt (`bool`, *opcional*, padrão `False`) : Se deve ou não ignorar o prompt para `.generate()`. Útil, por exemplo, para chatbots.

timeout (`float`, *opcional*) : O tempo limite para a fila de texto. Se `None`, a fila bloqueará indefinidamente. Útil para lidar com exceções em `.generate()`, quando chamado em uma thread separada.

decode_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave adicionais para passar ao método `decode` do tokenizer.

**Exceções:** ``TimeoutError``

- ``TimeoutError`` -- Se o tempo de geração de tokens exceder o valor de timeout.

Streamer que armazena texto pronto para impressão em uma fila, para ser usado por um aplicativo downstream como um iterador assíncrono. Isso é útil para aplicativos que se beneficiam do acesso ao texto gerado de forma assíncrona (por exemplo, em um demo interativo do Gradio).

Exemplos:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, AsyncTextIteratorStreamer
>>> from threading import Thread
>>> import asyncio

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")

>>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
>>> async def main():
...     # Important: AsyncTextIteratorStreamer must be initialized inside a coroutine!
...     streamer = AsyncTextIteratorStreamer(tok)
...     generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20)
...     thread = Thread(target=model.generate, kwargs=generation_kwargs)
...     thread.start()
...     generated_text = ""
...     async for new_text in streamer:
...         generated_text += new_text
>>>     print(generated_text)
>>> asyncio.run(main())
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,
```

#### on_finalized_text[[transformers.AsyncTextIteratorStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

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

Coloque o novo texto na fila. Se o stream estiver terminando, coloque também um sinal de parada na fila.

#### transformers.TextDiffusionStreamer[[transformers.TextDiffusionStreamer]]

```python
transformers.TextDiffusionStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, sleep_time: float | None = None, **decode_kwargs: Any)
```

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

**Parâmetros:**

tokenizer (`AutoTokenizer`) : O tokenizado usado para decodificar os tokens.

skip_prompt (`bool`, *opcional*, padrão `False`) : Se deve ou não ignorar o prompt para `.generate()`. Útil, por exemplo, para chatbots.

sleep_time (`float`, *opcional*) : Tempo de espera entre os rascunhos de difusão, o que pode ser útil para visualizar as saídas intermediárias.

decode_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave adicionais para passar ao método `decode` do tokenizer.

Streamer que imprime as saídas de difusão de texto. As etapas intermediárias de difusão (rascunhos) são temporárias e substituídas por rascunhos subsequentes, sendo removidas quando o texto confirmado é impresso.

Se você estiver executando em um ambiente como tmux, o texto de rascunho pode não conseguir sobrescrever a si mesmo.

Exemplos:

```python
>>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(
...     "google/diffusiongemma-26B-A4B-it", device_map="auto",
... )
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

>>> chat = [{"role": "user", "content": "Why is the sky blue?"},]
>>> input_ids = processor.apply_chat_template(
...     chat, tokenize=True, return_tensors="pt", add_generation_prompt=True
... )
>>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
>>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer)
```

#### fim[[transformers.TextDiffusionStreamer.end]]

```python
end()
```

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

Limpa o cache restante e imprime uma nova linha.

#### put[[transformers.TextDiffusionStreamer.put]]

```python
put(value)
```

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

Recebe os tokens confirmados, limpa o rascunho e os imprime permanentemente.

#### put_draft[[transformers.TextDiffusionStreamer.put_draft]]

```python
put_draft(value, **kwargs)
```

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

Recebe a sequência completa de tokens de rascunho, os decodifica e os exibe em amarelo. Sobrescreve o rascunho anterior.

## Caches[[transformers.CacheLayerMixin]]

#### transformers.CacheLayerMixin[[transformers.CacheLayerMixin]]

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

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

Base, classe abstrata para o cache de uma única camada.

#### atualizar[[transformers.CacheLayerMixin.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L52)

#### get_seq_length[[transformers.CacheLayerMixin.get_seq_length]]

```python
get_seq_length()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L60)

#### get_mask_sizes[[transformers.CacheLayerMixin.get_mask_sizes]]

```python
get_mask_sizes(query_length: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L57)

#### get_max_length[[transformers.CacheLayerMixin.get_max_length]]

```python
get_max_length()
```

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

Retorna o comprimento máximo de sequência que a camada pode armazenar. Um valor de `-1` significa que não há limite máximo, ou que o limite máximo é indefinido, por exemplo, uma camada de atenção dinâmica que cresce indefinidamente ou uma camada de atenção linear que não possui dimensão de comprimento de sequência.

#### reset[[transformers.CacheLayerMixin.reset]]

```python
reset()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L84)

Redefine os valores do cache preservando os objetos

#### reorder_cache[[transformers.CacheLayerMixin.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L97)

Reordena o cache desta camada para a busca por feixe (beam search).

#### lazy_initialization[[transformers.CacheLayerMixin.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L49)

#### transformers.DynamicLayer[[transformers.DynamicLayer]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L104)

Uma camada de cache que cresce dinamicamente à medida que mais tokens são gerados. Este é o padrão para modelos generativos. Ela armazena os estados de chave e valor como tensores de forma `[batch_size, num_heads, seq_len, head_dim]`.

#### atualizar[[transformers.DynamicLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L119)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

**Retorna:** tuple[`torch.Tensor`, `torch.Tensor`]

Os estados de chave e valor.

Atualize os caches de chave e valor in-place e retorne os estados de chaves e valores necessários.

#### lazy_initialization[[transformers.DynamicLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

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

#### crop[[transformers.DynamicLayer.crop]]

```python
crop(tokens_to_remove: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L164)

Remove `tokens_to_remove` tokens da camada de cache atual.

#### batch_repeat_interleave[[transformers.DynamicLayer.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L183)

Repita o cache `repeats` vezes na dimensão do lote.

#### batch_select_indices[[transformers.DynamicLayer.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L189)

Mantenha apenas os `indices` na dimensão do lote do cache.

#### transformers.StaticLayer[[transformers.StaticLayer]]

```python
transformers.StaticLayer(max_cache_len: int, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L403)

**Parâmetros:**

max_cache_len (`int`) : Número máximo de tokens que podem ser armazenados, usado para a pré-alocação de tensores.

Uma camada de cache estática que armazena os estados de chave e valor como tensores estáticos de forma `[batch_size, num_heads, max_cache_len, head_dim]`. Ela aloca preguiçosamente seus tensores de suporte completos e, em seguida, os modifica no local. Projetada para suporte a `torch.compile`.

#### atualizar[[transformers.StaticLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L461)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

**Retorna:** tuple[`torch.Tensor`, `torch.Tensor`]

Os estados de chave e valor.

Atualize os caches de chave e valor in-place e retorne os estados de chaves e valores necessários.

#### lazy_initialization[[transformers.StaticLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423)

Inicialização preguiçosa dos tensores de chaves e valores. Isso permite obter todas as propriedades (dtype, device, num_heads no caso de TP, etc.) em tempo de execução diretamente, o que é extremamente prático, pois evita mover devices, dtypes, etc. posteriormente para cada `update` (o que também poderia quebrar os endereços estáticos do dynamo).

Se isso não for desejado, é possível chamar `early_initialization(...)` diretamente no Cache, o que invocará esta função antecipadamente (isso é necessário, por exemplo, para `torch.export`). Também é obrigatório sempre que o próprio prefill terminar em uma região compilada (por exemplo, com prefill em blocos).

#### transformers.StaticSlidingWindowLayer[[transformers.StaticSlidingWindowLayer]]

```python
transformers.StaticSlidingWindowLayer(max_cache_len: int, sliding_window: int, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L510)

**Parâmetros:**

max_cache_len (`int`) : Número máximo de tokens que podem ser armazenados, usado para a pré-alocação de tensores.

sliding_window (`int`) : O tamanho da janela deslizante.

Uma camada de cache estática que armazena os estados de chave e valor como tensores estáticos de forma `[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]`. Ela aloca preguiçosamente seus tensores de suporte completos e, em seguida, os modifica no local. Projetada para suporte a `torch.compile`.

#### atualizar[[transformers.StaticSlidingWindowLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L531)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

**Retorna:** tuple[`torch.Tensor`, `torch.Tensor`]

Os estados de chave e valor.

Atualize os caches de chave e valor in-place e retorne os estados de chaves e valores necessários.

#### lazy_initialization[[transformers.StaticSlidingWindowLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423)

Inicialização preguiçosa dos tensores de chaves e valores. Isso permite obter todas as propriedades (dtype, device, num_heads no caso de TP, etc.) em tempo de execução diretamente, o que é extremamente prático, pois evita mover devices, dtypes, etc. posteriormente para cada `update` (o que também poderia quebrar os endereços estáticos do dynamo).

Se isso não for desejado, é possível chamar `early_initialization(...)` diretamente no Cache, o que invocará esta função antecipadamente (isso é necessário, por exemplo, para `torch.export`). Também é obrigatório sempre que o próprio prefill terminar em uma região compilada (por exemplo, com prefill em blocos).

#### transformers.QuantoQuantizedLayer[[transformers.QuantoQuantizedLayer]]

```python
transformers.QuantoQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L854)

#### atualizar[[transformers.QuantoQuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

**Retorna:** tuple[`torch.Tensor`, `torch.Tensor`]

Os estados de chave e valor.

Atualize os caches de chave e valor in-place e retorne os estados de chaves e valores necessários.

#### lazy_initialization[[transformers.QuantoQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

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

#### transformers.HQQQuantizedLayer[[transformers.HQQQuantizedLayer]]

```python
transformers.HQQQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L909)

#### atualizar[[transformers.HQQQuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

**Retorna:** tuple[`torch.Tensor`, `torch.Tensor`]

Os estados de chave e valor.

Atualize os caches de chave e valor in-place e retorne os estados de chaves e valores necessários.

#### lazy_initialization[[transformers.HQQQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

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

#### transformers.Fp8QuantizedLayer[[transformers.Fp8QuantizedLayer]]

```python
transformers.Fp8QuantizedLayer()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L966)

Uma camada quantizada que armazena os estados de chave e valor em ponto flutuante de 8 bits. A escala por tensor é congelada após o primeiro `update`, de modo que novos estados são adicionados como estão: sem cache residual e sem requantização.

Uma variante de granularidade mais fina pertence aqui, em vez de sob `QuantizedLayer`, pois o agrupamento ao longo da dimensão de cabeças mantém os estados acopláveis e apenas converte a escala armazenada em um tensor.

#### atualizar[[transformers.Fp8QuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L994)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

**Retorna:** tuple[`torch.Tensor`, `torch.Tensor`]

Os estados de chave e valor.

Atualize os caches de chave e valor in-place e retorne os estados de chaves e valores necessários.

#### lazy_initialization[[transformers.Fp8QuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L978)

#### transformers.Cache[[transformers.Cache]]

```python
transformers.Cache(layers: list[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin | transformers.cache_utils.DummyLayer] | None = None, layer_class_to_replicate: type[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin] | None = None, offloading: bool = False, offload_only_non_sliding: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1453)

**Parâmetros:**

layers (`Optional`, *opcional*) : Uma lista de `CacheLayerMixin` ou `LinearAttentionCacheLayerMixin` pré-criados. Se omitida (`None`), `layer_class_to_replicate` será usado.

layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`, *opcional*) : Usado apenas quando `layers` é omitido (`None`), caso em que será usado como a classe base para cada camada, e as camadas serão adicionadas de forma preguiçosa assim que `update` for chamado com um `layer_idx` maior que a lista atual de camadas.

offloading (`bool`, *opcional*, padrão `False`) : Se deve realizar o offloading das camadas para `cpu`, para economizar memória de GPU.

offload_only_non_sliding (`bool`, *opcional*, padrão `True`) : Se `offloading` for `True`, este parâmetro determina se apenas as camadas não deslizantes serão offloadadas (pois, em geral, as camadas deslizantes são pequenas em tamanho, não havendo necessidade de offloadá-las, e ignorá-las é mais rápido).

Uma `Cache` é, em grande parte, uma lista de objetos `CacheLayerMixin`, um para cada camada do modelo. Ela atua como um contêiner para a Cache de cada camada.

#### atualizar[[transformers.Cache.update]]

```python
update(key_states: Tensor, value_states: Tensor, layer_idx: int, *args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1540)

**Parâmetros:**

key_states (`torch.Tensor`) : Os novos estados de chave para cache.

value_states (`torch.Tensor`) : Os novos valores de estado a serem armazenados em cache.

layer_idx (`int`) : O índice da camada para a qual os estados devem ser armazenados em cache.

**Retorna:**

Uma tupla contendo os estados atualizados de chave e valor.

Atualiza o cache com os novos `key_states` e `value_states` para a camada `layer_idx`.

#### early_initialization[[transformers.Cache.early_initialization]]

```python
early_initialization(batch_size: int, num_heads: int | list[int], head_dim: int | list[int], dtype: dtype, device: device)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1669)

Inicialize todas as camadas com antecedência (caso contrário, elas são inicializadas de forma preguiçosa na primeira chamada de `update`). Isso é útil para nossas receitas de `export`, pois `export` precisa de tudo com antecedência.

#### get_seq_length[[transformers.Cache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1706)

Retorna o comprimento da sequência do cache para a camada especificada.

#### get_mask_sizes[[transformers.Cache.get_mask_sizes]]

```python
get_mask_sizes(query_length: int, layer_idx: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1776)

Retorna uma tupla (kv_length, kv_offset) correspondente ao comprimento e ao deslocamento que serão retornados para a camada especificada em `layer_idx`. As máscaras são então preparadas de acordo com os comprimentos (kv_length, kv_offset) e os padrões de cada camada.

#### get_max_length[[transformers.Cache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1730)

Retorna o comprimento máximo do cache. Se `layer_idx` não for fornecido (padrão), isso retorna o máximo entre todas as camadas. Caso contrário, retorna o valor máximo suportado para a camada especificada. Um valor de `-1` significa sem máximo, ou máximo indefinido, por exemplo, para camadas de atenção dinâmica que podem crescer indefinidamente, ou camadas de atenção linear que não possuem uma dimensão de comprimento de sequência.

#### reset[[transformers.Cache.reset]]

```python
reset()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1813)

Redefinir recursivamente os tensores de todas as camadas

#### reorder_cache[[transformers.Cache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1818)

Reordenar o cache para a busca por feixe

#### crop[[transformers.Cache.crop]]

```python
crop(tokens_to_remove: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1823)

Remove `tokens_to_remove` tokens do Cache atual. Para camadas que não precisam manter todos os estados passados em memória, como camadas de janela deslizante ou camadas de atenção linear, isso também restringe o tamanho dos estados em cache de volta ao seu tamanho mínimo de trabalho. Isso significa que `crop(0)` não será necessariamente sempre uma operação sem efeito, pois ainda pode remover estados inúteis (ou seja, estados que não são necessários para o próximo `forward`) do Cache.

#### batch_repeat_interleave[[transformers.Cache.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1833)

Repetir e intercalar o cache

#### batch_select_indices[[transformers.Cache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1838)

Selecione índices do cache

#### transformers.DynamicCache[[transformers.DynamicCache]]

```python
transformers.DynamicCache(ddp_cache_data: collections.abc.Iterable[tuple[typing.Optional[torch.Tensor], ...]] | None = None, config: transformers.configuration_utils.PreTrainedConfig | None = None, offloading: bool = False, offload_only_non_sliding: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1960)

**Parâmetros:**

ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`, *opcional*) : Foi adicionado originalmente para compatibilidade com `torch.distributed` (DDP). Em resumo, é `map(gather_map, zip(*caches))`, ou seja, cada item no iterável contém os estados de chave e valor para uma camada, agregados entre réplicas pelo torch.distributed (shape=[global batch size, num_heads, seq_len, head_dim]). Observação: ele precisa ser o 1º argumento também para funcionar corretamente

config (`PreTrainedConfig`, *opcional*) : A config do modelo para o qual este Cache será usado. Se for passada, será utilizada para verificar a estrutura de camadas deslizantes ou híbridas, reduzindo significativamente a exigência de memória dos tensors em cache para `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

offloading (`bool`, *opcional*, padrão `False`) : Se deve realizar o offloading das camadas para `cpu`, para economizar memória de GPU.

offload_only_non_sliding (`bool`, *opcional*, padrão `False`) : Se `offloading` for `True`, este parâmetro determina se apenas as camadas não deslizantes serão descarregadas (pois, em geral, as camadas deslizantes têm tamanho pequeno, não há necessidade de descarregá-las e ignorá-las é mais rápido).

Um cache que cresce dinamicamente à medida que mais tokens são gerados. Este é o padrão para modelos generativos. Ele armazena os estados de chave e valor como uma lista de `CacheLayer`, um para cada camada. A forma esperada para cada tensor nos `CacheLayer`s é `[batch_size, num_heads, seq_len, head_dim]`. Se uma configuração for passada, ele verificará adicionalmente por uma estrutura de cache deslizante ou híbrida, reduzindo significativamente o requisito de memória dos tensores em cache para `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

Veja `Cache` para obter detalhes sobre os métodos comuns implementados por todas as classes de cache.

Exemplo:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, DynamicCache

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")

>>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> past_key_values = DynamicCache(config=model.config)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
```

#### transformers.StaticCache[[transformers.StaticCache]]

```python
transformers.StaticCache(config: PreTrainedConfig, max_cache_len: int, offloading: bool = False, offload_only_non_sliding: bool = True, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2056)

**Parâmetros:**

config (`PreTrainedConfig`) : A configuração do modelo para o qual esta Cache será usada. Será utilizada para verificar a estrutura de camadas deslizantes ou híbridas e inicializar cada camada de acordo.

max_cache_len (`int`) : O número máximo de tokens que este Cache deve reter.

offloading (`bool`, *opcional*, padrão `False`) : Se deve realizar o offloading das camadas para `cpu`, para economizar memória de GPU.

offload_only_non_sliding (`bool`, *opcional*, padrão `True`) : Se `offloading` for `True`, este parâmetro determina se apenas as camadas não deslizantes serão offloadadas (pois, em geral, as camadas deslizantes são pequenas em tamanho, não havendo necessidade de offloadá-las, e ignorá-las é mais rápido).

Classe de cache estática para ser usada com `torch.compile(model)` e `torch.export()`. Ela verifica a `config` em busca de uma possível estrutura de cache híbrida e inicializa cada camada de acordo.

Veja `Cache` para obter detalhes sobre os métodos comuns implementados por todas as classes de cache.

Exemplo:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, StaticCache

>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf")

>>> inputs = tokenizer(text="My name is Llama", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate
>>> max_generated_length = inputs.input_ids.shape[1] + 10
>>> past_key_values = StaticCache(config=model.config, max_cache_len=max_generated_length)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
StaticCache()
```

#### transformers.QuantizedCache[[transformers.QuantizedCache]]

```python
transformers.QuantizedCache(backend: str, config: PreTrainedConfig, nbits: int | None = None, axis_key: int | None = None, axis_value: int | None = None, q_group_size: int | None = None, residual_length: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2113)

**Parâmetros:**

backend (`str`) : O backend de quantização a ser usado. Um dos `("quanto", "hqq", "fp8")`.

config (`PreTrainedConfig`) : A configuração do modelo para o qual este Cache será usado.

nbits (`int`, *opcional*, padrão 4) : O número de bits para quantização.

axis_key (`int`, *opcional*, padrão 0) : O eixo no qual quantizar as chaves.

axis_value (`int`, *opcional*, padrão 0) : O eixo no qual quantizar os valores.

q_group_size (`int`, *opcional*, padrão 64) : A quantização é realizada por canal de acordo com um conjunto `q_group_size` para ambas as chaves e os valores.

residual_length (`int`, *opcional*, padrão 128) : Capacidade máxima para o cache de precisão original.

Um cache de quantização semelhante ao descrito no [artigo KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache](https://huggingface.co/papers/2402.02750). Ele permite que o modelo gere sequências mais longas sem alocar memória excessiva para chaves e valores, aplicando quantização. O cache possui dois tipos de armazenamento: um para a precisão original e outro para o cache quantizado. Um `residual length` é definido como a capacidade máxima para o cache de precisão original. Quando o comprimento excede a capacidade máxima, o cache de precisão original é descartado e movido para o cache quantizado. A quantização é realizada por canal, com um `q_group_size` definido para ambas as chaves e valores, em contraste com o que foi descrito no artigo.

Veja `Cache` para obter detalhes sobre os métodos comuns implementados por todas as classes de cache.

Os cinco últimos argumentos configuram os backends de inteiros por grupo. O backend `fp8` quantiza por tensor e os rejeita.

#### transformers.EncoderDecoderCache[[transformers.EncoderDecoderCache]]

```python
transformers.EncoderDecoderCache(*caches)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2199)

**Parâmetros:**

caches (`Iterable`) : Geralmente um iterável de comprimento 2, contendo 2 objetos `Cache`, o primeiro para autoatenção e o segundo para atenção cruzada. Opcionalmente, também pode ser um iterável de comprimento 1, contendo um `tuple[tuple[torch.Tensor]]` (geralmente usado para compatibilidade com torch dp e ddp).

Base, classe abstrata para todos os caches de encoder-decoder. Pode ser usada para manter combinações de caches de autoatenção e atenção cruzada.

Veja `Cache` para obter detalhes sobre os métodos comuns implementados por todas as classes de cache.

Exemplo:

```python
>>> from transformers import AutoProcessor, AutoModelForCausalLM, DynamicCache, EncoderDecoderCache

>>> model = AutoModelForCausalLM.from_pretrained("openai/whisper-small")
>>> processor = AutoProcessor.from_pretrained("openai/whisper-small")

>>> inputs = processor(audio=YOUR-AUDIO, return_tensors="pt")

>>> # Prepare cache classes for encoder and decoder and pass it to model's forward
>>> self_attention_cache = DynamicCache(config=self.config)
>>> cross_attention_cache = DynamicCache(config=self.config)
>>> past_key_values = EncoderDecoderCache(self_attention_cache, cross_attention_cache)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
EncoderDecoderCache()
```

#### batch_repeat_interleave[[transformers.EncoderDecoderCache.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2316)

Repita o cache `repeats` vezes na dimensão do lote. Usado na busca contrastiva (no Hub).

#### batch_select_indices[[transformers.EncoderDecoderCache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2322)

Mantenha apenas os `indices` na dimensão do lote do cache. Usado na busca contrastiva (no Hub).

#### crop[[transformers.EncoderDecoderCache.crop]]

```python
crop(tokens_to_remove: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2309)

Remove `tokens_to_remove` tokens da camada de cache atual.

#### get_max_length[[transformers.EncoderDecoderCache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2284)

Retorna o comprimento máximo da sequência (ou seja, a capacidade máxima) do objeto de cache

#### get_seq_length[[transformers.EncoderDecoderCache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2280)

Retorna o comprimento da sequência dos estados em cache. Um índice de camada pode ser passado opcionalmente.

#### reorder_cache[[transformers.EncoderDecoderCache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2294)

Reordena o cache para a busca por feixe, dados os índices de feixe selecionados.

## Utilitários de marca d'água[[transformers.WatermarkingConfig]]

#### transformers.WatermarkingConfig[[transformers.WatermarkingConfig]]

```python
transformers.WatermarkingConfig(greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1)
```

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

Classe que armazena os argumentos para a geração de marca d'água e deve ser passada para `GenerationConfig` durante `generate`. Consulte [este artigo](https://huggingface.co/papers/2306.04634) para mais detalhes sobre os argumentos.

Aceita as seguintes chaves:
- greenlist_ratio (`float`): Usado para marca d'água. A proporção de tokens "verdes" em relação ao tamanho do vocabulário. O valor padrão é 0,25.
- bias (`float`): Usado com marca d'água. O viés adicionado aos logits dos tokens "verdes" selecionados. O valor padrão é 2.0.
- hashing_key (`int`): Chave de hash usada para marcação de água. O valor padrão é 15485863 (o milionésimo número primo).
- seeding_scheme (`str`): Algoritmo a ser usado para marca d'água. Aceita os valores:
  - "lefthash" (padrão): a seleção de tokens "green" depende do último token (Algoritmo 2 do artigo)
  - A seleção de tokens "selfhash": "green" depende do próprio token atual (Algoritmo 3 do artigo). A desvantagem desse esquema é que ele considera todos os possíveis tokens seguintes e pode ser mais lento que "lefthash".
- context_width(`int`): O comprimento do contexto dos tokens anteriores a ser usado na semeadura. Um comprimento de contexto maior torna a marca d'água mais robusta.

#### __call__[[transformers.WatermarkingConfig.__call__]]

```python
__call__(*args, **kwargs)
```

Chame self como uma função.

#### transformers.WatermarkDetector[[transformers.WatermarkDetector]]

```python
transformers.WatermarkDetector(model_config: PreTrainedConfig, device: str, watermarking_config: typing.Union[ForwardRef('WatermarkingConfig'), dict], ignore_repeated_ngrams: bool = False, max_cache_size: int = 128)
```

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

**Parâmetros:**

model_config (`PreTrainedConfig`) : A configuração do modelo que será usada para obter os argumentos específicos do modelo utilizados na geração.

device (`str`) : O dispositivo utilizado durante a geração de texto com marca d'água.

watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : A configuração e os argumentos de marca d'água exatos usados na geração de texto.

ignore_repeated_ngrams (`bool`, *opcional*, padrão `False`) : Se cada n-grama único deve ser contado apenas uma vez ou não.

max_cache_size (`int`, *opcional*, padrão 128) : O tamanho máximo a ser usado para o cache LRU dos algoritmos de seeding/sampling chamados para cada token.

Detector para detecção de texto gerado com marca d'água. O detector precisa receber exatamente as mesmas configurações que foram fornecidas durante a geração do texto para replicar a geração da greenlist da marca d'água e, assim, detectar a marca d'água. Isso inclui o dispositivo correto utilizado durante a geração do texto, os argumentos corretos de marca d'água e o tamanho correto do vocabulário do tokenizer. O código foi baseado no [repositório original](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

Veja [o artigo](https://huggingface.co/papers/2306.04634) para mais informações.

Exemplos:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig

>>> model_id = "openai-community/gpt2"
>>> model = AutoModelForCausalLM.from_pretrained(model_id)
>>> tok = AutoTokenizer.from_pretrained(model_id)
>>> tok.pad_token_id = tok.eos_token_id
>>> tok.padding_side = "left"

>>> inputs = tok(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt")
>>> input_len = inputs["input_ids"].shape[-1]

>>> # first generate text with watermark and without
>>> watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash")
>>> out_watermarked = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20)
>>> out = model.generate(**inputs, do_sample=False, max_length=20)

>>> # now we can instantiate the detector and check the generated text
>>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config)
>>> detection_out_watermarked = detector(out_watermarked, return_dict=True)
>>> detection_out = detector(out, return_dict=True)
>>> detection_out_watermarked.prediction
array([ True,  True])

>>> detection_out.prediction
array([False,  False])
```

#### __call__[[transformers.WatermarkDetector.__call__]]

```python
__call__(input_ids: LongTensor, z_threshold: float = 3.0, return_dict: bool = False)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor`) : O texto gerado com marca d'água. Recomenda-se remover o prompt, pois ele pode afetar a detecção.

z_threshold (`Dict`, *opcional*, padrão `3.0`) : Alterar esse limiar altera a sensibilidade do detector. Um limiar z mais alto resulta em menor sensibilidade, e vice-versa para um limiar z mais baixo.

return_dict (`bool`,  *opcional*, padrão `False`) : Indica se deve retornar `~generation.WatermarkDetectorOutput` ou não. Caso contrário, retornará previsões booleanas,

**Retorna:** `WatermarkDetectorOutput` ou `np.ndarray`

Um `WatermarkDetectorOutput` se `return_dict=True`, caso contrário, um `np.ndarray`.

ma

#### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]]

```python
transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs)
```

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

**Parâmetros:**

watermarking_depth (`int`, *opcional*) : O número de camadas de torneio.

base_rate (`float`, *opcional*, padrão 0.5) : Probabilidade a priori P(w) de que um texto esteja com marca d'água.

Esta é a classe de configuração para armazenar a configuração de um [BayesianDetectorModel](/docs/transformers/main/pt/internal/generation_utils#transformers.BayesianDetectorModel). Ela é usada para instanciar um modelo Bayesian Detector de acordo com os argumentos especificados.

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

#### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]]

```python
transformers.BayesianDetectorModel(config)
```

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

**Parâmetros:**

config ([BayesianDetectorConfig](/docs/transformers/main/pt/internal/generation_utils#transformers.BayesianDetectorConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Classificador bayesiano para detecção de marca d'água.

Este detector usa a regra de Bayes para calcular uma pontuação de marca d'água, que é a sigmoide do log da razão entre as probabilidades a posteriori P(watermarked|g_values) e P(unwatermarked|g_values). Consulte a seção sobre BayesianScore no artigo para mais detalhes. URL do artigo: https://www.nature.com/articles/s41586-024-08025-4

Observe que este detector funciona apenas com marca d'água baseada em torneio sem distorção, usando a distribuição de valor g Bernoulli(0.5).

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.BayesianDetectorModel.forward]]

```python
forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False)
```

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

**Parâmetros:**

g_values (`torch.Tensor` de forma `(batch_size, seq_len, watermarking_depth, ...)`) : valores g (com valores 0 ou 1)

mask : Um array binário com forma [batch_size, seq_len] que indica quais valores de g devem ser usados. Valores de g com valor de máscara 0 são descartados.

**Retorna:**

p(watermarked | g_values), de forma [batch_size].

Calcula a posterior com marca d'água P(watermarked|g_values).

#### transformers.SynthIDTextWatermarkingConfig[[transformers.SynthIDTextWatermarkingConfig]]

```python
transformers.SynthIDTextWatermarkingConfig(ngram_len: int, keys: list, context_history_size: int = 1024, sampling_table_seed: int = 0, sampling_table_size: int = 65536, skip_first_ngram_calls: bool = False, debug_mode: bool = False)
```

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

**Parâmetros:**

ngram_len (`int`) : Comprimento do n-grama.

keys (`list[int]`) : Uma sequência de chaves de marca d'água, uma para cada profundidade.

context_history_size (`int`, *opcional*, padrão 1024) : Tamanho do tensor para acompanhar os contextos já vistos.

sampling_table_seed (`int`, *opcional*, padrão 0) : Semente aleatória para gerar a tabela de amostragem.

sampling_table_size (`int`, *opcional*, padrão 65536) : Tamanho da tabela de amostragem.

skip_first_ngram_calls (`bool`, *opcional*, padrão `False`) : Se deve ignorar as primeiras chamadas de ngram.

debug_mode (`bool`, *opcional*, padrão `False`) : Os logits são modificados para um uniforme obtido antes da aplicação da modificação de marca d'água. Isso serve para testar a implementação.

Classe que armazena os argumentos para a geração de marca d'água e deve ser passada para `GenerationConfig` durante `generate`. Consulte [este artigo](https://www.nature.com/articles/s41586-024-08025-4) para mais detalhes sobre os argumentos.

Exemplos:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

>>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left")
>>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b')

>>> # SynthID Text configuration
>>> watermarking_config = SynthIDTextWatermarkingConfig(
...     keys=[654, 400, 836, 123, 340, 443, 597, 160, 57],
...     ngram_len=5,
... )

>>> # Generation with watermarking
>>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True)
>>> output_sequences = model.generate(
...     **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10
... )
>>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True)
```

#### transformers.SynthIDTextWatermarkDetector[[transformers.SynthIDTextWatermarkDetector]]

```python
transformers.SynthIDTextWatermarkDetector(detector_module: BayesianDetectorModel, logits_processor: SynthIDTextWatermarkLogitsProcessor, tokenizer: Any)
```

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

**Parâmetros:**

detector_module ([BayesianDetectorModel](/docs/transformers/main/pt/internal/generation_utils#transformers.BayesianDetectorModel)) : objeto de módulo de detector bayesiano inicializado com parâmetros. Consulte https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text para ver o uso.

logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : o processador de logits usado para marcação d'água.

tokenizer (`Any`) : O tokenizer usado para o modelo.

Classe do detector de marca d'água de texto SynthID.

Esta classe deve ser inicializada com o módulo do detector bayesiano treinado; consulte o script de verificação em examples/synthid_text/detector_training.py, por exemplo, para treinar, salvar e carregar este módulo do detector. A pasta também apresenta um caso de uso de exemplo deste detector.

Exemplos:
```python
>>> from transformers import (
...     AutoTokenizer, BayesianDetectorModel, SynthIDTextWatermarkLogitsProcessor, SynthIDTextWatermarkDetector
... )

>>> # Load the detector. See https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text for training a detector.
>>> detector_model = BayesianDetectorModel.from_pretrained("joaogante/dummy_synthid_detector")
>>> logits_processor = SynthIDTextWatermarkLogitsProcessor(
...     **detector_model.config.watermarking_config, device="cpu"
... )
>>> tokenizer = AutoTokenizer.from_pretrained(detector_model.config.model_name)
>>> detector = SynthIDTextWatermarkDetector(detector_model, logits_processor, tokenizer)

>>> # Test whether a certain string is watermarked
>>> test_input = tokenizer(["This is a test input"], return_tensors="pt")
>>> is_watermarked = detector(test_input.input_ids)
```

#### __call__[[transformers.SynthIDTextWatermarkDetector.__call__]]

```python
__call__(tokenized_outputs: Tensor)
```

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

## Utilitários de Compilação[[transformers.CompileConfig]]

#### transformers.CompileConfig[[transformers.CompileConfig]]

```python
transformers.CompileConfig(fullgraph: bool = False, dynamic: bool | None = None, backend: str | collections.abc.Callable = 'inductor', mode: str = 'reduce-overhead', options: dict | None = None)
```

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

**Parâmetros:**

fullgraph (`bool`, *opcional*, padrão `False`) : Se False (padrão), tenta descobrir regiões compiláveis que serão otimizadas. Se True, exige que a função inteira seja capturável em um único grafo. Se isso não for possível (ou seja, se houver quebras de grafo), um erro será lançado.

dynamic (`bool` ou `None`, *opcional*) : Se deve tentar usar grafos de forma dinâmica.

backend (`str` ou `Callable`, *opcional*, padrão `"inductor"`) : Backend a ser utilizado.

mode (`str`, *opcional*, padrão `"reduce-overhead"`) : Controla o equilíbrio entre desempenho e sobrecarga.

options (`dict`, *opcional*) : Um dicionário de opções para passar ao backend.

Classe que armazena os argumentos relativos ao comportamento de `torch.compile` ao usar a compilação automática em `generate`. Consulte [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html) para mais detalhes sobre os argumentos.

Exemplos:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, CompileConfig

>>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b')
>>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b').cuda()

>>> # Automatic compile configuration, used with static cache
>>> compile_config = CompileConfig(dynamic=True)

>>> # Generation with static cache and compile config
>>> input = tokenizer.encode("Hello there, how", return_tensors="pt").cuda()
>>> output = model.generate(
...     input, do_sample=False, max_new_tokens=300, cache_implementation="static", compile_config=compile_config
... )
>>> output_text = tokenizer.batch_decode(output, skip_special_tokens=True)[0]
```

#### __call__[[transformers.CompileConfig.__call__]]

```python
__call__(*args, **kwargs)
```

Chame self como uma função.