# Utilitas untuk generasi

Halaman ini mencantumkan semua fungsi utilitas yang digunakan oleh [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate).

## Generate Output[[transformers.generation.GenerateDecoderOnlyOutput]]

Output dari [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate) adalah instance dari subclass [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput). Output ini merupakan struktur data yang berisi semua informasi yang dikembalikan oleh [generate()](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin.generate), tetapi juga dapat digunakan sebagai tuple atau dictionary.

Berikut adalah contohnya:

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

Objek `generation_output` adalah [GenerateDecoderOnlyOutput](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput), dan seperti yang dapat kita lihat dalam dokumentasi kelas tersebut di bawah, artinya objek ini memiliki atribut berikut:

- `sequences`: rangkaian token yang dihasilkan
- `scores` (opsional): skor prediksi dari kepala pemodelan bahasa, untuk setiap langkah generasi
- `hidden_states` (opsional): hidden states dari model, untuk setiap langkah generasi
- `attentions` (opsional): bobot perhatian model, untuk setiap langkah generasi

Di sini kita memiliki `scores` karena kita meneruskan `output_scores=True`, tetapi kita tidak memiliki `hidden_states` dan `attentions` karena kita tidak meneruskan `output_hidden_states=True` atau `output_attentions=True`.

Anda dapat mengakses setiap atribut seperti biasa, dan jika atribut tersebut tidak dikembalikan oleh model, Anda akan mendapatkan `None`. Misalnya, di sini `generation_output.scores` adalah semua skor prediksi yang dihasilkan oleh kepala pemodelan bahasa, dan `generation_output.attentions` adalah `None`.

Saat menggunakan objek `generation_output` kami sebagai tuple, objek ini hanya menyimpan atribut yang tidak memiliki nilai `None`. Di sini, misalnya, ada dua elemen, yaitu `loss` lalu `logits`, sehingga

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

akan mengembalikan tuple `(generation_output.sequences, generation_output.scores)`, misalnya.

Saat menggunakan objek `generation_output` kami sebagai kamus, hanya atribut yang tidak memiliki nilai `None` yang dipertahankan. Di sini, misalnya, terdapat dua kunci, yaitu `sequences` dan `scores`.

Kami mendokumentasikan semua tipe output di sini.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/utils.py#L183)

**Parameter:**

sequences (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Urutan yang dihasilkan. Dimensi kedua (sequence_length) sama dengan `max_length` atau lebih pendek jika semua batch selesai lebih awal karena `eos_token_id`.

scores (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_scores=True`) : Skor prediksi yang diproses dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax) pada setiap langkah generasi. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_logits=True`) : Skor prediksi yang belum diproses dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax) pada setiap langkah generasi. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size, config.vocab_size)`.

attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_hidden_states=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opsional*, dikembalikan saat `use_cache=True`) : Mengembalikan cache model, yang digunakan untuk mempercepat decoding. Model yang berbeda memiliki format cache yang berbeda, periksa dokumentasi model tersebut. Biasanya, sebuah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache).

Output dari model generasi decoder-only, ketika menggunakan metode non-beam.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/utils.py#L219)

**Parameter:**

sequences (`torch.LongTensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)`) : Urutan yang dihasilkan. Dimensi kedua (sequence_length) sama dengan `max_length` atau lebih pendek jika semua batch selesai lebih awal karena `eos_token_id`.

scores (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_scores=True`) : Skor prediksi yang diproses dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax) pada setiap langkah generasi. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_logits=True`) : Skor prediksi yang belum diproses dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax) pada setiap langkah generasi. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size, config.vocab_size)`.

encoder_attentions (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer decoder) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_hidden_states=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opsional*, dikembalikan saat `use_cache=True`) : Mengembalikan cache model, yang digunakan untuk mempercepat decoding. Model yang berbeda memiliki format cache yang berbeda, periksa dokumentasi model tersebut. Biasanya, sebuah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache).

Output dari model generasi encoder-decoder, ketika menggunakan metode non-beam.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/utils.py#L267)

**Parameter:**

sequences (`torch.LongTensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)`) : Urutan yang dihasilkan. Dimensi kedua (sequence_length) sama dengan `max_length` atau lebih pendek jika semua batch selesai lebih awal karena `eos_token_id`.

sequences_scores (`torch.Tensor` dengan bentuk `(batch_size*num_return_sequences)`, *opsional*, dikembalikan saat `output_scores=True`) : Skor beam akhir dari `sequences` yang dihasilkan.

scores (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_scores=True`) : Skor transisi beam untuk setiap token kosakata pada setiap langkah generasi. Skor transisi beam yang terdiri dari log probabilitas token yang dikondisikan pada log softmax dari token yang sebelumnya dihasilkan dalam beam ini. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_logits=True`) : Skor prediksi yang belum diproses dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax) pada setiap langkah generasi. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *opsional*, dikembalikan saat `output_scores=True`) : Indeks beam dari id token yang dihasilkan pada setiap langkah generasi. `torch.LongTensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)`.

attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap lapisan decoder) dari `torch.Tensor` dengan bentuk `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan saat `output_hidden_states=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *opsional*, dikembalikan saat `use_cache=True`) : Mengembalikan cache model, yang digunakan untuk mempercepat decoding. Model yang berbeda memiliki format cache yang berbeda, periksa dokumentasi model tersebut. Biasanya, sebuah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache).

Output dari model generasi decoder-only, saat menggunakan metode beam.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/utils.py#L311)

**Parameter:**

sequences (`torch.LongTensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)`) : Urutan yang dihasilkan. Dimensi kedua (sequence_length) sama dengan `max_length` atau lebih pendek jika semua batch selesai lebih awal karena `eos_token_id`.

sequences_scores (`torch.Tensor` dengan bentuk `(batch_size*num_return_sequences)`, *opsional*, dikembalikan saat `output_scores=True`) : Skor beam akhir dari `sequences` yang dihasilkan.

scores (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_scores=True`) : Skor transisi beam untuk setiap token kosakata pada setiap langkah generasi. Skor transisi beam yang terdiri dari log probabilitas token yang dikondisikan pada log softmax dari token yang sebelumnya dihasilkan dalam beam ini. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *opsional*, dikembalikan saat `output_logits=True`) : Skor prediksi yang belum diproses dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax) pada setiap langkah generasi. Tuple dari `torch.Tensor` dengan hingga `max_new_tokens` elemen (satu elemen untuk setiap token yang dihasilkan), dengan setiap tensor berbentuk `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *opsional*, dikembalikan saat `output_scores=True`) : Indeks beam dari id token yang dihasilkan pada setiap langkah generasi. `torch.LongTensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)`.

encoder_attentions (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) : Tuple dari `torch.Tensor` (satu untuk setiap layer decoder) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True`) : Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan saat `output_hidden_states=True`) : Tuple (satu elemen untuk setiap token yang dihasilkan) dari tuple (satu elemen untuk setiap layer decoder) dari `torch.Tensor` dengan bentuk `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *opsional*, dikembalikan saat `use_cache=True`) : Mengembalikan cache model, yang digunakan untuk mempercepat decoding. Model yang berbeda memiliki format cache yang berbeda, periksa dokumentasi model tersebut. Biasanya, sebuah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache).

Output dari model generasi encoder-decoder, saat menggunakan metode beam.

## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) dapat digunakan untuk memodifikasi skor prediksi dari kepala model bahasa untuk generasi.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2228)

**Parameter:**

input_start_len (`int`) : Panjang dari urutan input awal.

semantic_vocab_size (`int`) : Ukuran kosakata bagian semantik, yaitu jumlah token yang terkait dengan kosakata semantik.

codebook_size (`int`) : Jumlah token yang terkait dengan codebook.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang menegakkan generasi bergantian antara dua codebook Bark.

Logits processor ini hanya kompatibel dengan submodel fine dari [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark). Lihat dokumentasi model untuk contoh.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2257)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2164)

**Parameter:**

guidance_scale (float) : Skala panduan untuk panduan bebas pengklasifikasi (CFG). CFG diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong model untuk menghasilkan sampel yang lebih erat kaitannya dengan prompt masukan, biasanya dengan mengorbankan kualitas yang lebih buruk.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) untuk classifier free guidance (CFG). Skor dipecah di sepanjang dimensi batch, di mana setengah pertama sesuai dengan logits kondisional (diprediksi dari prompt input) dan setengah kedua sesuai dengan logits tak kondisional (diprediksi dari prompt kosong atau 'null'). Prosesor ini menghitung rata-rata berbobot di antara logits kondisional dan tak kondisional, yang diparameterisasi oleh `guidance_scale`.

Lihat [makalahnya](https://huggingface.co/papers/2306.05284) untuk informasi lebih lanjut.

Logits processor ini hanya kompatibel dengan [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen)

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2212)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1173)

**Parameter:**

encoder_ngram_size (`int`) : Semua ngram berukuran `ngram_size` hanya dapat muncul di dalam encoder input ids.

encoder_input_ids (`int`) : encoder_input_ids yang tidak boleh diulang di dalam decoder ids.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang bekerja serupa dengan [NoRepeatNGramLogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor), tetapi diterapkan secara eksklusif untuk mencegah pengulangan n-gram yang ada dalam prompt.

Hal ini dirancang untuk mendorong sifat kecerewetan pada model bahasa, dengan mencegah pengulangan n-gram yang sudah muncul pada putaran percakapan sebelumnya.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1222)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L440)

**Parameter:**

penalty (`float`) : Parameter untuk repetition penalty. 1.0 berarti tidak ada penalti. Di atas 1.0 memberi imbalan pada token prompt. Di antara 0.0 dan 1.0 memberlakukan penalti pada token prompt.

encoder_input_ids (`torch.LongTensor`) : encoder_input_ids yang harus diulang di dalam decoder ids.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang bekerja serupa dengan [RepetitionPenaltyLogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor), tetapi dengan penalti *invers* yang diterapkan pada token yang ada dalam prompt. Dengan kata lain, penalti di atas 1.0 meningkatkan peluang pemilihan token yang sudah ada dalam prompt.

Desainnya bertujuan untuk menghindari halusinasi pada tugas yang berbasis input, seperti ringkasan. Meskipun awalnya ditujukan untuk model encoder-decoder, fitur ini juga dapat digunakan dengan model decoder-only seperti LLM.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L486)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L897)

**Parameter:**

epsilon (`float`) : Jika diatur ke > 0, hanya token dengan probabilitas `epsilon` atau lebih tinggi yang dipertahankan untuk generasi.

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang difilter akan diset ke nilai float ini.

min_tokens_to_keep (`int`, *opsional*, default 1) : Jumlah minimum token yang tidak dapat difilter.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang melakukan epsilon-sampling, yaitu membatasi pada token dengan `prob >= epsilon`. Jika tidak ada token yang memenuhi batasan ini, diambil min_tokens_to_keep token terbesar. Lihat [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) untuk informasi lebih lanjut.

Contoh:
```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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L952)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L966)

**Parameter:**

epsilon (`float`) : Nilai float dalam rentang (0, 1). Hyperparameter yang digunakan untuk menghitung nilai cutoff dinamis, `eta`. Nilai yang disarankan dari paper berkisar dari 3e-4 hingga 4e-3 tergantung pada ukuran model.

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang ditemukan berada di bawah nilai cutoff dinamis, `eta`, akan diset ke nilai float ini. Parameter ini berguna ketika logits perlu dimodifikasi untuk token dengan probabilitas sangat rendah yang harus dikecualikan sepenuhnya dari proses generasi.

min_tokens_to_keep (`int`, *opsional*, default 1) : Menentukan jumlah minimum token yang harus dipertahankan untuk generasi, terlepas dari probabilitasnya. Misalnya, jika `min_tokens_to_keep` diatur ke 1, setidaknya satu token akan selalu dipertahankan untuk generasi, bahkan jika semua token memiliki probabilitas di bawah ambang `eta`.

device (`str`, *opsional*, default `"cpu"`) : Perangkat untuk mengalokasikan tensor.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang melakukan eta-sampling, yaitu teknik untuk menyaring token dengan probabilitas di bawah nilai ambang dinamis, `eta`, yang dihitung berdasarkan kombinasi hiperparameter `epsilon` dan entropi dari probabilitas token, yaitu `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. Jika tidak ada token yang memenuhi batasan ini, processor ini mengambil min_tokens_to_keep token dengan probabilitas tertinggi. Hal ini mengatasi masalah kualitas yang buruk pada sampel teks panjang yang dihasilkan oleh model bahasa neural, sehingga menghasilkan teks yang lebih koheren dan lancar. Lihat [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) untuk informasi lebih lanjut. Catatan: `do_sample` harus diatur ke `True` agar `LogitsProcessor` ini dapat berfungsi.

Contoh:
```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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1035)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1718)

**Parameter:**

exponential_decay_length_penalty (`tuple(int, float)`) : Tuple ini harus terdiri dari: `(start_index, decay_factor)` di mana `start_index` menunjukkan di mana penalti dimulai dan `decay_factor` mewakili faktor peluruhan eksponensial

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

input_ids_seq_length (`int`) : Panjang dari sekuens input.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang secara eksponensial meningkatkan skor dari `eos_token_id` setelah `start_index` tercapai. Hal ini memungkinkan pembuatan sekuens yang lebih pendek tanpa pemotongan keras, sehingga `eos_token` dapat diprediksi pada posisi yang bermakna.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1804)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1596)

**Parameter:**

bos_token_id (`int`) : id dari token yang dipaksa sebagai token pertama yang dihasilkan.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang memaksa token yang ditentukan sebagai token pertama yang dihasilkan. Digunakan dengan model encoder-decoder.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1631)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1641)

**Parameter:**

max_length (`int`) : Panjang maksimum dari sekuens yang akan dihasilkan.

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

device (`str`, *opsional*, default `"cpu"`) : Perangkat untuk mengalokasikan tensor.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang memaksa token yang ditentukan menjadi token yang dihasilkan terakhir ketika `max_length` tercapai.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1687)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1697)

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang menghapus semua nilai `nan` dan `inf` untuk menghindari kegagalan metode generasi. Perhatikan bahwa penggunaan logits processor sebaiknya hanya dilakukan jika diperlukan, karena dapat memperlambat metode generasi.

Logits processor ini tidak memiliki contoh `generate`, karena seharusnya tidak ada kombinasi flag yang benar yang memerlukan penggunaannya.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1706)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1820)

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) untuk menormalisasi skor menggunakan log-softmax. Penting untuk menormalisasi skor selama beam search, setelah menerapkan logits processors atau warpers, karena algoritma pencarian yang digunakan di pustaka ini tidak melakukannya (hanya dilakukan sebelumnya, tetapi mungkin perlu normalisasi ulang), namun algoritma tersebut tetap mengasumsikan bahwa skor sudah ternormalisasi saat membandingkan hipotesis.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1851)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L49)

Kelas basis abstrak untuk semua pemroses logit yang dapat diterapkan selama generasi.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L56)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L63)

Kelas ini dapat digunakan untuk membuat daftar [LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) guna memproses tensor input `scores` secara berurutan. Kelas ini mewarisi dari list dan menambahkan metode *__call__* khusus untuk menerapkan setiap [LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) ke input.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L70)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

kwargs (`dict[str, Any]`, *opsional*) : kwargs tambahan yang spesifik untuk logits processor.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L101)

**Parameter:**

min_length (`int`) : Panjang minimum di bawah mana skor dari `eos_token_id` diatur menjadi `-float("Inf")`.

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

device (`str`, *opsional*, default `"cpu"`) : Perangkat untuk mengalokasikan tensor.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang menegakkan panjang minimum dengan mengatur probabilitas EOS menjadi 0. Perhatikan bahwa, untuk model decoder-only seperti sebagian besar LLM, panjang tersebut mencakup prompt.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L154)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

#### 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')
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L164)

**Parameter:**

prompt_length_to_skip (`int`) : Panjang token input. Bukan argumen yang valid saat digunakan dengan `generate` karena panjang input akan ditetapkan secara otomatis.

min_new_tokens (`int`) : Panjang minimum *new* tokens di bawah mana skor dari `eos_token_id` diatur menjadi `-float("Inf")`.

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

device (`str`, *opsional*, default `"cpu"`) : Perangkat untuk mengalokasikan tensor.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang menegakkan panjang minimum token baru dengan mengatur probabilitas token EOS (End-Of-Sequence) menjadi 0. Berbeda dengan [MinLengthLogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.MinLengthLogitsProcessor), prosesor ini mengabaikan prompt.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L226)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L733)

**Parameter:**

min_p (`float`) : Probabilitas token minimum, yang akan diskalakan oleh probabilitas token yang paling mungkin. Nilainya harus berada di antara 0 dan 1. Nilai tipikal berada dalam rentang 0,01-0,2, dengan tingkat selektivitas yang sebanding dengan pengaturan `top_p` dalam rentang 0,99-0,8 (gunakan kebalikan dari nilai `top_p` normal).

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang difilter akan diset ke nilai float ini.

min_tokens_to_keep (`int`, *opsional*, default 1) : Jumlah minimum token yang tidak dapat difilter.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang melakukan min-p, yaitu mempertahankan semua token yang berada di atas probabilitas minimum, yang diskalakan berdasarkan probabilitas token yang paling mungkin. Akibatnya, filter menjadi lebih agresif ketika terdapat token dengan probabilitas tinggi, yang merupakan tanda dari output yang percaya diri dan sebaiknya tidak disimpangkan.

Sering digunakan bersama dengan [TemperatureLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TemperatureLogitsWarper). Digunakan sebagai alternatif untuk [TopPLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TopPLogitsWarper) dan [TopKLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TopKLogitsWarper).

Dibuat oleh @menhguin dan @kalomaze (nama pengguna github). Kode diadaptasi dari [PR eksternal ini](https://github.com/oobabooga/text-generation-webui/pull/4449/files)

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L790)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1432)

**Parameter:**

bad_words_ids (`list[list[int]]`) : Daftar dari daftar token id yang tidak diizinkan untuk dihasilkan.

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

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang memastikan bahwa urutan tertentu tidak akan pernah dipilih.

Untuk mendapatkan token id dari kata-kata yang tidak boleh muncul dalam teks yang dihasilkan, pastikan untuk mengatur `add_prefix_space=True` saat menginisialisasi tokenizer, dan gunakan `tokenizer(bad_words, add_special_tokens=False).input_ids`. Argumen `add_prefix_space` hanya didukung untuk beberapa tokenizer lambat, karena perilaku prefixing pada tokenizer cepat berasal dari `pre tokenizers`. Baca selengkapnya [di sini](https://huggingface.co/docs/tokenizers/api/pre-tokenizers).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1319)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1102)

**Parameter:**

ngram_size (`int`) : Semua ngram berukuran `ngram_size` hanya dapat muncul satu kali.

N-gram adalah kelompok "n" kata, karakter, atau token berurutan yang diambil dari sebuah rangkaian teks. Diberikan kalimat: "She runs fast", bi-gram (n=2) akan menjadi ("she", "runs") dan ("runs", "fast"). Dalam generasi teks, menghindari pengulangan rangkaian kata menghasilkan keluaran yang lebih beragam. [LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) ini menegakkan larangan pengulangan n-gram dengan mengatur skor token yang dilarang menjadi negatif tak hingga, yang menghilangkan token tersebut dari pertimbangan saat memproses skor lebih lanjut. Perhatikan bahwa, untuk model hanya-decoder seperti sebagian besar LLM, prompt juga dipertimbangkan untuk memperoleh n-gram. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345).

Gunakan penalti n-gram dengan hati-hati. Misalnya, memberlakukan penalti pada 2-gram (bigram) dalam artikel tentang kota New York dapat menghasilkan hasil yang tidak diinginkan, di mana nama kota tersebut hanya muncul sekali di seluruh teks. [Referensi](https://huggingface.co/blog/how-to-generate)

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1149)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

```python
transformers.PrefixConstrainedLogitsProcessor(prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]], num_beams: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1521)

**Parameter:**

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : Fungsi ini membatasi beam search hanya pada token yang diizinkan di setiap langkah. Fungsi ini menerima 2 argumen, yaitu `inputs_ids` dan ID batch `batch_id`. Fungsi ini harus mengembalikan daftar token yang diizinkan untuk langkah generasi berikutnya, dengan kondisi token yang telah dihasilkan sebelumnya `inputs_ids` dan ID batch `batch_id`.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang menerapkan pembangkitan terkonstruksi dan berguna untuk pembangkitan terkonstruksi yang dikondisikan pada prefiks. Lihat [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) untuk informasi lebih lanjut.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1572)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L306)

**Parameter:**

penalty (`float`) : Parameter untuk repetition penalty. 1.0 berarti tidak ada penalti. Nilai di atas 1.0 memberikan penalti pada token yang telah dihasilkan sebelumnya. Nilai antara 0.0 dan 1.0 memberikan imbalan pada token yang telah dihasilkan sebelumnya.

prompt_ignore_length (`int` atau `torch.LongTensor`, *opsional*) : Jumlah token awal yang diabaikan, dapat ditentukan per elemen batch.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang mencegah pengulangan token sebelumnya melalui penalti. Penalti ini diterapkan paling banyak sekali per token. Perhatikan bahwa, untuk model decoder-only seperti sebagian besar LLM, token yang dipertimbangkan secara default mencakup prompt.

Pada [makalah](https://huggingface.co/papers/1909.05858) aslinya, para penulis menyarankan penggunaan nilai penalti sekitar 1,2 untuk mencapai keseimbangan yang baik antara generasi yang jujur dan minimnya pengulangan. Untuk memberikan penalti dan mengurangi pengulangan, gunakan nilai `penalty` di atas 1,0, di mana nilai yang lebih tinggi memberikan penalti yang lebih kuat. Untuk memberikan imbalan dan mendorong pengulangan, gunakan nilai `penalty` antara 0,0 dan 1,0, di mana nilai yang lebih rendah memberikan imbalan yang lebih kuat.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L373)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

```python
transformers.SequenceBiasLogitsProcessor(sequence_bias: list[list[list[int] | float]])
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1242)

**Parameter:**

sequence_bias (`list[list[Union[list[int], float]]]`) : Daftar dari daftar yang memetakan urutan token ke istilah bias-nya (mis. `[[[10, 45], -2.0], [[64], -7.5]]`). Bias positif meningkatkan peluang urutan tersebut terpilih, sedangkan bias negatif melakukan kebalikannya. Jika sebuah urutan memiliki panjang 1, bias-nya akan selalu diterapkan. Sebaliknya, bias hanya akan diterapkan jika urutan yang dimaksud akan segera diselesaikan (pada langkah pemilihan token setelah pemroses ini diterapkan).

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang menerapkan bias aditif pada sekuens. Bias diterapkan pada token terakhir dari sebuah sekuens ketika token yang dihasilkan berikutnya dapat melengkapinya. Oleh karena itu, untuk memanfaatkan bias pada sekuens dengan lebih dari satu token secara optimal, pertimbangkan untuk menggunakan metode beam (untuk menangani sekuens yang hanya sebagian selesai dan memiliki bias negatif secara halus) serta menerapkan bias pada prefiks mereka (untuk memastikan bias diterapkan lebih awal).

Pada tingkat token, membiasakan sebuah kata berbeda dengan membiasakan kata yang memiliki spasi di depannya. Jika Anda ingin membiasakan "foo" di tengah kalimat, kemungkinan besar Anda perlu menambahkan spasi awalan dan membiasakan " foo" sebagai gantinya. Periksa bagian tokenizer di kursus NLP kami untuk mengetahui alasannya: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1319)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1857)

[SuppressTokensAtBeginLogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor) menekan daftar token segera setelah fungsi `generate` mulai menghasilkan output menggunakan `begin_index` token. Hal ini memastikan bahwa token yang didefinisikan oleh `begin_suppress_tokens` tidak dihasilkan di bagian awal. Awalnya dibuat untuk [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1899)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1910)

Prosesor ini dapat digunakan untuk menekan daftar token. Prosesor akan mengatur log prob mereka menjadi `-inf` sehingga token tersebut tidak dihasilkan. Awalnya dibuat untuk [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1942)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2611)

**Parameter:**

ngram_len (`int`) : Panjang ngram.

keys (`list[int]`) : Sekumpulan kunci watermarking, satu untuk setiap kedalaman.

sampling_table_size (`int`) : Ukuran tabel sampling.

sampling_table_seed (`int`) : Random seed untuk menghasilkan tabel sampling.

context_history_size (`int`) : Ukuran tensor untuk melacak konteks yang telah dilihat.

device (`torch.device`) : Perangkat yang akan digunakan.

skip_first_ngram_calls (`bool`, *opsional*, default `False`) : Apakah akan melewati panggilan ngram pertama.

debug_mode (`bool`, *opsional*, default `False`) : Logits dimodifikasi menjadi seragam satu yang diperoleh sebelum modifikasi watermarking diterapkan. Ini untuk menguji implementasi.

Logits processor yang menerapkan teknik watermarking untuk model generasi teks. Kelas ini memfasilitasi penerapan SynthID text watermarking, yaitu metode untuk menyisipkan sinyal yang tidak dapat dipersepsikan ke dalam teks yang dihasilkan guna membantu mendeteksi konten sintetis. Kelas ini bekerja dengan cara memanipulasi probabilitas pemilihan token secara halus selama generasi teks, dengan cara yang dapat dipulihkan secara andal kemudian untuk verifikasi.

Fitur Utama:
* **Manajemen State:** Mempertahankan state internal untuk melacak urutan token dan menghasilkan kunci watermarking
secara dinamis.

* **Generasi Kunci:** Menghitung hash berdasarkan urutan token dan parameter watermarking untuk membuat kunci unik
untuk setiap posisi.

* **Penarikan Sampel Nilai-G:** Menggunakan tabel penarikan sampel yang telah dihitung sebelumnya untuk mengambil nilai watermarking (nilai-g) berdasarkan
kunci yang dihasilkan.

* **Penyesuaian Skor:** Menerapkan nilai g yang dihitung untuk memodifikasi probabilitas token selama proses generasi, dengan menanamkan
watermark.

* **Penanganan Pengulangan Konteks:** Mengandung logika untuk menghindari pemberian watermark pada token dalam konteks yang berulang,
menjaga naturalitas.

* **Masking Token EOS:** Mendukung masking token akhir kalimat untuk mencegah token tersebut disertakan dalam watermarking
perhitungan.

* **Fungsi Utilitas:** Menyediakan fungsi untuk menghitung nilai-g secara langsung, memeriksa pengulangan konteks, membuat
Mask token EOS, dan perkirakan nilai g rata-rata yang diharapkan.

Lihat paper di url: https://www.nature.com/articles/s41586-024-08025-4 untuk detail lebih lanjut.

Contoh:
```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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2749)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L238)

**Parameter:**

temperature (`float`) : Nilai float yang secara ketat positif, digunakan untuk memodulasi distribusi logits. Nilai yang lebih kecil dari `1` mengurangi keacakan (dan sebaliknya), dengan `0` setara dengan menggeser seluruh massa probabilitas ke token yang paling mungkin.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) untuk temperature (penykalaan eksponensial distribusi probabilitas output), yang secara efektif berarti dapat mengontrol keacakan token yang diprediksi. Sering digunakan bersama dengan [TopPLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TopPLogitsWarper) dan [TopKLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TopKLogitsWarper).

Pastikan bahwa `do_sample=True` disertakan dalam argumen `generate`, jika tidak nilai temperature tidak akan memiliki efek apa pun.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L300)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L627)

**Parameter:**

top_h (`float`) : Koefisien penskalaan untuk ambang batas berbasis entropi (`tau`). Harus berada dalam rentang `(0, 1]`.

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang difilter akan diset ke nilai float ini.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang mengimplementasikan Top-H sampling, sebuah metode decoding yang secara adaptif memilih subset token dengan probabilitas tinggi berdasarkan kendala entropi dan probabilitas kumulatif.

Metode ini secara dinamis menentukan berapa banyak token yang harus dipertahankan dengan menganalisis perbedaan entropi dari distribusi yang dipilih, sehingga menyeimbangkan eksplorasi dan eksploitasi. Hal ini memastikan bahwa teks yang dihasilkan tetap mempertahankan keragaman dan koherensi.

Referensi: Untuk detail, lihat *Top-H Decoding: Adapting the Creativity and Coherence with Bounded Entropy in Text Generation* (NeurIPS 2025): https://arxiv.org/abs/2509.02510

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L678)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : ID token input.

scores (`torch.Tensor` dengan bentuk `(batch_size, vocab_size)`) : Logit mentah dari model.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, vocab_size)`

Logit yang telah diproses di mana token tidak valid dimask dengan `-inf`.

Menyaring logits menggunakan sampling Top-H.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L571)

**Parameter:**

top_k (`int`) : Jumlah token kosakata dengan probabilitas tertinggi yang dipertahankan untuk top-k-filtering.

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang difilter akan diset ke nilai float ini.

min_tokens_to_keep (`int`, *opsional*, default 1) : Jumlah minimum token yang tidak dapat difilter.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang melakukan top-k, yaitu membatasi ke k elemen dengan probabilitas tertinggi. Sering digunakan bersama dengan [TemperatureLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TemperatureLogitsWarper) dan [TopPLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TopPLogitsWarper).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L618)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L502)

**Parameter:**

top_p (`float`) : Jika diatur ke < 1, hanya kumpulan token paling kecil dengan probabilitas tertinggi yang jumlah probabilitasnya mencapai `top_p` atau lebih tinggi yang dipertahankan untuk generasi.

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang difilter akan diset ke nilai float ini.

min_tokens_to_keep (`int`, *opsional*, default 1) : Jumlah minimum token yang tidak dapat difilter.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang melakukan top-p, yaitu membatasi ke token teratas yang jumlah probabilitasnya <= prob_cut_off. Sering digunakan bersama dengan [TemperatureLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TemperatureLogitsWarper) dan [TopKLogitsWarper](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.TopKLogitsWarper).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L555)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L809)

**Parameter:**

mass (`float`, *opsional*, default 0.9) : Nilai typical_p antara 0 dan 1 inklusif, default 0.9.

filter_value (`float`, *opsional*, default -inf) : Semua nilai yang difilter akan diset ke nilai float ini.

min_tokens_to_keep (`int`, *opsional*, default 1) : Jumlah minimum token yang tidak dapat difilter.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang melakukan decoding tipikal. Terinspirasi dari cara manusia menggunakan bahasa, komponen ini memprioritaskan token yang log probabilitasnya mendekati entropi dari distribusi probabilitas token. Artinya, token yang paling mungkin dapat saja dibuang dalam proses tersebut.

Lihat [Decoding Tipikal untuk Natural Language Generation](https://huggingface.co/papers/2202.00666) untuk informasi lebih lanjut.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L873)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2273)

**Parameter:**

guidance_scale (`float`) : Skala panduan untuk classifier free guidance (CFG). CFG diaktifkan dengan mengatur `guidance_scale != 1`. Skala panduan yang lebih tinggi mendorong model untuk menghasilkan sampel yang lebih erat kaitannya dengan prompt input, biasanya dengan mengorbankan kualitas yang lebih buruk. Nilai yang lebih kecil dari 1 memiliki efek sebaliknya, yaitu membuat negative prompt yang disediakan melalui negative_prompt_ids (jika ada) bertindak sebagai prompt positif.

model (`PreTrainedModel`) : Model yang menghitung skor tanpa syarat. Seharusnya sama dengan model yang menghitung skor bersyarat. Kedua model harus menggunakan tokenizer yang sama.

unconditional_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata untuk cabang tanpa syarat. Jika tidak disetel, akan secara default menggunakan token terakhir dari prompt.

unconditional_attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Attention mask untuk unconditional_ids.

use_cache (`bool`, *opsional*, default `True`) : Apakah akan meng-cache key/value selama forward pass prompt negatif.

Logits processor untuk Classifier-Free Guidance (CFG). Processor ini menghitung rata-rata berbobot dari skor logits kondisional prompt dan logits tak-kondisional (atau negatif) prompt, yang diparameterisasi oleh `guidance_scale`. Skor tak-kondisional dihitung secara internal dengan mem-prompt `model` menggunakan cabang `unconditional_ids`.

Lihat [makalahnya](https://huggingface.co/papers/2306.17806) untuk informasi lebih lanjut.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2379)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L1950)

**Parameter:**

generate_config (`GenerateConfig`) : Konfigurasi generate yang digunakan untuk menghasilkan output. Parameter berikut wajib diisi: eos_token_id (`int`, *opsional*, default 50257): id dari token *end-of-sequence*. no_timestamps_token_id (`int`, *opsional*, default 50363): id dari token `"<|notimestamps|>"`. max_initial_timestamp_index (`int`, *opsional*, default 1): Digunakan untuk mengatur nilai maksimum dari timestamp awal. Ini digunakan untuk mencegah model memprediksi timestamp yang terlalu jauh di masa depan.

begin_index (`int`) : Indeks token dari token pertama yang dihasilkan oleh model.

_detect_timestamp_from_logprob (`bool`, *opsional*) : Apakah timestamp dapat diprediksi dari logprobs atas semua timestamp.

[LogitsProcessor](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.LogitsProcessor) yang memodifikasi logits untuk generasi timestamp dalam transkripsi. Ketika token input mencapai ambang batas tertentu, prosesor mengatur skor menjadi negatif tak hingga. Prosesor memastikan bahwa token timestamp muncul berpasangan, dengan mem-mask logits yang akan merusak pola pasangan ini. Hal ini dilakukan untuk menjaga konsistensi dan struktur timestamp yang dihasilkan. Prosesor juga memastikan bahwa ketika probabilitas prediksi untuk mengambil salah satu token timestamp lebih besar daripada token non-timestamp mana pun, logits non-timestamp tersebut diatur menjadi negatif tak hingga. Hal ini dilakukan untuk memastikan generasi timestamp di atas token potensial lainnya.

Lihat [makalahnya](https://huggingface.co/papers/2212.04356) untuk informasi lebih lanjut.

Contoh:
``` 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2040)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2438)

**Parameter:**

vocab_size (`int`) : vocab_size dari tokenizer model. Digunakan untuk menghitung rasio token "hijau".

device (`str`) : Perangkat tempat model dialokasikan.

greenlist_ratio (`float`, opsional, *opsional*, default 0.25) : Rasio token "hijau" yang digunakan terhadap ukuran kosakata. Default 0.25.

bias (`float`, opsional, *opsional*, default 2.0) : Bias yang ditambahkan ke logits token "green" yang dipilih. Pertimbangkan untuk menurunkan `bias` jika kualitas generasi teks menurun. Nilai yang direkomendasikan berada dalam rentang [0,5, 2,0]. Default 2,0.

hashing_key (`int`, opsional, *opsional*, default 15485863) : Kunci yang digunakan untuk hashing. Jika Anda menerapkan watermark ini, kami menyarankan untuk menggunakan kunci privat lain. Defaultnya adalah 15485863 (bilangan prima ke-sejuta).

seeding_scheme (`str`, opsional, *opsional*, default `"lefthash"`) : Skema seeding yang digunakan untuk memilih token "green". Menerima nilai: - "lefthash" (default): pemilihan token "green" bergantung pada token terakhir (Algoritma 2 dari paper) - "selfhash": pemilihan token "green" bergantung pada token saat ini itu sendiri (Algoritma 3 dari paper) Kekurangan dari skema ini adalah mempertimbangkan semua token berikutnya yang mungkin dan dapat lebih lambat daripada "lefthash". Panjang konteks dari token sebelumnya yang digunakan dalam seeding. Panjang konteks yang lebih tinggi membuat watermarking lebih robust.

context_width (`int`, *opsional*, default 1) : Jumlah token sebelumnya yang digunakan saat mengatur seed.

Logits processor untuk watermarking teks yang dihasilkan. Prosesor ini memodifikasi skor output model dengan menambahkan bias kecil ke himpunan acak token "green" sebelum menghasilkan token berikutnya. Proses pemilihan token "green" bergantung pada `seeding_scheme` yang digunakan. Kode ini didasarkan pada [repo asli](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

Teks yang dihasilkan oleh `LogitsProcessor` ini dapat dideteksi menggunakan `WatermarkDetector`. Lihat [__call__()](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.WatermarkDetector.__call__) untuk detailnya,

Lihat [makalahnya](https://huggingface.co/papers/2306.04634) untuk informasi lebih lanjut.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/logits_process.py#L2560)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. [Apa itu input ID?](../glossary#input-ids)

scores (`torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa. Ini dapat berupa logits untuk setiap kosakata saat tidak menggunakan beam search, atau log softmax untuk setiap token kosakata saat menggunakan beam search.

**Mengembalikan:** `torch.Tensor` dengan bentuk `(batch_size, config.vocab_size)`

Skor prediksi yang telah diproses.

## StoppingCriteria[[transformers.StoppingCriteria]]

[StoppingCriteria](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.StoppingCriteria) dapat digunakan untuk mengubah kapan generasi dihentikan (selain token EOS). Harap dicatat bahwa ini hanya tersedia untuk implementasi PyTorch kami.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L48)

Kelas basis abstrak untuk semua kriteria penghentian yang dapat diterapkan selama generasi.

Jika kriteria penghentian Anda bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L55)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Skor prediksi dari kepala pemodelan bahasa, berupa tuple dengan satu tensor per langkah generasi, masing-masing dengan bentuk `(batch_size, config.vocab_size)`. Skor ini dapat berupa skor untuk setiap token kosakata sebelum SoftMax atau skor untuk setiap token kosakata setelah SoftMax. Jika kriteria penghentian ini bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`, jika tidak `None` akan diteruskan.

kwargs (`dict[str, Any]`, *opsional*) : kwargs kriteria penghentian tambahan.

**Mengembalikan:** `torch.BoolTensor`. (`torch.BoolTensor` dengan bentuk `(batch_size, 1)`)

`True` menunjukkan bahwa kita menghentikan generasi untuk baris tertentu. `False` menunjukkan bahwa kita harus melanjutkan.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L610)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L611)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Skor prediksi dari kepala pemodelan bahasa, berupa tuple dengan satu tensor per langkah generasi, masing-masing dengan bentuk `(batch_size, config.vocab_size)`. Skor ini dapat berupa skor untuk setiap token kosakata sebelum SoftMax atau skor untuk setiap token kosakata setelah SoftMax. Jika kriteria penghentian ini bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`, jika tidak `None` akan diteruskan.

kwargs (`dict[str, Any]`, *opsional*) : kwargs kriteria penghentian tambahan.

**Mengembalikan:** `torch.BoolTensor`. (`torch.BoolTensor` dengan bentuk `(batch_size, 1)`)

`True` menunjukkan bahwa kita menghentikan generasi untuk baris tertentu. `False` menunjukkan bahwa kita harus melanjutkan.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L60)

**Parameter:**

max_length (`int`) : Panjang maksimum yang dapat dimiliki urutan output dalam jumlah token.

max_position_embeddings (`int`, *opsional*) : Panjang maksimum model, seperti yang ditentukan oleh atribut `config.max_position_embeddings` model.

Kelas ini dapat digunakan untuk menghentikan generasi kapan pun jumlah token yang dihasilkan secara keseluruhan melebihi `max_length`. Perlu diingat, untuk jenis transformers yang hanya memiliki decoder, jumlah ini akan mencakup token prompt awal.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L76)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Skor prediksi dari kepala pemodelan bahasa, berupa tuple dengan satu tensor per langkah generasi, masing-masing dengan bentuk `(batch_size, config.vocab_size)`. Skor ini dapat berupa skor untuk setiap token kosakata sebelum SoftMax atau skor untuk setiap token kosakata setelah SoftMax. Jika kriteria penghentian ini bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`, jika tidak `None` akan diteruskan.

kwargs (`dict[str, Any]`, *opsional*) : kwargs kriteria penghentian tambahan.

**Mengembalikan:** `torch.BoolTensor`. (`torch.BoolTensor` dengan bentuk `(batch_size, 1)`)

`True` menunjukkan bahwa kita menghentikan generasi untuk baris tertentu. `False` menunjukkan bahwa kita harus melanjutkan.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L89)

**Parameter:**

max_time (`float`) : Waktu maksimum yang diizinkan dalam detik untuk proses generasi.

initial_timestamp (`float`, *opsional*, default `time.time()`) : Awal dari waktu yang diizinkan untuk generasi.

Kelas ini dapat digunakan untuk menghentikan generasi kapan pun durasi total generasi melebihi batas waktu tertentu. Secara default, waktu mulai dihitung saat Anda menginisialisasi fungsi ini. Anda dapat menimpa perilaku ini dengan meneruskan `initial_timestamp`.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L106)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Skor prediksi dari kepala pemodelan bahasa, berupa tuple dengan satu tensor per langkah generasi, masing-masing dengan bentuk `(batch_size, config.vocab_size)`. Skor ini dapat berupa skor untuk setiap token kosakata sebelum SoftMax atau skor untuk setiap token kosakata setelah SoftMax. Jika kriteria penghentian ini bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`, jika tidak `None` akan diteruskan.

kwargs (`dict[str, Any]`, *opsional*) : kwargs kriteria penghentian tambahan.

**Mengembalikan:** `torch.BoolTensor`. (`torch.BoolTensor` dengan bentuk `(batch_size, 1)`)

`True` menunjukkan bahwa kita menghentikan generasi untuk baris tertentu. `False` menunjukkan bahwa kita harus melanjutkan.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L112)

**Parameter:**

tokenizer (`PreTrainedTokenizer`) : tokenizer yang terkait dengan model (diperlukan untuk mengekstrak vocab dan melakukan tokenisasi pada sekuens terminasi)

stop_strings (`Union[str, list[str]]`) : Daftar string yang harus mengakhiri generasi. Jika sebuah string diberikan, string tersebut akan diperlakukan seperti daftar dengan satu elemen.

Kelas ini dapat digunakan untuk menghentikan generasi kapan pun sekuens string tertentu dihasilkan. Kelas ini memproses string bersama dengan vocab tokenizer untuk menemukan posisi di mana token dapat secara valid melengkapi string stop.

Generation dihentikan segera setelah sebuah token yang melengkapi salah satu dari string stop dihasilkan. Kami ingin menangkap setiap kasus di mana string stop hadir dalam output yang didekode, yang berarti kami juga harus menangkap kasus dengan "overhang" di salah satu atau kedua ujungnya. Untuk membuatnya lebih konkret, untuk string stop "stop", urutan token berikut akan memicu kecocokan:

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

Perhatikan bahwa kecocokan hanya akan dipicu jika string stop berada di akhir urutan yang dihasilkan. Dengan kata lain, urutan-urutan berikut tidak akan memicu kecocokan:

- ["stop", "at"]
- ["st", "op", "at"]
- ["st", "opera", "tion"]

Alasan mengapa ini tidak cocok adalah karena string stop tidak tumpang tindih dengan token terakhir. Jika Anda dapat menghapus satu atau lebih token dari akhir urutan tanpa merusak string stop, maka kriteria ini tidak akan cocok dengan string stop tersebut. Hal ini memang dirancang demikian; karena pemeriksaan ini dijalankan setelah setiap token dihasilkan, kita tidak akan melewatkan string stop yang valid jika satu di antaranya dihasilkan, tetapi kita tidak ingin menghentikan generasi hanya karena string stop ada di suatu tempat dalam input_ids masa lalu.

Lalu, bagaimana pencocokan sebenarnya dilakukan? Kami melakukannya dengan cara yang cukup membingungkan, karena kami ingin seluruh proses pencocokan dapat dikompilasi dengan Torch atau XLA, yang berarti kami tidak dapat menggunakan metode string standar. Namun, dengan sedikit usaha, pencocokan string dapat dilakukan dengan operasi tensor murni. Kami akan mulai dengan menjelaskan algoritma yang kami gunakan dengan operasi string standar, dan di akhir kami akan menjelaskan bagaimana hal ini dikonversi menjadi operasi tensor murni.

Kunci dari algoritma ini adalah sebuah pengamatan: karena string stop harus tumpang tindih dengan akhir dari urutan token, kita dapat memulai dari akhir urutan dan bekerja mundur. Secara spesifik, kita memeriksa apakah ada tumpang tindih antara awal dari token terakhir dan akhir dari stop_string, atau dengan kata lain, stop_string[-i:] == token[:i] untuk beberapa i > 0. Jika Anda melihat contoh positif di atas, Anda akan melihat bahwa token terakhir di semua contoh tersebut memenuhi sifat ini:

- ["st", "op"] (overlap adalah "op", panjang overlap == 2)
- ["stop"]  (overlap adalah "stop", panjang overlap == 4)
- ["st", "opera"] (tumpang tindih adalah "op", panjang tumpang tindih == 2)
- ["sto", "pper"] (tumpang tindih adalah "p", panjang tumpang tindih == 1)
- ["las", "topper"] (overlap adalah "top", panjang overlap == 3)
- ["s", "to", "pped"] (tumpang tindih adalah "p", panjang tumpang tindih == 1)

Mustahil untuk menyusun urutan yang cocok yang tidak memiliki sifat ini (silakan verifikasi sendiri). Namun, meskipun tumpang tindih antara awal token terakhir dan akhir string stop diperlukan untuk kecocokan, hal itu tidak cukup. Kita juga perlu memeriksa bahwa sisa urutan token konsisten dengan string stop.

Bagaimana cara melakukannya? Mari kita gunakan ["s", "to", "pped"] sebagai contoh. Kita tahu bahwa token terakhir, "pped", memiliki tumpang tindih 1 dengan string stop, "stop". Kemudian kita kembali ke token sebelumnya, "to". Karena kita sudah mencocokkan 1 karakter dari string stop, sisa yang perlu diperiksa adalah "sto". Kita periksa bahwa token berikutnya "to" cocok dengan akhir dari sisa tersebut, dan memang demikian. Sekarang kita telah mencocokkan 3 karakter dari string stop, dan sisa yang harus dicocokkan adalah "s". Kita kembali ke token sebelumnya lagi, yang juga "s". Ini adalah kecocokan, sehingga kita telah mencocokkan seluruh string stop.

Bagaimana cara kerjanya ketika token melewati awal string stop? Mari kita pertimbangkan contoh ["las", "topper"]. Token terakhir, "topper", memiliki tumpang tindih 3 dengan string stop, "stop". Oleh karena itu, sisa string stop yang harus dicocokkan adalah "s". Kita kembali ke token sebelumnya, "las". Karena sisa yang harus dicocokkan hanya "s", dengan panjang 1, kita hanya mempertimbangkan 1 karakter terakhir dari token tersebut, yaitu "s". Ini cocok dengan string stop, sehingga seluruh string berhasil dicocokkan.

Bagaimana kita menghitung kecocokan ini dengan operasi tensor? Caranya sederhana: kita menghitung secara efisien informasi yang diperlukan untuk semua token! Untuk setiap token, kita menghitung:
- Tumpang tindihnya dengan akhir string stop, jika ada
- Posisi di dalam string stop tempat token cocok, termasuk kecocokan yang melampaui awal string.
- Panjang total dari token

Sebagai contoh, untuk token "pped", kita akan menghitung end overlap sebesar 1, tidak ada posisi pencocokan internal, dan panjang 4. Untuk token "to", kita akan menghitung tidak ada end overlap, satu posisi pencocokan internal pada posisi 1 (dihitung dari akhir), dan panjang 2. Untuk token "s", kita akan menghitung tidak ada end overlap, satu posisi pencocokan internal pada posisi 3 (kembali dihitung dari akhir), dan panjang 1.

Selama kita memiliki informasi ini, kita dapat menjalankan algoritma di atas tanpa operasi perbandingan string. Kita cukup melakukan langkah-langkah berikut:
- Periksa apakah token terakhir memiliki akhir yang tumpang tindih dengan string awal
- Lanjutkan mundur, sambil melacak berapa banyak dari string stop yang telah cocok sejauh ini
- Pada setiap titik, periksa apakah token berikutnya memiliki posisi saat ini sebagai salah satu posisinya yang valid
- Lanjutkan hingga salah satu kecocokan gagal, atau hingga seluruh string stop cocok sepenuhnya

Sekali lagi, pertimbangkan ["s", "to", "pped"] sebagai contoh. "pped" memiliki tumpang tindih akhir sebesar 1, sehingga kita dapat memulai pencocokan. Kita telah mencocokkan 1 karakter sejauh ini, jadi kita periksa apakah token berikutnya "to" memiliki 1 sebagai posisi yang valid (kembali, dihitung dari akhir). Ya, jadi kita menambahkan panjang "to" ke pelacak posisi kita. Kita telah mencocokkan 3 karakter, jadi kita periksa apakah token berikutnya "s" memiliki 3 sebagai posisi yang valid. Ya, jadi kita menambahkan panjangnya ke pelacak posisi. Pelacak posisi sekarang adalah 4, yang merupakan panjang string stop. Kita telah mencocokkan seluruh string stop.

Pada kasus kedua, ["las", "topper"], "topper" memiliki tumpang tindih akhir sebesar 3, sehingga kita dapat memulai pencocokan. Kita telah mencocokkan 3 karakter sejauh ini, jadi kita periksa apakah token berikutnya "las" memiliki 3 sebagai posisi yang valid. Ya, karena kita mengizinkan token untuk mencocokkan posisi yang melampaui awal string stop. Kita menambahkan panjangnya ke pelacak posisi. Pelacak posisi sekarang menjadi 6, yang lebih besar dari panjang string stop! Namun, jangan panik - ini juga dihitung sebagai pencocokan string stop. Kita telah mencocokkan seluruh string stop.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L475)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Skor prediksi dari kepala pemodelan bahasa, berupa tuple dengan satu tensor per langkah generasi, masing-masing dengan bentuk `(batch_size, config.vocab_size)`. Skor ini dapat berupa skor untuk setiap token kosakata sebelum SoftMax atau skor untuk setiap token kosakata setelah SoftMax. Jika kriteria penghentian ini bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`, jika tidak `None` akan diteruskan.

kwargs (`dict[str, Any]`, *opsional*) : kwargs kriteria penghentian tambahan.

**Mengembalikan:** `torch.BoolTensor`. (`torch.BoolTensor` dengan bentuk `(batch_size, 1)`)

`True` menunjukkan bahwa kita menghentikan generasi untuk baris tertentu. `False` menunjukkan bahwa kita harus melanjutkan.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L537)

**Parameter:**

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

Kelas ini dapat digunakan untuk menghentikan generasi kapan pun token "end-of-sequence" dihasilkan. Secara default, kelas ini menggunakan `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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/stopping_criteria.py#L554)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token dari urutan input dalam kosakata. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input ID?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Skor prediksi dari kepala pemodelan bahasa, berupa tuple dengan satu tensor per langkah generasi, masing-masing dengan bentuk `(batch_size, config.vocab_size)`. Skor ini dapat berupa skor untuk setiap token kosakata sebelum SoftMax atau skor untuk setiap token kosakata setelah SoftMax. Jika kriteria penghentian ini bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`, jika tidak `None` akan diteruskan.

new_token_length (`int`, *opsional*, default `1`) : Jumlah token yang akan diperiksa untuk kriteria. `new_token_length` token terbaru pada setiap item batch akan diperiksa.

kwargs (`dict[str, Any]`, *opsional*) : kwargs kriteria penghentian tambahan.

**Mengembalikan:** `torch.BoolTensor`. (`torch.BoolTensor` dengan bentuk `(batch_size, 1)`)

`True` menunjukkan bahwa kita menghentikan generasi untuk baris tertentu. `False` menunjukkan bahwa kita harus melanjutkan.

## Streamers[[transformers.TextStreamer]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L41)

**Parameter:**

tokenizer (`AutoTokenizer`) : tokenizer yang digunakan untuk mendekode token.

skip_prompt (`bool`, *opsional*, default `False`) : Apakah akan melewati prompt ke `.generate()` atau tidak. Berguna, misalnya, untuk chatbot.

decode_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke metode `decode` tokenizer.

Streamer teks sederhana yang mencetak token ke stdout segera setelah kata utuh terbentuk.

Contoh:

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

#### akhir[[transformers.TextStreamer.end]]

```python
end()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L113)

Membuang sisa cache dan mencetak baris baru ke stdout.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L127)

Mencetak teks baru ke stdout. Jika stream berakhir, juga mencetak baris baru.

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

```python
put(value)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L79)

Menerima token, mendekodekannya, dan mencetaknya ke stdout segera setelah membentuk kata utuh.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L156)

**Parameter:**

tokenizer (`AutoTokenizer`) : tokenizer yang digunakan untuk mendekode token.

skip_prompt (`bool`, *opsional*, default `False`) : Apakah akan melewati prompt ke `.generate()` atau tidak. Berguna, misalnya, untuk chatbot.

timeout (`float`, *opsional*) : Timeout untuk antrean teks. Jika `None`, antrean akan memblokir secara tak terbatas. Berguna untuk menangani pengecualian di `.generate()`, ketika dipanggil di thread terpisah.

decode_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke metode `decode` tokenizer.

Streamer yang menyimpan teks siap cetak dalam antrean, untuk digunakan oleh aplikasi hilir sebagai iterator. Ini berguna untuk aplikasi yang diuntungkan dari akses ke teks yang dihasilkan secara non-blocking (misalnya dalam demo Gradio interaktif).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L208)

Letakkan teks baru dalam antrean. Jika aliran sedang berakhir, letakkan juga sinyal berhenti dalam antrean.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L225)

**Parameter:**

tokenizer (`AutoTokenizer`) : tokenizer yang digunakan untuk mendekode token.

skip_prompt (`bool`, *opsional*, default `False`) : Apakah akan melewati prompt ke `.generate()` atau tidak. Berguna, misalnya, untuk chatbot.

timeout (`float`, *opsional*) : Timeout untuk antrean teks. Jika `None`, antrean akan memblokir secara tak terbatas. Berguna untuk menangani pengecualian di `.generate()`, ketika dipanggil di thread terpisah.

decode_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke metode `decode` tokenizer.

**Mengangkat:** ``TimeoutError``

- ``TimeoutError`` -- Jika waktu pembuatan token melebihi nilai timeout.

Streamer yang menyimpan teks siap cetak dalam antrean, untuk digunakan oleh aplikasi hilir sebagai iterasi asinkron. Ini berguna untuk aplikasi yang diuntungkan dari akses ke teks yang dihasilkan secara asinkron (misalnya dalam demo Gradio interaktif).

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L285)

Letakkan teks baru dalam antrean. Jika aliran sedang berakhir, letakkan juga sinyal berhenti dalam antrean.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L303)

**Parameter:**

tokenizer (`AutoTokenizer`) : tokenizer yang digunakan untuk mendekode token.

skip_prompt (`bool`, *opsional*, default `False`) : Apakah akan melewati prompt ke `.generate()` atau tidak. Berguna, misalnya, untuk chatbot.

sleep_time (`float`, *opsional*) : Waktu tidur antara draft difusi, yang mungkin berguna untuk memvisualisasikan output antara.

decode_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke metode `decode` tokenizer.

Streamer yang mencetak keluaran difusi teks. Langkah-langkah difusi antara (draf) bersifat sementara dan ditimpa oleh draf berikutnya, serta dihapus saat teks yang dikonfirmasi dicetak.

Jika Anda menjalankan di lingkungan seperti tmux, teks draf mungkin gagal menimpa dirinya sendiri.

Contoh:

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

#### akhir[[transformers.TextDiffusionStreamer.end]]

```python
end()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L392)

Membuang sisa cache dan mencetak baris baru.

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

```python
put(value)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L387)

Menerima token yang dikonfirmasi, mengosongkan draf, dan mencetaknya secara permanen.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/streamers.py#L365)

Menerima urutan lengkap token draft, mendekodekannya, dan mencetaknya dalam warna kuning. Menimpa draft sebelumnya.

## Cache[[transformers.CacheLayerMixin]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L23)

Kelas abstrak dasar untuk cache satu lapisan.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L52)

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

```python
get_seq_length()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L60)

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L57)

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

```python
get_max_length()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L63)

Mengembalikan panjang sekuens maksimum yang dapat ditampung oleh layer. Nilai `-1` berarti tidak ada maksimum, atau maksimum yang tidak terdefinisi, misalnya layer attention dinamis yang tumbuh tanpa batas atau layer attention linear yang tidak memiliki dimensi panjang sekuens.

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

```python
reset()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L84)

Mengatur ulang nilai cache sambil mempertahankan objek

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

```python
reorder_cache(beam_idx: LongTensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L97)

Mengurutkan ulang cache layer ini untuk beam search.

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

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L49)

#### transformers.DynamicLayer[[transformers.DynamicLayer]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L104)

Lapisan cache yang tumbuh secara dinamis seiring dengan semakin banyaknya token yang dihasilkan. Ini adalah default untuk model generatif. Lapisan ini menyimpan keadaan key dan value sebagai tensor dengan bentuk `[batch_size, num_heads, seq_len, head_dim]`.

#### update[[transformers.DynamicLayer.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L119)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

**Mengembalikan:** tuple[`torch.Tensor`, `torch.Tensor`]

Status kunci dan nilai.

Perbarui cache kunci dan nilai secara in-place, lalu kembalikan keadaan kunci dan nilai yang diperlukan.

#### lazy_initialization[[transformers.DynamicLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L113)

#### crop[[transformers.DynamicLayer.crop]]

```python
crop(tokens_to_remove: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L164)

Hapus token `tokens_to_remove` dari lapisan cache saat ini.

#### batch_repeat_interleave[[transformers.DynamicLayer.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L183)

Ulangi cache sebanyak `repeats` kali pada dimensi batch.

#### batch_select_indices[[transformers.DynamicLayer.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L189)

Hanya simpan `indices` pada dimensi batch dari cache.

#### transformers.StaticLayer[[transformers.StaticLayer]]

```python
transformers.StaticLayer(max_cache_len: int, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L403)

**Parameter:**

max_cache_len (`int`) : Jumlah maksimum token yang dapat disimpan, digunakan untuk prealokasi tensor.

Lapisan cache statis yang menyimpan keadaan kunci dan nilai sebagai tensor statis dengan bentuk `[batch_size, num_heads, max_cache_len, head_dim]`. Lapisan ini mengalokasikan tensor pendukung penuh secara malas, lalu memodifikasinya secara in-place. Dibangun untuk mendukung `torch.compile`.

#### update[[transformers.StaticLayer.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L461)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

**Mengembalikan:** tuple[`torch.Tensor`, `torch.Tensor`]

Status kunci dan nilai.

Perbarui cache kunci dan nilai secara in-place, lalu kembalikan keadaan kunci dan nilai yang diperlukan.

#### lazy_initialization[[transformers.StaticLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L423)

Inisialisasi lazy untuk tensor keys dan values. Hal ini memungkinkan untuk mendapatkan semua properti (dtype, device, num_heads dalam kasus TP, dst.) langsung pada saat runtime, yang sangat praktis karena menghindari perpindahan device, dtype, dan sebagainya di kemudian hari untuk setiap `update` (yang juga dapat merusak alamat dynamo statis).

Jika ini tidak diinginkan, Anda dapat memanggil `early_initialization(...)` langsung pada Cache, yang akan memanggil fungsi ini lebih awal (hal ini diperlukan untuk `torch.export`, misalnya). Hal ini juga diperlukan setiap kali prefill itu sendiri berada di dalam region yang dikompilasi (misalnya dengan chunked prefill).

#### transformers.StaticSlidingWindowLayer[[transformers.StaticSlidingWindowLayer]]

```python
transformers.StaticSlidingWindowLayer(max_cache_len: int, sliding_window: int, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L510)

**Parameter:**

max_cache_len (`int`) : Jumlah maksimum token yang dapat disimpan, digunakan untuk prealokasi tensor.

sliding_window (`int`) : Ukuran dari sliding window.

Lapisan cache statis yang menyimpan keadaan kunci dan nilai sebagai tensor statis dengan bentuk `[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]`. Lapisan ini mengalokasikan tensor pendukung penuh secara malas, lalu memodifikasinya secara in-place. Dibangun untuk mendukung `torch.compile`.

#### update[[transformers.StaticSlidingWindowLayer.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L531)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

**Mengembalikan:** tuple[`torch.Tensor`, `torch.Tensor`]

Status kunci dan nilai.

Perbarui cache kunci dan nilai secara in-place, lalu kembalikan keadaan kunci dan nilai yang diperlukan.

#### lazy_initialization[[transformers.StaticSlidingWindowLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L423)

Inisialisasi lazy untuk tensor keys dan values. Hal ini memungkinkan untuk mendapatkan semua properti (dtype, device, num_heads dalam kasus TP, dst.) langsung pada saat runtime, yang sangat praktis karena menghindari perpindahan device, dtype, dan sebagainya di kemudian hari untuk setiap `update` (yang juga dapat merusak alamat dynamo statis).

Jika ini tidak diinginkan, Anda dapat memanggil `early_initialization(...)` langsung pada Cache, yang akan memanggil fungsi ini lebih awal (hal ini diperlukan untuk `torch.export`, misalnya). Hal ini juga diperlukan setiap kali prefill itu sendiri berada di dalam region yang dikompilasi (misalnya dengan chunked prefill).

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L854)

#### update[[transformers.QuantoQuantizedLayer.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L781)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

**Mengembalikan:** tuple[`torch.Tensor`, `torch.Tensor`]

Status kunci dan nilai.

Perbarui cache kunci dan nilai secara in-place, lalu kembalikan keadaan kunci dan nilai yang diperlukan.

#### lazy_initialization[[transformers.QuantoQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L909)

#### update[[transformers.HQQQuantizedLayer.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L781)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

**Mengembalikan:** tuple[`torch.Tensor`, `torch.Tensor`]

Status kunci dan nilai.

Perbarui cache kunci dan nilai secara in-place, lalu kembalikan keadaan kunci dan nilai yang diperlukan.

#### lazy_initialization[[transformers.HQQQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L113)

#### transformers.Fp8QuantizedLayer[[transformers.Fp8QuantizedLayer]]

```python
transformers.Fp8QuantizedLayer()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L966)

Lapisan terkuantisasi yang menyimpan keadaan kunci dan nilai dalam format floating point 8-bit. Skala per tensor dibekukan setelah `update` pertama, sehingga keadaan baru ditambahkan apa adanya: tanpa cache residual, tanpa re-kuantisasi.

Varian yang lebih granular seharusnya berada di sini, bukan di bawah `QuantizedLayer`, karena pengelompokan sepanjang dimensi head menjaga agar state tetap dapat ditambahkan dan hanya mengubah scale yang disimpan menjadi tensor.

#### update[[transformers.Fp8QuantizedLayer.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L994)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

**Mengembalikan:** tuple[`torch.Tensor`, `torch.Tensor`]

Status kunci dan nilai.

Perbarui cache kunci dan nilai secara in-place, lalu kembalikan keadaan kunci dan nilai yang diperlukan.

#### lazy_initialization[[transformers.Fp8QuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1453)

**Parameter:**

layers (`Optional`, *optional*) : Daftar `CacheLayerMixin` atau `LinearAttentionCacheLayerMixin` yang telah dibuat sebelumnya. Jika diabaikan (`None`), maka `layer_class_to_replicate` akan digunakan.

layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`, *opsional*) : Hanya digunakan jika `layers` diabaikan (`None`), di mana tipe ini akan menjadi kelas dasar untuk setiap layer, dan layer akan ditambahkan secara lazy begitu `update` dipanggil dengan `layer_idx` yang lebih besar dari daftar layer saat ini.

offloading (`bool`, *opsional*, default `False`) : Apakah akan melakukan offloading layer ke `cpu` untuk menghemat memori GPU.

offload_only_non_sliding (`bool`, *opsional*, default `True`) : Jika `offloading` adalah `True`, parameter ini menentukan apakah hanya lapisan non-sliding yang akan di-offload (karena biasanya lapisan sliding berukuran kecil, sehingga tidak perlu di-offload, dan melewatinya lebih cepat).

`Cache` pada dasarnya adalah daftar objek `CacheLayerMixin`, satu untuk setiap lapisan model. Ia berfungsi sebagai wadah untuk Cache dari setiap lapisan.

#### update[[transformers.Cache.update]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1540)

**Parameter:**

key_states (`torch.Tensor`) : Key states baru untuk di-cache.

value_states (`torch.Tensor`) : Nilai baru yang akan disimpan ke cache.

layer_idx (`int`) : Indeks dari layer untuk meng-cache state-nya.

**Mengembalikan:**

Tuple yang berisi state kunci dan nilai yang diperbarui.

Memperbarui cache dengan `key_states` dan `value_states` baru untuk lapisan `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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1669)

Inisialisasi semua layer di awal (jika tidak, inisialisasi akan dilakukan secara lazy pada pemanggilan `update` pertama). Hal ini berguna untuk resep `export` kami, karena `export` membutuhkan semuanya di awal.

#### get_seq_length[[transformers.Cache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1706)

Mengembalikan panjang urutan cache untuk lapisan yang diberikan.

#### get_mask_sizes[[transformers.Cache.get_mask_sizes]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1776)

Kembalikan tuple (kv_length, kv_offset) yang sesuai dengan panjang dan offset yang akan dikembalikan untuk layer tertentu pada `layer_idx`. Masker kemudian disiapkan sesuai dengan panjang (kv_length, kv_offset) dan pola yang diberikan untuk setiap layer.

#### get_max_length[[transformers.Cache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1730)

Mengembalikan panjang maksimum cache. Jika `layer_idx` tidak diberikan (default), ini mengembalikan nilai maksimum di semua lapisan. Sebaliknya, mengembalikan nilai maksimum yang didukung untuk lapisan yang diberikan. Nilai `-1` berarti tidak ada maksimum, atau maksimum tidak terdefinisi, misalnya untuk lapisan attention dinamis yang dapat tumbuh tanpa batas, atau lapisan attention linear yang tidak memiliki dimensi panjang sekuens.

#### reset[[transformers.Cache.reset]]

```python
reset()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1813)

Atur ulang tensor semua lapisan secara rekursif

#### reorder_cache[[transformers.Cache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1818)

Urutkan ulang cache untuk beam search

#### crop[[transformers.Cache.crop]]

```python
crop(tokens_to_remove: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1823)

Hapus `tokens_to_remove` token dari Cache saat ini. Untuk lapisan yang tidak perlu menyimpan semua state masa lalu di memori, seperti lapisan sliding window atau lapisan linear attention, hal ini juga akan membatasi ukuran state yang di-cache kembali ke ukuran kerja minimalnya. Artinya, `crop(0)` tidak selalu menjadi no-op, karena masih dapat menghapus state yang tidak berguna (yaitu state yang tidak diperlukan untuk `forward` berikutnya) dari Cache.

#### batch_repeat_interleave[[transformers.Cache.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1833)

Ulangi dan selang-selingkan cache

#### batch_select_indices[[transformers.Cache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1838)

Pilih indeks dari 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L1960)

**Parameter:**

ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`, *opsional*) : Awalnya ditambahkan untuk kompatibilitas dengan `torch.distributed` (DDP). Singkatnya, ini adalah `map(gather_map, zip(*caches))`, yaitu setiap item dalam iterable berisi state kunci dan nilai untuk sebuah layer yang dikumpulkan antar replika oleh torch.distributed (shape=[global batch size, num_heads, seq_len, head_dim]). Catatan: argumen ini juga harus menjadi argumen pertama agar berfungsi dengan benar

config (`PreTrainedConfig`, *opsional*) : Konfigurasi model yang akan menggunakan Cache ini. Jika diberikan, konfigurasi ini akan digunakan untuk memeriksa struktur lapisan sliding atau hybrid, sehingga sangat mengurangi kebutuhan memori tensor yang di-cache menjadi `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

offloading (`bool`, *opsional*, default `False`) : Apakah akan melakukan offloading layer ke `cpu` untuk menghemat memori GPU.

offload_only_non_sliding (`bool`, *opsional*, default `False`) : Jika `offloading` adalah `True`, parameter ini menentukan apakah hanya lapisan non-sliding yang akan di-offload (karena biasanya lapisan sliding berukuran kecil, sehingga tidak perlu di-offload, dan melewatinya lebih cepat).

Cache yang tumbuh secara dinamis seiring dengan semakin banyaknya token yang dihasilkan. Ini adalah default untuk model generatif. Cache ini menyimpan state key dan value sebagai daftar `CacheLayer`, satu untuk setiap layer. Bentuk (shape) yang diharapkan untuk setiap tensor dalam `CacheLayer` adalah `[batch_size, num_heads, seq_len, head_dim]`. Jika config diberikan, cache ini juga akan memeriksa struktur cache sliding atau hybrid, yang secara signifikan mengurangi kebutuhan memori tensor yang di-cache menjadi `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

Lihat `Cache` untuk detail tentang metode umum yang diimplementasikan oleh semua kelas cache.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2056)

**Parameter:**

config (`PreTrainedConfig`) : Konfigurasi model yang akan menggunakan Cache ini. Konfigurasi ini akan digunakan untuk memeriksa struktur lapisan sliding atau hybrid, serta menginisialisasi setiap lapisan secara sesuai.

max_cache_len (`int`) : Jumlah maksimum token yang harus disimpan oleh Cache ini.

offloading (`bool`, *opsional*, default `False`) : Apakah akan melakukan offloading layer ke `cpu` untuk menghemat memori GPU.

offload_only_non_sliding (`bool`, *opsional*, default `True`) : Jika `offloading` adalah `True`, parameter ini menentukan apakah hanya lapisan non-sliding yang akan di-offload (karena biasanya lapisan sliding berukuran kecil, sehingga tidak perlu di-offload, dan melewatinya lebih cepat).

Kelas Static Cache untuk digunakan dengan `torch.compile(model)` dan `torch.export()`. Kelas ini akan memeriksa `config` untuk struktur cache hybrid yang potensial, dan menginisialisasi setiap layer sesuai dengan itu.

Lihat `Cache` untuk detail tentang metode umum yang diimplementasikan oleh semua kelas cache.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2113)

**Parameter:**

backend (`str`) : Backend kuantisasi yang akan digunakan. Salah satu dari `("quanto", "hqq", "fp8")`.

config (`PreTrainedConfig`) : Konfigurasi model yang akan menggunakan Cache ini.

nbits (`int`, *opsional*, default 4) : Jumlah bit untuk kuantisasi.

axis_key (`int`, *opsional*, default 0) : Sumbu yang digunakan untuk mengkuantisasi kunci.

axis_value (`int`, *opsional*, default 0) : Sumbu yang digunakan untuk mengkuantisasi nilai.

q_group_size (`int`, *opsional*, default 64) : Kuantisasi dilakukan per kanal berdasarkan `q_group_size` yang ditetapkan untuk kedua kunci dan nilai.

residual_length (`int`, *opsional*, default 128) : Kapasitas maksimum untuk cache presisi asli.

Cache kuantizer yang serupa dengan yang dijelaskan dalam [KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache paper](https://huggingface.co/papers/2402.02750). Cache ini memungkinkan model untuk menghasilkan panjang sekuens yang lebih panjang tanpa mengalokasikan terlalu banyak memori untuk key dan value dengan menerapkan kuantisasi. Cache memiliki dua jenis penyimpanan, satu untuk presisi asli dan satu untuk cache terkuantisasi. Sebuah `residual length` ditetapkan sebagai kapasitas maksimum untuk cache presisi asli. Ketika panjang melampaui kapasitas maksimum, cache presisi asli dibuang dan dipindahkan ke cache terkuantisasi. Kuantisasi dilakukan per-channel dengan `q_group_size` yang ditetapkan untuk key dan value, berbeda dengan yang dijelaskan dalam paper tersebut.

Lihat `Cache` untuk detail tentang metode umum yang diimplementasikan oleh semua kelas cache.

Lima argumen terakhir mengonfigurasi backend integer grup-ke-grup. Backend `fp8` melakukan kuantisasi per-tensor dan menolak argumen tersebut.

#### transformers.EncoderDecoderCache[[transformers.EncoderDecoderCache]]

```python
transformers.EncoderDecoderCache(*caches)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2199)

**Parameter:**

caches (`Iterable`) : Biasanya iterable dengan panjang 2, berisi 2 objek `Cache`, yang pertama untuk self-attention dan yang kedua untuk cross-attention. Secara opsional, juga dapat berupa iterable dengan panjang 1, berisi `tuple[tuple[torch.Tensor]]` (biasanya digunakan untuk kompatibilitas dengan torch dp dan ddp).

Kelas abstrak dasar untuk semua cache encoder-decoder. Dapat digunakan untuk menyimpan kombinasi cache self-attention dan cross-attention.

Lihat `Cache` untuk detail tentang metode umum yang diimplementasikan oleh semua kelas cache.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2316)

Ulangi cache sebanyak `repeats` kali pada dimensi batch. Digunakan dalam pencarian kontras (di Hub).

#### batch_select_indices[[transformers.EncoderDecoderCache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2322)

Hanya simpan `indices` pada dimensi batch dari cache. Digunakan dalam pencarian kontras (di Hub).

#### crop[[transformers.EncoderDecoderCache.crop]]

```python
crop(tokens_to_remove: int)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2309)

Hapus token `tokens_to_remove` dari lapisan cache saat ini.

#### get_max_length[[transformers.EncoderDecoderCache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2284)

Mengembalikan panjang urutan maksimum (yaitu kapasitas maksimum) dari objek cache

#### get_seq_length[[transformers.EncoderDecoderCache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2280)

Mengembalikan panjang urutan dari state yang di-cache. Indeks layer dapat secara opsional diberikan.

#### reorder_cache[[transformers.EncoderDecoderCache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/cache_utils.py#L2294)

Mengurutkan ulang cache untuk beam search, berdasarkan indeks beam yang dipilih.

## Utilitas Watermark[[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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/configuration_utils.py#L1460)

Kelas yang menyimpan argumen untuk pembuatan watermark dan harus diteruskan ke `GenerationConfig` saat `generate`. Lihat [makalah ini](https://huggingface.co/papers/2306.04634) untuk detail lebih lanjut mengenai argumen tersebut.

Menerima kunci-kunci berikut:
- greenlist_ratio (`float`): Digunakan untuk watermarking. Rasio token "green" yang digunakan terhadap ukuran kosakata. Nilai default adalah 0.25.
- bias (`float`): Digunakan bersama watermarking. Bias yang ditambahkan ke logits token "hijau" yang dipilih. Nilai defaultnya adalah 2.0.
- hashing_key (`int`): Kunci hashing yang digunakan untuk watermarking. Nilai defaultnya adalah 15485863 (bilangan prima ke-sejuta).
- seeding_scheme (`str`): Algoritma yang digunakan untuk watermarking. Menerima nilai:
  - "lefthash" (default): pemilihan token "green" bergantung pada token terakhir (Algoritma 2 dari makalah tersebut)
  - Pemilihan token "selfhash": "green" bergantung pada token saat ini itu sendiri (Algoritma 3 dari makalah tersebut). Kekurangan dari skema ini adalah ia mempertimbangkan semua token berikutnya yang mungkin dan dapat lebih lambat daripada "lefthash".
- context_width(`int`): Panjang konteks dari token sebelumnya yang digunakan dalam seeding. Panjang konteks yang lebih tinggi membuat watermarking lebih robust.

#### __call__[[transformers.WatermarkingConfig.__call__]]

```python
__call__(*args, **kwargs)
```

Panggil self sebagai fungsi.

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L71)

**Parameter:**

model_config (`PreTrainedConfig`) : Konfigurasi model yang akan digunakan untuk mendapatkan argumen spesifik model yang dipakai saat menghasilkan.

device (`str`) : Perangkat yang digunakan selama pembuatan teks berairmark.

watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : Konfigurasi dan argumen watermarking yang persis sama yang digunakan saat menghasilkan teks.

ignore_repeated_ngrams (`bool`, *opsional*, default `False`) : Apakah setiap ngram unik hanya dihitung sekali atau tidak.

max_cache_size (`int`, *opsional*, default 128) : Ukuran maksimum yang akan digunakan untuk LRU caching dari algoritma seeding/sampling yang dipanggil untuk setiap token.

Detektor untuk mendeteksi teks yang dihasilkan dengan watermark. Detektor ini harus diberikan pengaturan yang persis sama dengan yang digunakan saat generasi teks untuk mereplikasi pembuatan greenlist watermark dan dengan demikian mendeteksi watermark. Pengaturan ini mencakup perangkat yang benar yang digunakan selama generasi teks, argumen watermarking yang benar, dan ukuran vocab tokenizer yang benar. Kode ini didasarkan pada [repo asli](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

Lihat [makalahnya](https://huggingface.co/papers/2306.04634) untuk informasi lebih lanjut.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L193)

**Parameter:**

input_ids (`torch.LongTensor`) : Teks yang dihasilkan oleh watermark. Disarankan untuk menghapus prompt, karena dapat memengaruhi deteksi.

z_threshold (`Dict`, *opsional*, default `3.0`) : Mengubah ambang batas ini akan mengubah sensitivitas detektor. Nilai z threshold yang lebih tinggi menghasilkan sensitivitas yang lebih rendah, dan sebaliknya untuk nilai z threshold yang lebih rendah.

return_dict (`bool`,  *opsional*, default `False`) : Apakah akan mengembalikan `~generation.WatermarkDetectorOutput` atau tidak. Jika tidak, akan mengembalikan prediksi boolean,

**Mengembalikan:** `WatermarkDetectorOutput` atau `np.ndarray`

`WatermarkDetectorOutput` jika `return_dict=True`, selain itu `np.ndarray`.

ma

#### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]]

```python
transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L252)

**Parameter:**

watermarking_depth (`int`, *opsional*) : Jumlah lapisan turnamen.

base_rate (`float`, *opsional*, default 0.5) : Probabilitas prior P(w) bahwa sebuah teks diberi watermark.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari [BayesianDetectorModel](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.BayesianDetectorModel). Kelas ini digunakan untuk membuat model Bayesian Detector sesuai dengan argumen yang ditentukan.

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

#### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]]

```python
transformers.BayesianDetectorModel(config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L359)

**Parameter:**

config ([BayesianDetectorConfig](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.BayesianDetectorConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Klasifikasi Bayesian untuk deteksi watermark.

Detektor ini menggunakan aturan Bayes untuk menghitung skor watermarking, yaitu sigmoid dari log dari rasio probabilitas posterior P(watermarked|g_values) dan P(unwatermarked|g_values). Silakan lihat bagian tentang BayesianScore dalam makalah untuk detail lebih lanjut. URL makalah: https://www.nature.com/articles/s41586-024-08025-4

Perhatikan bahwa detektor ini hanya berfungsi dengan watermarking berbasis Tournament yang non-distortionary menggunakan distribusi g-value Bernoulli(0.5).

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.BayesianDetectorModel.forward]]

```python
forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L448)

**Parameter:**

g_values (`torch.Tensor` dengan bentuk `(batch_size, seq_len, watermarking_depth, ...)`) : nilai-g (dengan nilai 0 atau 1)

mask : Array biner dengan bentuk [batch_size, seq_len] yang menunjukkan nilai g mana yang harus digunakan. Nilai g dengan nilai mask 0 akan dibuang.

**Mengembalikan:**

p(watermarked | g_values), dengan bentuk [batch_size].

Menghitung posterior berairan P(watermarked|g_values).

#### transformers.SynthIDTextWatermarkingConfig[[transformers.SynthIDTextWatermarkingConfig]]

```python
transformers.SynthIDTextWatermarkingConfig(ngram_len: int, keys: list[int], 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/configuration_utils.py#L1540)

**Parameter:**

ngram_len (`int`) : Panjang ngram.

keys (`list[int]`) : Sekumpulan kunci watermarking, satu untuk setiap kedalaman.

context_history_size (`int`, *opsional*, default 1024) : Ukuran tensor untuk melacak konteks yang telah dilihat.

sampling_table_seed (`int`, *opsional*, default 0) : Benang acak (random seed) untuk menghasilkan tabel sampling.

sampling_table_size (`int`, *opsional*, default 65536) : Ukuran tabel sampling.

skip_first_ngram_calls (`bool`, *opsional*, default `False`) : Apakah akan melewati panggilan ngram pertama.

debug_mode (`bool`, *opsional*, default `False`) : Logits dimodifikasi menjadi seragam satu yang diperoleh sebelum modifikasi watermarking diterapkan. Ini untuk menguji implementasi.

Kelas yang menyimpan argumen untuk pembuatan watermark dan harus diteruskan ke `GenerationConfig` saat `generate`. Lihat [makalah ini](https://www.nature.com/articles/s41586-024-08025-4) untuk detail lebih lanjut mengenai argumen tersebut.

Contoh:
```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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L492)

**Parameter:**

detector_module ([BayesianDetectorModel](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.BayesianDetectorModel)) : objek modul Bayesian detector yang diinisialisasi dengan parameter. Lihat https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text untuk penggunaan.

logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : logits processor yang digunakan untuk watermarking.

tokenizer (`Any`) : Tokenizer yang digunakan untuk model.

Kelas detektor watermark teks SynthID.

Kelas ini harus diinisialisasi dengan modul detektor bayesian yang telah dilatih; periksa skrip di examples/synthid_text/detector_training.py sebagai contoh untuk melatih, menyimpan, dan memuat modul detektor ini. Folder tersebut juga menampilkan contoh kasus penggunaan detektor ini.

Contoh:
```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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/watermarking.py#L539)

## Utilitas Kompilasi[[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)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/generation/configuration_utils.py#L1632)

**Parameter:**

fullgraph (`bool`, *opsional*, defaultnya `False`) : Jika False (default), akan mencoba menemukan region yang dapat dikompilasi untuk dioptimalkan. Jika True, maka seluruh fungsi harus dapat ditangkap ke dalam satu graph. Jika hal ini tidak memungkinkan (yaitu, jika terdapat graph breaks), maka error akan dilempar.

dynamic (`bool` atau `None`, *opsional*) : Apakah akan mencoba menggunakan graf bentuk dinamis.

backend (`str` atau `Callable`, *opsional*, defaultnya `"inductor"`) : Backend yang akan digunakan.

mode (`str`, *opsional*, defaultnya `"reduce-overhead"`) : Mengontrol keseimbangan antara kinerja dan overhead.

options (`dict`, *opsional*) : Kamus berisi opsi untuk diteruskan ke backend.

Kelas yang menyimpan argumen terkait perilaku `torch.compile` saat menggunakan kompilasi otomatis di `generate`. Lihat [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html) untuk detail lebih lanjut mengenai argumen-argumen tersebut.

Contoh:
```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)
```

Panggil self sebagai fungsi.

