# Üretim için yardımcı programlar

Bu sayfa, [generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) tarafından kullanılan tüm yardımcı işlevleri listeler.

## Çıktıları Oluştur[[transformers.generation.GenerateDecoderOnlyOutput]]

[generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) işlevinin çıktısı, [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput)'un bir alt sınıfının örneğidir. Bu çıktı, [generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) tarafından döndürülen tüm bilgileri içeren bir veri yapısıdır ancak aynı zamanda bir tuple veya sözlük olarak da kullanılabilir.

İşte bir örnek:

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

`generation_output` nesnesi bir [GenerateDecoderOnlyOutput](/docs/transformers/main/tr/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput)'dur; aşağıdaki sınıfın belgelerinde de görülebileceği üzere, bu nesnenin şu özellikleri vardır:

- `sequences`: oluşturulan token dizileri
- `scores` (isteğe bağlı): dil modelleme başlığı için her üretim adımına ait tahmin puanları
- `hidden_states` (isteğe bağlı): modelin gizli durumları, her üretim adımı için
- `attentions` (isteğe bağlı): modelin dikkat ağırlıkları, her üretim adımı için

Burada `output_scores=True` parametresini ilettiğimiz için `scores` değerleri mevcut, ancak `output_hidden_states=True` veya `output_attentions=True` parametrelerini iletmediğimiz için `hidden_states` ve `attentions` değerleri yok.

Her özniteliğe normalde yaptığınız gibi erişebilirsiniz ve bu öznitelik model tarafından döndürülmediyse `None` alırsınız. Örneğin burada `generation_output.scores`, dil modelleme başlığının ürettiği tüm tahmin puanlarını, `generation_output.attentions` ise `None` değerini temsil eder.

`generation_output` nesnesini bir tuple olarak kullandığımızda, yalnızca `None` değeri olmayan öznitelikleri saklar. Burada, örneğin, iki öğesi vardır: `loss` ve ardından `logits`, dolayısıyla

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

örneğin `(generation_output.sequences, generation_output.scores)` demetini döndürür.

`generation_output` nesnesini bir sözlük olarak kullandığımızda, yalnızca `None` değeri olmayan öznitelikleri saklar. Burada, örneğin, `sequences` ve `scores` olmak üzere iki anahtarı vardır.

Burada tüm çıktı türlerini belgeledik.

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

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

**Parametreler:**

sequences (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Üretilen diziler. İkinci boyut (sequence_length), `max_length`'a eşittir veya `eos_token_id` nedeniyle tüm partiler erken bittiyse daha kısadır.

scores (`tuple(torch.Tensor)` *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Dil modelleme başlığının işlenmiş tahmin puanları (SoftMax öncesi her sözlük belirteci için puanlar), her üretim adımında. En fazla `max_new_tokens` öğe içeren `torch.Tensor` bir demeti (üretilen her belirteç için bir öğe), her tensörün şekli `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *isteğe bağlı*, `output_logits=True` olduğunda döndürülür) : Dil modelleme başlığının işlenmemiş tahmin puanları (SoftMax öncesi her sözlük belirteci için puanlar), her üretim adımında. En fazla `max_new_tokens` öğe içeren `torch.Tensor` bir demeti (her üretilen belirteç için bir öğe), her tensörün şekli `(batch_size, config.vocab_size)`.

attentions (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` olduğunda döndürülür) : Üretilen her token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_hidden_states=True` olduğunda döndürülür) : Her üretilen token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren `torch.Tensor` tuple'larından oluşan bir tuple, şekli `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *isteğe bağlı*, `use_cache=True` olduğunda döndürülür) : Çözmeyi hızlandırmak için kullanılan model önbelleğini döndürür. Farklı modellerin farklı önbellek biçimleri vardır, modelin belgesine bakın. Genellikle bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir.

Beam olmayan yöntemler kullanıldığında, yalnızca decoder'a sahip üretim modellerinin çıktıları.

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

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

**Parametreler:**

sequences (`torch.LongTensor`, şekli `(batch_size*num_return_sequences, sequence_length)`) : Üretilen diziler. İkinci boyut (sequence_length), `max_length`'a eşittir veya tüm toplamlar `eos_token_id` nedeniyle erken bittiyse daha kısadır.

scores (`tuple(torch.Tensor)` *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Dil modelleme başlığının işlenmiş tahmin puanları (SoftMax öncesi her sözlük belirteci için puanlar), her üretim adımında. En fazla `max_new_tokens` öğe içeren `torch.Tensor` bir demeti (üretilen her belirteç için bir öğe), her tensörün şekli `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *isteğe bağlı*, `output_logits=True` olduğunda döndürülür) : Dil modelleme başlığının işlenmemiş tahmin puanları (SoftMax öncesi her sözlük belirteci için puanlar), her üretim adımında. En fazla `max_new_tokens` öğe içeren `torch.Tensor` bir demeti (her üretilen belirteç için bir öğe), her tensörün şekli `(batch_size, config.vocab_size)`.

encoder_attentions (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` olduğunda döndürülür) : `torch.Tensor` (ayrıştırıcının her katmanı için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` olduğunda döndürülür) : `torch.Tensor` (gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` olduğunda döndürülür) : Üretilen her token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` olduğunda döndürülür) : Üretilen her token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_hidden_states=True` olduğunda döndürülür) : Her üretilen token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren `torch.Tensor` tuple'larından oluşan bir tuple, şekli `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *isteğe bağlı*, `use_cache=True` olduğunda döndürülür) : Çözmeyi hızlandırmak için kullanılan model önbelleğini döndürür. Farklı modellerin farklı önbellek biçimleri vardır, modelin belgesine bakın. Genellikle bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir.

Beam olmayan yöntemler kullanıldığında, encoder-decoder üretim modellerinin çıktıları.

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

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

**Parametreler:**

sequences (`torch.LongTensor`, şekli `(batch_size*num_return_sequences, sequence_length)`) : Üretilen diziler. İkinci boyut (sequence_length), `max_length`'a eşittir veya tüm toplamlar `eos_token_id` nedeniyle erken bittiyse daha kısadır.

sequences_scores (`torch.Tensor`, şekli `(batch_size*num_return_sequences)`, *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Üretilen `sequences` dizilerinin nihai beam puanları.

scores (`tuple(torch.Tensor)` *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Her üretim adımında sözlükteki her token için beam geçiş puanları. Bu beam'de daha önce üretilen tokenların log softmax'ine koşullu token log olasılıklarından oluşan beam geçiş puanları. En fazla `max_new_tokens` öğe içeren (her üretilen token için bir öğe) `torch.Tensor` tuple'ı, her tensörün şekli `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *isteğe bağlı*, `output_logits=True` olduğunda döndürülür) : Dil modelleme başlığının işlenmemiş tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar), her üretim adımında. En fazla `max_new_tokens` öğe içeren `torch.Tensor` bir demeti (üretilen her jeton için bir öğe), her tensörün şekli `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Her üretim adımında üretilen token kimliğinin beam indeksleri. `torch.LongTensor`, şekli `(batch_size*num_return_sequences, sequence_length)`.

attentions (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` olduğunda döndürülür) : Üretilen her token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_hidden_states=True` olduğunda döndürülür) : Her üretilen token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *isteğe bağlı*, `use_cache=True` olduğunda döndürülür) : Çözmeyi hızlandırmak için kullanılan model önbelleğini döndürür. Farklı modellerin farklı önbellek biçimleri vardır, modelin belgesine bakın. Genellikle bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir.

Beam yöntemleri kullanıldığında, yalnızca decoder'a sahip üretim modellerinin çıktıları.

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

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

**Parametreler:**

sequences (`torch.LongTensor`, şekli `(batch_size*num_return_sequences, sequence_length)`) : Üretilen diziler. İkinci boyut (sequence_length), `max_length`'a eşittir veya tüm toplamlar `eos_token_id` nedeniyle erken bittiyse daha kısadır.

sequences_scores (`torch.Tensor`, şekli `(batch_size*num_return_sequences)`, *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Üretilen `sequences` dizilerinin nihai beam puanları.

scores (`tuple(torch.Tensor)` *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Her üretim adımında sözlükteki her token için beam geçiş puanları. Bu beam'de daha önce üretilen tokenların log softmax'ine koşullu token log olasılıklarından oluşan beam geçiş puanları. En fazla `max_new_tokens` öğe içeren (her üretilen token için bir öğe) `torch.Tensor` tuple'ı, her tensörün şekli `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *isteğe bağlı*, `output_logits=True` olduğunda döndürülür) : Dil modelleme başlığının işlenmemiş tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar), her üretim adımında. En fazla `max_new_tokens` öğe içeren `torch.Tensor` bir demeti (üretilen her jeton için bir öğe), her tensörün şekli `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *isteğe bağlı*, `output_scores=True` olduğunda döndürülür) : Her üretim adımında üretilen token kimliğinin beam indeksleri. `torch.LongTensor`, şekli `(batch_size*num_return_sequences, sequence_length)`.

encoder_attentions (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` olduğunda döndürülür) : `torch.Tensor` (ayrıştırıcının her katmanı için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` olduğunda döndürülür) : `torch.Tensor` (gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` olduğunda döndürülür) : Üretilen her token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_attentions=True` olduğunda döndürülür) : Üretilen her token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opsiyonel*, `output_hidden_states=True` olduğunda döndürülür) : Her üretilen token için bir eleman içeren, decoder'ın her katmanı için bir eleman içeren tuple'ların `torch.Tensor` tuple'ı, şekli `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *isteğe bağlı*, `use_cache=True` olduğunda döndürülür) : Çözmeyi hızlandırmak için kullanılan model önbelleğini döndürür. Farklı modellerin farklı önbellek biçimleri vardır, modelin belgesine bakın. Genellikle bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir.

Beam yöntemleri kullanıldığında, encoder-decoder üretim modellerinin çıktıları.

## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

Bir [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor), üretim için dil modeli başlığının tahmin skorlarını değiştirmek üzere kullanılabilir.

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

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

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

**Parametreler:**

input_start_len (`int`) : Başlangıç girdi dizisinin uzunluğu.

semantic_vocab_size (`int`) : Semantik bölümün sözlük boyutu, yani semantik sözlükle ilişkilendirilen token sayısı.

codebook_size (`int`) : Kod kitabıyla ilişkili jeton sayısı.

Bark'ın iki kod kitabı arasında dönüşümlü üretimi zorlayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor).

Bu logits işlemcisi yalnızca [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark)'ın ince alt modeliyle uyumludur. Örnekler için model dokümantasyonuna bakın.

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

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

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

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

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

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

**Parametreler:**

guidance_scale (float) : Sınıflandırıcı serbest yönlendirmesi (CFG) için yönlendirme ölçeği. CFG, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, modelin girdi istemine daha sıkı bağlı örnekler üretmesini teşvik eder; bu genellikle daha düşük kalite pahasına gerçekleşir.

Sınıflandırıcı serbest yönlendirmesi (CFG) için [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Skorlar, batch boyutu üzerinde bölünür; ilk yarı, koşullu logitleri (girdi isteminden tahmin edilenler) temsil ederken ikinci yarı, koşulsuz logitleri (boş veya 'null' istemden tahmin edilenler) temsil eder. İşleyici, `guidance_scale` ile parametrelenmiş koşullu ve koşulsuz logitler üzerinden ağırlıklı bir ortalama hesaplar.

Daha fazla bilgi için [makaleye](https://huggingface.co/papers/2306.05284) bakın.

Bu logits işlemcisi yalnızca [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen) ile uyumludur.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

encoder_ngram_size (`int`) : `ngram_size` boyutundaki tüm ngram'lar yalnızca kodlayıcı girdi kimlikleri içinde oluşabilir.

encoder_input_ids (`int`) : decoder ids içinde tekrarlanmaması gereken encoder_input_ids.

[LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor), [NoRepeatNGramLogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor) ile benzer şekilde çalışır ancak yalnızca prompt'ta bulunan n-gram'ların tekrarını önlemek için uygulanır.

Dil modelinde sohbet etme eğilimini teşvik etmek için, önceki konuşma turlarında bulunan n-gram'ların üretilmesini engelleyerek tasarlanmıştır.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

penalty (`float`) : Tekrar cezası parametresi. 1.0 ceza uygulanmadığı anlamına gelir. 1.0'un üzerindeki değerler istem token'larını ödüllendirir. 0.0 ile 1.0 arasındaki değerler istem token'larını cezalandırır.

encoder_input_ids (`torch.LongTensor`) : decoder ids içinde tekrarlanması gereken encoder_input_ids.

[LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor), [RepetitionPenaltyLogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor) ile benzer şekilde çalışır ancak istemde (prompt) bulunan token'lara uygulanan *ters* bir ceza kullanır. Başka bir deyişle, 1.0'dan büyük bir ceza değeri, istemde yer alan token'ların seçilme olasılığını artırır.

Girdiye dayalı özetleme gibi görevlerde halüsinasyonu önlemek amacıyla tasarlanmıştır. Başlangıçta kodlayıcı-çözücü (encoder-decoder) modeller için öngörülmüş olsa da, LLM'ler gibi yalnızca çözücü (decoder-only) modellerle de kullanılabilir.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

epsilon (`float`) : > 0 olarak ayarlanırsa, üretim için yalnızca olasılıkları `epsilon` veya daha yüksek olan en çok token'lar korunur.

filter_value (`float`, *isteğe bağlı*, varsayılan -inf) : Tüm filtrelenmiş değerler bu float değerine ayarlanır.

min_tokens_to_keep (`int`, *opsiyonel*, varsayılan 1) : Filtrelenemeyecek en az token sayısı.

Epsilon örneklemesi yapan, yani `prob >= epsilon` koşulunu sağlayan tokenlarla sınırlayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Bu kısıtı sağlayan token yoksa, en büyük min_tokens_to_keep tokenlarını alır. Daha fazla bilgi için [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) makalesine bakın.

Örnekler:
```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)
```

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

epsilon (`float`) : (0, 1) aralığında bir float değeri. Dinik kesme değerini, `eta`, hesaplamak için kullanılan hiperparametre. Makalede önerilen değerler, modelin boyutuna bağlı olarak 3e-4 ile 4e-3 arasında değişmektedir.

filter_value (`float`, *opsiyonel*, varsayılan -inf) : Dinik kesme değeri olan `eta`'nın altında bulunan tüm değerler bu float değerine ayarlanır. Bu parametre, üretimden tamamen hariç tutulması gereken çok düşük olasılıklı tokenlar için logitlerin değiştirilmesi gerektiğinde faydalıdır.

min_tokens_to_keep (`int`, *opsiyonel*, varsayılan 1) : Olasılıklarından bağımsız olarak, üretim için korunması gereken en az token sayısını belirtir. Örneğin, `min_tokens_to_keep` değeri 1 olarak ayarlanırsa, tüm tokenların olasılıkları `eta` kesme değerinin altında olsa bile, üretim için her zaman en az bir token korunur.

device (`str`, *isteğe bağlı*, varsayılan `"cpu"`) : Tensörlerin ayrılacağı cihaz.

Dinamik bir kesme değeri olan `eta`'nın altındaki olasılıklara sahip tokenları filtrelemek için kullanılan eta-sampling tekniğini uygulayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). `eta`, `epsilon` hiperparametresi ile token olasılıklarının entropisinin bir kombinasyonuna dayanarak hesaplanır, yani `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. Bu kısıtı sağlayan token yoksa en büyük min_tokens_to_keep token alınır. Sinirsel dil modelleri tarafından üretilen uzun metin örneklerindeki düşük kalite sorununu ele alarak daha tutarlı ve akıcı metinler elde edilmesini sağlar. Daha fazla bilgi için [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) makalesine bakın. Not: Bu `LogitsProcessor`'un çalışması için `do_sample`'ın `True` olarak ayarlanması gerekir.

Örnekler:
```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)
```

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

exponential_decay_length_penalty (`tuple(int, float)`) : Bu tuple şu öğelerden oluşmalıdır: `(start_index, decay_factor)` burada `start_index` cezanın başladığı yeri belirtir ve `decay_factor` üstel azalma katsayısını temsil eder

eos_token_id (`Union[int, list[int], torch.Tensor]`) : *dizinin sonu* belirtecinin kimlik(leri).

input_ids_seq_length (`int`) : Girdi dizisinin uzunluğu.

`start_index` değerine ulaşıldıktan sonra `eos_token_id` skorunu üstel olarak artıran [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Bu sayede sert bir kesme noktası olmadan daha kısa diziler üretilebilir ve `eos_token` anlamlı bir konumda tahmin edilebilir.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

bos_token_id (`int`) : İlk üretilen token olarak zorlanacak token'ın kimliği.

Belirtilen token'ın üretilen ilk token olarak uygulanmasını sağlayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Encoder-decoder modelleriyle kullanılır.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

max_length (`int`) : Üretilmesi gereken dizinin maksimum uzunluğu.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : *dizinin sonu* belirtecinin kimlik(leri).

device (`str`, *isteğe bağlı*, varsayılan `"cpu"`) : Tensörlerin ayrılacağı cihaz.

`max_length` değerine ulaşıldığında, belirtilen token'ın son üretilen token olarak zorlanmasını sağlayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor).

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

Üretim yönteminin başarısız olmasını önlemek için tüm `nan` ve `inf` değerlerini kaldıran bir [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Logits işleyicisinin yalnızca gerekli olduğunda kullanılması gerektiğini unutmayın; çünkü üretim yöntemini yavaşlatabilir.

Bu logits işlemcisinin `generate` örneği yoktur, çünkü kullanımını gerektirecek doğru bir bayrak kombinasyonu bulunmamalıdır.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

Skorları log-softmax kullanarak normalize etmek için [Log-softmax](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Bu kütüphanede kullanılan arama algoritması bunu yapmadığı için (yalnızca işlem öncesinde yapar, ancak yeniden normalizasyon gerekebilir), logits işleyicileri veya şekillendiricileri uygulandıktan sonra beam search sırasında skorları normalize etmek önemlidir; algoritma hipotezleri karşılaştırırken skorların normalize edildiğini varsayar.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

Üretim sırasında uygulanabilen tüm logit işleyicileri için soyut temel sınıf.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

Bu sınıf, `scores` girdi tensörünü işlemek üzere [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor) listesini oluşturmak için kullanılabilir. Bu sınıf, list sınıfından devralır ve girdilere her bir [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor)'u uygulamak için belirli bir *__call__* metodu ekler.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Bir logits işleyicisine özgü ek kwargs'lar.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

min_length (`int`) : `eos_token_id` puanının `-float("Inf")` olarak ayarlandığı minimum uzunluk.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : *dizinin sonu* belirtecinin kimlik(leri).

device (`str`, *isteğe bağlı*, varsayılan `"cpu"`) : Tensörlerin ayrılacağı cihaz.

EOS olasılığını 0'a ayarlayarak minimum uzunluğu uygulayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Çoğu LLM gibi yalnızca çözücü (decoder-only) modellerde, uzunluğun prompt'u da içerdiğine dikkat edin.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

**Parametreler:**

prompt_length_to_skip (`int`) : Girdi token uzunluğu. `generate` ile kullanıldığında girdi uzunluğunu otomatik olarak atadığı için geçerli bir argüman değildir.

min_new_tokens (`int`) : `eos_token_id` skorunun `-float("Inf")` olarak ayarlandığı *yeni* token uzunluğunun alt sınırı.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : *dizinin sonu* belirtecinin kimlik(leri).

device (`str`, *isteğe bağlı*, varsayılan `"cpu"`) : Tensörlerin ayrılacağı cihaz.

Yeni token'lar için minimum uzunluğu, EOS (End-Of-Sequence) token olasılığını 0'a ayarlayarak uygulayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). [MinLengthLogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.MinLengthLogitsProcessor)'un aksine, bu işlemci prompt'u görmezden gelir.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

min_p (`float`) : En olası token'ın olasılığıyla ölçeklenecek olan minimum token olasılığı. 0 ile 1 arasında bir değer olmalıdır. Tipik değerler 0.01-0.2 aralığındadır ve `top_p`'nin 0.99-0.8 aralığında ayarlanmasına benzer bir seçicilik gösterir (normal `top_p` değerlerinin tersini kullanın).

filter_value (`float`, *isteğe bağlı*, varsayılan -inf) : Tüm filtrelenmiş değerler bu float değerine ayarlanır.

min_tokens_to_keep (`int`, *opsiyonel*, varsayılan 1) : Filtrelenemeyecek en az token sayısı.

En olası token'ın olasılığına göre ölçeklenmiş, minimum olasılığın üzerindeki tüm token'ları koruyan min-p işlemini gerçekleştiren [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Sonuç olarak, yüksek olasılıklı token'ların varlığında filtre daha agresif hale gelir; bu da sapmamamız gereken özgüvenli bir çıktının işaretidir.

Genellikle [TemperatureLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TemperatureLogitsWarper) ile birlikte kullanılır. [TopPLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TopPLogitsWarper) ve [TopKLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TopKLogitsWarper) yerine bir alternatif olarak kullanılır.

@menhguin ve @kalomaze tarafından oluşturuldu (github kullanıcı adları). Kod, [bu dış PR'dan](https://github.com/oobabooga/text-generation-webui/pull/4449/files) uyarlanmıştır

Örnekler:

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

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

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

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

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

**Parametreler:**

bad_words_ids (`list[list[int]]`) : Üretilmesine izin verilmeyen token kimliklerinin listelerinden oluşan liste.

eos_token_id (`Union[int, list[int], torch.Tensor]`, *isteğe bağlı*) : *end-of-sequence* token'ının kimlik(l)eri.

Belirtilen dizilerin asla seçilmeyeceğini zorlayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor).

Üretilen metinde yer almaması gereken kelimelerin token kimliklerini almak için, tokenizer'ı başlatırken `add_prefix_space=True` değerini ayarlamayı ve `tokenizer(bad_words, add_special_tokens=False).input_ids` ifadesini kullanmayı unutmayın. `add_prefix_space` argümanı yalnızca bazı yavaş tokenizer'lar tarafından desteklenir; hızlı tokenizer'ların önek davranışları `pre tokenizers` kütüphanesinden gelir. Daha fazla bilgi için [buraya](https://huggingface.co/docs/tokenizers/api/pre-tokenizers) bakın.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

ngram_size (`int`) : `ngram_size` boyutundaki tüm n-gramlar yalnızca bir kez oluşabilir.

N-gram'ler, bir metin dizisinden alınan "n" ardışık kelime, karakter veya token grubudur. "She runs fast" cümlesi verildiğinde, bi-gram'ler (n=2) ("she", "runs") ve ("runs", "fast") olur. Metin üretiminde, kelime dizilerinin tekrarını önlemek daha çeşitli bir çıktı sağlar. Bu [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor), yasaklı token'ların skorlarını negatif sonsuza ayarlayarak ve bu token'ları skorların daha fazla işlenmesi sırasında hesaba katılmaktan çıkararak n-gram'lerin tekrarlanmamasını sağlar. Not: Çoğu LLM gibi yalnızca decoder'a sahip modellerde, n-gram'leri elde etmek için prompt da dikkate alınır. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345).

N-gram cezalarını dikkatli kullanın. Örneğin, New York şehri hakkında bir makalede 2-gram (bigram) cezalandırması, şehrin adının metinde yalnızca bir kez geçmesine yol açan istenmeyen sonuçlara neden olabilir. [Referans](https://huggingface.co/blog/how-to-generate)

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : Bu fonksiyon, her adımda beam search'i yalnızca izin verilen token'lara kısıtlar. Bu fonksiyon `inputs_ids` ve batch kimliği `batch_id` olmak üzere 2 argüman alır. Önceki adımlarda üretilen token'lara `inputs_ids` ve batch kimliğine `batch_id` bağlı olarak, bir sonraki üretim adımı için izin verilen token'ların listesini döndürmelidir.

Kısıtlı üretimi uygulayan ve önek koşullu kısıtlı üretim için faydalı olan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Daha fazla bilgi için [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) bölümüne bakın.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

penalty (`float`) : Tekrar cezası parametresi. 1.0 ceza uygulanmadığı anlamına gelir. 1.0'un üzerindeki değerler, daha önce üretilmiş token'ları cezalandırır. 0.0 ile 1.0 arasındaki değerler, daha önce üretilmiş token'ları ödüllendirir.

prompt_ignore_length (`int` veya `torch.LongTensor`, *isteğe bağlı*) : Yoksayılacak öndeki token sayısı, isteğe bağlı olarak her parti öğesi için belirtilebilir.

Önceki tokenlerin tekrarını bir ceza yoluyla önleyen [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Bu ceza, her token için en fazla bir kez uygulanır. Dikkat edin, çoğu LLM gibi yalnızca çözücü (decoder-only) modellerde, varsayılan olarak değerlendirilen tokenler istemi (prompt) dahil eder.

Orijinal [makalede](https://huggingface.co/papers/1909.05858), yazarlar, doğru üretim ile tekrarsızlık arasında iyi bir denge sağlamak için yaklaşık 1,2 değerinde bir ceza kullanmayı önermektedir. Tekrarı cezalandırmak ve azaltmak için, daha yüksek değerlerin daha güçlü bir şekilde cezalandırdığı 1,0 üzerindeki `penalty` değerlerini kullanın. Tekrarı ödüllendirmek ve teşvik etmek için, daha düşük değerlerin daha güçlü bir şekilde ödüllendirdiği 0,0 ile 1,0 arasındaki `penalty` değerlerini kullanın.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

sequence_bias (`list[list[Union[list[int], float]]]`) : Bir token dizisini önyargı terimine eşleyen liste listesi (ör. `[[[10, 45], -2.0], [[64], -7.5]]`). Pozitif önyargılar dizinin seçilme olasılığını artırırken, negatif önyargılar tam tersini yapar. Bir dizinin uzunluğu 1 ise, önyargısı her zaman uygulanır. Aksi halde, önyargı yalnızca ilgili dizinin tamamlılmak üzere olduğu durumda (bu işleyici uygulandıktan sonraki token seçim adımında) uygulanır.

[LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor), dizilere ek bir önyargı uygular. Önyargı, bir dizinin son token'ına, bir sonraki üretilen token bu diziyi tamamlayabildiğinde uygulanır. Sonuç olarak, birden fazla token içeren dizilerdeki önyargıdan en iyi şekilde yararlanmak için, kısmen tamamlanmış ve negatif önyargıya sahip dizileri zarif bir şekilde aşmak için beam yöntemlerini kullanmayı ve önyargının daha erken uygulanmasını sağlamak için önyargıyı bu dizilerin öneklerine uygulamayı düşünün.

Bir token düzeyinde, bir kelimeyi önyargılandırmak, başında bir boşluk olan bir kelimeyi önyargılandırmaktan farklıdır. Cümlenin ortasındaki "foo" kelimesini önyargılandırmak istiyorsanız, büyük olasılıkla bir önek boşluğu ekleyip " foo" kelimesini önyargılandırmak istersiniz. Bunun nedenini öğrenmek için NLP kursumuzun tokenizer bölümüne göz atın: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

[SuppressTokensAtBeginLogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor), `generate` fonksiyonu `begin_index` belirteçlerini kullanarak üretimi başlattığı anda bir belirteç listesini bastırır. Bu, `begin_suppress_tokens` tarafından tanımlanan belirteçlerin başlangıçta üretilmemesini sağlamalıdır. Özgün olarak [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper) için oluşturulmuştur.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

Bu işlemci, bir token listesini bastırmak için kullanılabilir. İşlemci, bu tokenların log olasılıklarını `-inf` olarak ayarlayarak üretilmelerini engeller. Başlangıçta [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper) için oluşturulmuştur.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

ngram_len (`int`) : Ngram uzunluğu.

keys (`list[int]`) : Her derinlik için bir tane olmak üzere filigran anahtarlarından oluşan bir dizi.

sampling_table_size (`int`) : Örnekleme tablosunun boyutu.

sampling_table_seed (`int`) : Örnekleme tablosunu oluşturmak için rastgele tohum.

context_history_size (`int`) : Görülen bağlamları takip etmek için tutulacak tensörün boyutu.

device (`torch.device`) : Kullanılacak cihaz.

skip_first_ngram_calls (`bool`, *isteğe bağlı*, varsayılan `False`) : İlk ngram çağrılarının atlanıp atlanmayacağı.

debug_mode (`bool`, *isteğe bağlı*, varsayılan `False`) : Logitler, watermarking değişikliği uygulanmadan önce elde edilen düzgün bir dağılıma göre değiştirilir. Bu, uygulamanın test edilmesi içindir.

Metin üretim modelleri için filigranlama tekniklerini uygulayan bir logits işleyicisi. Bu sınıf, sentetik içeriğin tespit edilmesine yardımcı olmak amacıyla üretilen metne algılanamaz sinyaller gömme yöntemi olan SynthID metin filigranlamasının uygulanmasını kolaylaştırır. Bu sınıf, doğrulama için daha sonra güvenilir bir şekilde geri kazanılabilecek bir şekilde, metin üretimi sırasında token seçim olasılıklarını ince ayarlar.

Öne Çıkan Özellikler:
* **Durum Yönetimi:** Token dizilerini izlemek ve filigran anahtarları üretmek için dahili durumu korur
dinamik olarak.

* **Anahtar Oluşturma:** Benzersiz anahtarlar oluşturmak için token dizileri ve filigranlama parametrelerine dayalı olarak özetleri hesaplar
her konum için.

* **G-Değer Örnekleme:** Sızdırma değerlerini (g-değerleri) örneklemek için önceden hesaplanmış bir örnekleme tablosu kullanır
oluşturulan anahtarlar.

* **Puan Ayarı:** Üretim sırasında token olasılıklarını değiştirmek için hesaplanan g-değerlerini uygular,
filigran.

* **Bağlam Tekrarı İşleme:** Tekrarlanan bağlamlardaki token'lara filigran uygulanmasını önlemek için mantık içerir,
doğallığı koruyarak.

* **Son Token Masking:** Sözcük sonu token'larının watermarking'e dahil edilmesini önlemek için maskelenmesini destekler
hesaplamalar.

* **Yardımcı İşlevler:** g-değerlerini doğrudan hesaplamak, bağlam tekrarı kontrolü yapmak, oluşturmak
EOS token maskları ve beklenen ortalama g-değerlerini tahmin edin.

Bu konuyla ilgili daha fazla ayrıntı için makaleye şu adresten ulaşabilirsiniz: https://www.nature.com/articles/s41586-024-08025-4

Örnekler:
```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)
```

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

temperature (`float`) : Logit dağılımını modüle etmek için kullanılan, kesinlikle pozitif bir float değeri. `1`'den küçük bir değer rastgeleliği azaltır (ve tam tersi), `0` değeri ise tüm olasılık kütlesini en olası tokene kaydırmaya eşdeğerdir.

Sıcaklık için (üstel ölçekli çıktı olasılık dağılımı) [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor), bu da öngörülen token'ların rastgeleliğini kontrol edebileceği anlamına gelir. Sıkça [TopPLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TopPLogitsWarper) ve [TopKLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TopKLogitsWarper) ile birlikte kullanılır.

Sıcaklık değerinin herhangi bir etki yapmaması isteniyorsa, `generate` argümanlarına `do_sample=True` değerinin dahil edildiğinden emin olun.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

top_h (`float`) : Entropiye dayalı eşik (`tau`) için ölçekleme katsayısı. `(0, 1]` aralığında olmalıdır.

filter_value (`float`, *isteğe bağlı*, varsayılan -inf) : Tüm filtrelenmiş değerler bu float değerine ayarlanır.

Entropi ve kümülatif olasılık kısıtlamalarına dayanarak yüksek olasılıklı token'ların alt kümesini uyumlu olarak seçen Top-H örneklemesi yöntemini uygulayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor).

Bu yöntem, seçilen dağılımın entropi farkını analiz ederek kaç token'ın korunacağını dinamik olarak belirler ve böylece keşif ile sömürü arasında denge kurar. Üretilen metnin hem çeşitliliğini hem de tutarlılığını korumasını sağlar.

Referans: Ayrıntılar için *Top-H Decoding: Adapting the Creativity and Coherence with Bounded Entropy in Text Generation* (NeurIPS 2025) makalesine bakın: https://arxiv.org/abs/2509.02510

Örnek:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Girdi token kimlikleri.

scores (`torch.Tensor`, şekli `(batch_size, vocab_size)`) : Modelden gelen ham logitler.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, vocab_size)`

Geçersiz jetonlar `-inf` ile maskelemiş işlenmiş logitler.

Logitleri Top-H örneklemesi kullanılarak filtreler.

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

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

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

**Parametreler:**

top_k (`int`) : top-k filtreleme için en yüksek olasılığa sahip kaç sözlük token'ının tutulacağı.

filter_value (`float`, *isteğe bağlı*, varsayılan -inf) : Tüm filtrelenmiş değerler bu float değerine ayarlanır.

min_tokens_to_keep (`int`, *opsiyonel*, varsayılan 1) : Filtrelenemeyecek en az token sayısı.

En yüksek olasılığa sahip k öğeye kısıtlayarak top-k işlemini gerçekleştiren [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Genellikle [TemperatureLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TemperatureLogitsWarper) ve [TopPLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TopPLogitsWarper) ile birlikte kullanılır.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

top_p (`float`) : 1'den küçük bir değere ayarlanırsa, olasılıkları `top_p` veya daha yüksek bir toplamı oluşturan en küçük en olası token kümesi üretime dahil edilir.

filter_value (`float`, *isteğe bağlı*, varsayılan -inf) : Tüm filtrelenmiş değerler bu float değerine ayarlanır.

min_tokens_to_keep (`int`, *opsiyonel*, varsayılan 1) : Filtrelenemeyecek en az token sayısı.

top-p işlemini gerçekleştiren, yani olasılık toplamları prob_cut_off <= prob_cut_off eşitsizliğini sağlayan en üst tokenlere kısıtlayan [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Genellikle [TemperatureLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TemperatureLogitsWarper) ve [TopKLogitsWarper](/docs/transformers/main/tr/internal/generation_utils#transformers.TopKLogitsWarper) ile birlikte kullanılır.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

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

**Parametreler:**

mass (`float`, *isteğe bağlı*, varsayılan 0.9) : 0 ile 1 arasında (bu değerler dahil) tipik_p değeri, varsayılan olarak 0.9'dur.

filter_value (`float`, *isteğe bağlı*, varsayılan -inf) : Tüm filtrelenmiş değerler bu float değerine ayarlanır.

min_tokens_to_keep (`int`, *opsiyonel*, varsayılan 1) : Filtrelenemeyecek en az token sayısı.

Tipik çözümlenme (decoding) işlemini gerçekleştiren [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). İnsanların dil kullanımından ilham alır; token olasılık dağılımının entropisine yakın log olasılığa sahip tokenları önceliklendirir. Bu, en olası tokenların süreç sırasında elenebileceği anlamına gelir.

Daha fazla bilgi için [Doğal Dil Üretimi İçin Tipik Çözümleme](https://huggingface.co/papers/2202.00666) bölümüne bakın.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

**Parametreler:**

guidance_scale (`float`) : Sınıflandırıcı serbest yönlendirmesi (CFG) için yönlendirme ölçeği. CFG, `guidance_scale != 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, modelin girdi istemine daha sıkı bağlı örnekler üretmesini teşvik eder; bu genellikle daha düşük kalite pahasına gerçekleşir. 1'den küçük bir değerin etkisi tam tersidir; bu durumda negative_prompt_ids ile sağlanan negatif istem (varsa) pozitif istem gibi davranır.

model (`PreTrainedModel`) : Koşulsuz skorları hesaplayan model. Muhtemelen koşullu skorları hesaplayan modelle aynıdır. Her iki model de aynı tokenizer'ı kullanmalıdır.

unconditional_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Koşulsuz dal için sözlükteki girdi dizisi tokenlarının indeksleri. Ayarlanmazsa, istemin son tokenı varsayılan olarak kullanılır.

unconditional_attention_mask (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : unconditional_ids için dikkat maskesi.

use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Negatif prompt ileri geçişi sırasında anahtar/değerlerin önbelleğe alınıp alınmayacağını belirtir.

Classifier-Free Guidance (CFG) için logits işlemcisi. İşlemci, `guidance_scale` ile parametrelenmiş olarak, prompt koşullu ve prompt koşulsuz (veya negatif) logitslerden gelen skorlar üzerinden ağırlıklı bir ortalama hesaplar. Koşulsuz skorlar, `model` içsel olarak `unconditional_ids` dalı ile istemlendirilerek hesaplanır.

Daha fazla bilgi için [makaleye](https://huggingface.co/papers/2306.17806) bakın.

Örnekler:

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

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

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

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

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

**Parametreler:**

generate_config (`GenerateConfig`) : Çıktıyı üretmek için kullanılan generate config. Aşağıdaki parametreler zorunludur: eos_token_id (`int`, *isteğe bağlı*, varsayılan 50257): *dizinin sonu* token'ının kimliği. no_timestamps_token_id (`int`, *isteğe bağlı*, varsayılan 50363): `"<|notimestamps|>"` token'ının kimliği. max_initial_timestamp_index (`int`, *isteğe bağlı*, varsayılan 1): Başlangıç zaman damgasının maksimum değerini ayarlamak için kullanılır. Bu, modelin gelecekte çok uzak zaman damgaları tahmin etmesini önlemek için kullanılır.

begin_index (`int`) : Model tarafından üretilen ilk token'ın token indeksi.

_detect_timestamp_from_logprob (`bool`, *isteğe bağlı*) : Zaman damgalarının, tüm zaman damgaları üzerindeki logprobs'tan tahmin edilebilir olup olmadığı.

Transkripsiyonda zaman damgalarının üretimi için logitleri değiştiren [LogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.LogitsProcessor). Girdi token'ları belirli bir eşiğe ulaştığında, işlemci puanları negatif sonsuza ayarlar. İşlemci, bu eşleşme desenini bozacak logitleri maskeleyerek zaman damgası token'larının çiftler halinde görünmesini sağlar. Bu, üretilen zaman damgalarının tutarlılığını ve yapısını korumak için yapılır. Ayrıca, herhangi bir zaman damgası token'ının örneklenme olasılığının herhangi bir tekil zaman damgası olmayan token'dan büyük olması durumunda, bu zaman damgası olmayan logitlerin negatif sonsuza ayarlanmasını da garanti eder. Bu, zaman damgalarının diğer olası token'lara tercih edilerek üretilmesini sağlamak için yapılır.

Daha fazla bilgi için [makaleye](https://huggingface.co/papers/2212.04356) bakın.

Örnekler:
``` 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)
```

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

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

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

**Parametreler:**

vocab_size (`int`) : Modelin tokenizer'ının vocab_size değeri. "green" token oranını hesaplamak için kullanılır.

device (`str`) : Modelin tahsis edildiği cihaz.

greenlist_ratio (`float`, isteğe bağlı, *isteğe bağlı*, varsayılan 0.25) : Sözlük boyutuna oranla kullanılan "yeşil" jetonların oranı. Varsayılan 0.25'tir.

bias (`float`, isteğe bağlı, *isteğe bağlı*, varsayılan 2.0) : Seçilen "yeşil" tokenlerin logitlerine eklenen önyargı. Metin üretim kalitesi düşerse `bias` değerini düşürmeyi düşünün. Önerilen değerler [0.5, 2.0] aralığındadır. Varsayılan 2.0'dır.

hashing_key (`int`, isteğe bağlı, *optional*, varsayılan 15485863) : Hashing için kullanılan anahtar. Bu filigranı dağıtıyorsanız, başka bir özel anahtar kullanmanızı öneririz. Varsayılan değer 15485863'tür (bir milyonuncu asal sayı).

seeding_scheme (`str`, isteğe bağlı, *optional*, varsayılan `"lefthash"`) : "yeşil" token'ların seçimi için kullanılan tohumlama şeması. Kabul edilen değerler: - "lefthash" (varsayılan): "yeşil" token'ların seçimi son token'a bağlıdır (makaledeki Algoritma 2) - "selfhash": "yeşil" token'ların seçimi, mevcut token'ın kendisine bağlıdır (makaledeki Algoritma 3) Bu şemanın dezavantajı, olası tüm sonraki token'ları dikkate alması ve "lefthash"ten daha yavaş olabilmesidir. Tohumlamada kullanılacak önceki token'ların bağlam uzunluğu. Daha yüksek bağlam uzunluğu, filigranlamayı daha dayanıklı hale getirir.

context_width (`int`, *opsiyonel*, varsayılan 1) : Tohumu ayarlamak için kullanılacak önceki token sayısı.

Üretilen metni filigranlamak için logits işleyicisi. İşleyici, bir sonraki token'ı üretmeden önce rastgele seçilmiş "green" token kümesine küçük bir önyargı ekleyerek model çıktı puanlarını değiştirir. "Green" token seçimi süreci, kullanılan `seeding_scheme`'e bağlıdır. Kod, [orijinal repoya](https://github.com/jwkirchenbauer/lm-watermarking/tree/main) dayanmaktadır.

Bu `LogitsProcessor` tarafından üretilen metin, `WatermarkDetector` kullanılarak tespit edilebilir. Ayrıntılar için [__call__()](/docs/transformers/main/tr/internal/generation_utils#transformers.WatermarkDetector.__call__) bölümüne bakın,

Daha fazla bilgi için [makaleye](https://huggingface.co/papers/2306.04634) bakın.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi token'larının indeksleri. [Girdi kimlikleri nedir?](../glossary#input-ids)

scores (`torch.Tensor`, şekli `(batch_size, config.vocab_size)`) : Dil modelleme başlığının tahmin puanları. Bunlar, beam search kullanılmadığında her sözlük öğesi için logitler veya beam search kullanıldığında her sözlük token'ı için log softmax olabilir.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, config.vocab_size)`

İşlenmiş tahmin puanları.

## DurdurmaKriterleri[[transformers.StoppingCriteria]]

Bir [StoppingCriteria](/docs/transformers/main/tr/internal/generation_utils#transformers.StoppingCriteria), üretim ne zaman durdurulacağını değiştirmek için (EOS token dışında) kullanılabilir. Lütfen bunun yalnızca PyTorch uygulamalarımızda mevcut olduğunu unutmayın.

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

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

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

Üretim sırasında uygulanabilecek tüm durdurma kriterleri için soyut temel sınıf.

Durdurma kriteriniz `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Bir dil modelleme başlığının tahmin puanları, her üretim adımı için bir tensör içeren bir tuple olarak, her biri `(batch_size, config.vocab_size)` biçiminde. Bunlar, SoftMax öncesi her sözlük jetonu için puanlar veya SoftMax sonrası her sözlük jetonu için puanlar olabilir. Bu durdurma kriteri `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun, aksi takdirde `None` iletilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek durdurma kriterleri için özel kwargs.

**Dönüş:** `torch.BoolTensor`. (`torch.BoolTensor`, şekli `(batch_size, 1)`)

`True`, belirli bir satır için üretimin durdurulacağını belirtir. `False`, devam edilmesi gerektiğini belirtir.

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

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

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

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Bir dil modelleme başlığının tahmin puanları, her üretim adımı için bir tensör içeren bir tuple olarak, her biri `(batch_size, config.vocab_size)` biçiminde. Bunlar, SoftMax öncesi her sözlük jetonu için puanlar veya SoftMax sonrası her sözlük jetonu için puanlar olabilir. Bu durdurma kriteri `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun, aksi takdirde `None` iletilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek durdurma kriterleri için özel kwargs.

**Dönüş:** `torch.BoolTensor`. (`torch.BoolTensor`, şekli `(batch_size, 1)`)

`True`, belirli bir satır için üretimin durdurulacağını belirtir. `False`, devam edilmesi gerektiğini belirtir.

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

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

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

**Parametreler:**

max_length (`int`) : Çıktı dizisinin sahip olabileceği maksimum uzunluk, token sayısı cinsinden.

max_position_embeddings (`int`, *opsiyonel*) : Modelin `config.max_position_embeddings` özniteliği tarafından tanımlanan maksimum model uzunluğu.

Bu sınıf, üretilen toplam token sayısı `max_length` değerini aştığında üretimi durdurmak için kullanılabilir. Yalnızca decoder tipindeki transformers için, bu sayının başlangıçtaki istem token'larını da içerdiğini unutmayın.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Bir dil modelleme başlığının tahmin puanları, her üretim adımı için bir tensör içeren bir tuple olarak, her biri `(batch_size, config.vocab_size)` biçiminde. Bunlar, SoftMax öncesi her sözlük jetonu için puanlar veya SoftMax sonrası her sözlük jetonu için puanlar olabilir. Bu durdurma kriteri `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun, aksi takdirde `None` iletilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek durdurma kriterleri için özel kwargs.

**Dönüş:** `torch.BoolTensor`. (`torch.BoolTensor`, şekli `(batch_size, 1)`)

`True`, belirli bir satır için üretimin durdurulacağını belirtir. `False`, devam edilmesi gerektiğini belirtir.

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

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

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

**Parametreler:**

max_time (`float`) : Üretim için saniye cinsinden izin verilen maksimum süre.

initial_timestamp (`float`, *isteğe bağlı*, varsayılan `time.time()`) : Üretim için izin verilen sürenin başlangıcı.

Bu sınıf, tam üretim belirli bir süre aşıldığında üretimi durdurmak için kullanılabilir. Varsayılan olarak, süre bu fonksiyonu başlattığınızda sayılmaya başlar. `initial_timestamp` parametresini geçirerek bu davranışı geçersiz kılabilirsiniz.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Bir dil modelleme başlığının tahmin puanları, her üretim adımı için bir tensör içeren bir tuple olarak, her biri `(batch_size, config.vocab_size)` biçiminde. Bunlar, SoftMax öncesi her sözlük jetonu için puanlar veya SoftMax sonrası her sözlük jetonu için puanlar olabilir. Bu durdurma kriteri `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun, aksi takdirde `None` iletilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek durdurma kriterleri için özel kwargs.

**Dönüş:** `torch.BoolTensor`. (`torch.BoolTensor`, şekli `(batch_size, 1)`)

`True`, belirli bir satır için üretimin durdurulacağını belirtir. `False`, devam edilmesi gerektiğini belirtir.

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

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

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

**Parametreler:**

tokenizer (`PreTrainedTokenizer`) : Modelin ilişkili tokenizer'ı (sözlüğü çıkarmak ve sonlandırma dizilerini tokenlaştırmak için gereklidir)

stop_strings (`Union[str, list[str]]`) : Üretimi sonlandırmak için kullanılması gereken bir dizi. Bir dize geçirilirse, tek elemanlı bir dizi gibi ele alınır.

Bu sınıf, belirli dize dizileri üretildiğinde üretimi durdurmak için kullanılabilir. Dizeleri, tokenizör sözlüğüyle birlikte ön işleyerek tokenların stop dizelerini geçerli bir şekilde tamamlayabileceği konumları bulur.

Herhangi bir durdurma dizgesini tamamlayan bir token üretildiği anda üretim durdurulur. Durdurma dizgesinin çözümlenmiş çıktıda mevcut olabileceği her durumu yakalamak istiyoruz; bu da dizgenin bir veya her iki ucunda "taşma" (overhang) bulunan durumları da yakalamamız gerektiği anlamına gelir. Bunu daha somut hale getirmek için, "stop" durdurma dizgesi için aşağıdaki token dizilerinden herhangi biri eşleşmeyi tetikler:

- ["st", "op"]
- ["dur"]
- ["st", "opera"]
- ["sto", "pper"]
- ["las", "topper"]
- ["s", "e", "n"]

Durdurma dizgesinin üretilen dizinin sonunda olması durumunda bir eşleşmenin tetikleneceğini unutmayın. Başka bir deyişle, bu diziler bir eşleşme tetiklemeyecektir:

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

Bu eşleşmelerin gerçekleşmemesinin nedeni, durdurma dizisinin son token ile örtüşmemesidir. Sıralamanın sonundan bir veya daha fazla token kaldırılarak durdurma dizisi bozulmuyorsa, bu kriter o durdurma dizisiyle eşleşmez. Bu, tasarım gereğidir; çünkü bu kontrol her token üretildikten sonra çalıştırılır, geçerli bir durdurma dizisi üretilirse onu kaçırma ihtimalimiz yoktur, ancak durdurma dizisi geçmiş input_ids içinde herhangi bir yerde mevcut olduğu için üretim durdurulmamalıdır.

Peki eşleştirme işlemi fiilen nasıl gerçekleştiriliyor? Bunu oldukça kafa karıştırıcı bir şekilde yapıyoruz, çünkü tüm eşleştirme sürecinin Torch veya XLA ile derlenebilir olmasını istiyoruz; bu da standart string metotlarını kullanamayacağımız anlamına geliyor. Bununla birlikte, biraz iş yaparak saf tensör işlemleriyle string eşleştirme yapmak mümkündür. Önce standart string işlemleriyle kullandığımız algoritmayı tanımlayarak başlayacağız, ardından bunun nasıl saf tensör işlemlerine dönüştürüldüğünü açıklayacağız.

Algoritmanın anahtarı bir gözlemdir: Durdurma dizgesi, token dizisinin sonuyla çakışmak zorunda olduğundan, dizinin sonundan başlayıp geriye doğru ilerleyebiliriz. Spesifik olarak, son token'ın başlangıcı ile stop_string'in sonu arasında bir çakışma olup olmadığını kontrol ederiz; başka bir deyişle, bazı i > 0 değerleri için stop_string[-i:] == token[:i] eşitliği sağlanmalıdır. Yukarıdaki olumlu örneklere baktığınızda, hepsinde son token'ın bu özelliği karşıladığını göreceksiniz:

- ["st", "op"] (örtüşme "op", örtüşme uzunluğu == 2)
- ["stop"]  (örtüşme "stop", örtüşme uzunluğu == 4)
- ["st", "opera"] (örtüşme "op", örtüşme uzunluğu == 2)
- ["sto", "pper"] (örtüşme "p", örtüşme uzunluğu == 1)
- ["las", "topper"] (örtüşme "top", örtüşme uzunluğu == 3)
- ["s", "to", "pped"] (örtüşme "p", örtüşme uzunluğu == 1)

Bu özelliğe sahip olmayan eşleşen bir dizinin oluşturulması imkânsızdır (bunu kendiniz doğrulayabilirsiniz). Ancak, son token'ın başlangıcı ile duraklama dizgesinin sonu arasındaki bu örtüşme bir eşleşme için gerekli olsa da yeterli değildir. Token dizisinin geri kalanının da duraklama dizgesiyle tutarlı olduğunu kontrol etmemiz gerekir.

Bunu nasıl yapıyoruz? ["s", "to", "pped"] dizisini bir örnek olarak ele alalım. Son token olan "pped"in, "stop" durdurma dizgesiyle 1 karakterlik bir örtüşmesi olduğunu biliyoruz. Ardından bir önceki token olan "to"ya geri gideriz. Durdurma dizgesinden zaten 1 karakter eşleştiği için, kontrol edilecek kalan kısım "sto" olur. Bir sonraki token olan "to"nun, kalan kısmın sonuyla eşleşip eşleşmediğini kontrol ederiz; eşleşir. Bu noktada durdurma dizgesinden 3 karakter eşleşmiş olur ve eşleştirilecek kalan kısım "s" olur. Yine bir önceki tokena geri gideriz, bu da "s"tir. Bu bir eşleşmedir ve böylece durdurma dizgesinin tamamı eşleşmiş olur.

Peki, tokenler durdurma dizisinin başından taşarsa nasıl çalışır? ["las", "topper"] örneğini ele alalım. Son token olan "topper", "stop" durdurma dizisiyle 3 uzunluğunda bir örtüşmeye sahiptir. Bu nedenle, eşleştirilmesi gereken kalan durdurma dizesi "s" olur. Bir önceki token olan "las"a geri döneriz. Eşleştirilmesi gereken kalan kısım yalnızca "s" olduğundan ve uzunluğu 1'den ibaret olduğundan, tokenin yalnızca son 1 karakterini, yani "s"i değerlendiririz. Bu, durdurma dizesiyle eşleştiğinden tüm dize eşleşmiş olur.

Peki, bu eşleşmeleri tensör işlemleriyle nasıl hesaplarız? Basitçe: tüm jetonlar için gerekli bilgileri verimli bir şekilde önceden hesaplarız! Her jeton için şunları hesaplarız:
- Durdurma dizininin sonuyla örtüşmesi, varsa
- Durdurma dizisinin içinde, başlangıçtan taşan eşleşmeler de dahil olmak üzere, token'ın eşleştiği konumlar.
- Token'ın toplam uzunluğu

Örneğin, "pped" jetonu için 1 son örtüşme, iç eşleşme konumu yok ve 4 uzunluk hesaplarız. "to" jetonu için son örtüşme yok, 1 iç eşleşme konumu (sondan sayılarak) ve 2 uzunluk hesaplarız. "s" jetonu için son örtüşme yok, 3 iç eşleşme konumu (yine sondan sayılarak) ve 1 uzunluk hesaplarız.

Bu bilgiye sahip olduğumuz sürece, yukarıdaki algoritmayı herhangi bir dize karşılaştırma işlemi yapmadan çalıştırabiliriz. Sadece aşağıdaki adımları uygularız:
- Son token'ın başlangıç dizisiyle bir son-örtüşmesi olup olmadığını kontrol edin
- Geriye doğru ilerlemeye devam edin ve şu ana kadar duraklama dizgesinin ne kadarının eşleştiğini takip edin
- Her noktada, bir sonraki jetonun geçerli konumlarından birinin mevcut konum olup olmadığını kontrol edin
- Bir eşleşme başarısız olana veya durdurma dizisinin tamamı tamamen eşleşene kadar devam edin

Yine ["s", "to", "pped"] örneğini ele alalım. "pped" 1 uzunluğunda bir son örtüşmeye sahip olduğundan bir eşleşmeye başlayabiliriz. Şu ana kadar 1 karakter eşleştirildiğinden, bir sonraki token olan "to" için 1'in geçerli bir konum olup olmadığını kontrol ediyoruz (yine sondan sayıyoruz). Öyle olduğundan, "to"nun uzunluğunu konum izleyicimize ekliyoruz. Şu anda 3 karakter eşleştirildiğinden, bir sonraki token olan "s" için 3'ün geçerli bir konum olup olmadığını kontrol ediyoruz. Öyle olduğundan, uzunluğunu konum izleyicimize ekliyoruz. Konum izleyicisi artık 4'tür ve bu, duraklama dizgesinin uzunluğudur. Duraklama dizgesinin tamamını eşleştirdik.

İkinci durumda, ["las", "topper"] dizisinde "topper" için 3 uzunluğunda bir son örtüşme vardır, bu nedenle bir eşleşmeye başlayabiliriz. Şu ana kadar 3 karakter eşleşti, bu yüzden bir sonraki token olan "las" için 3'ün geçerli bir konum olup olmadığını kontrol ediyoruz. Geçerlidir, çünkü tokenlerin stop dizisinin başından taşan konumlarla eşleşmesine izin veriyoruz. Uzunluğunu konum izleyicisine ekliyoruz. Konum izleyicisi artık 6 ve bu, stop dizisinin uzunluğundan büyük! Panik yapmayın - bu da stop dizisinin bir eşleşmesi olarak sayılır. Stop dizisinin tamamını eşleştirdik.

Örnekler:

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Bir dil modelleme başlığının tahmin puanları, her üretim adımı için bir tensör içeren bir tuple olarak, her biri `(batch_size, config.vocab_size)` biçiminde. Bunlar, SoftMax öncesi her sözlük jetonu için puanlar veya SoftMax sonrası her sözlük jetonu için puanlar olabilir. Bu durdurma kriteri `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun, aksi takdirde `None` iletilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek durdurma kriterleri için özel kwargs.

**Dönüş:** `torch.BoolTensor`. (`torch.BoolTensor`, şekli `(batch_size, 1)`)

`True`, belirli bir satır için üretimin durdurulacağını belirtir. `False`, devam edilmesi gerektiğini belirtir.

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

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

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

**Parametreler:**

eos_token_id (`Union[int, list[int], torch.Tensor]`) : *dizinin sonu* belirtecinin kimlik(leri).

Bu sınıf, "end-of-sequence" token'ı üretildiğinde üretimi durdurmak için kullanılabilir. Varsayılan olarak `model.generation_config.eos_token_id` kullanır.

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

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

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

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi tokenlarının indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)'a bakın. [Girdi kimlikları nelerdir?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Bir dil modelleme başlığının tahmin puanları, her üretim adımı için bir tensör içeren bir tuple olarak, her biri `(batch_size, config.vocab_size)` biçiminde. Bunlar, SoftMax öncesi her sözlük jetonu için puanlar veya SoftMax sonrası her sözlük jetonu için puanlar olabilir. Bu durdurma kriteri `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini iletmenizden emin olun, aksi takdirde `None` iletilir.

new_token_length (`int`, *isteğe bağlı*, varsayılan `1`) : Kriterler için kontrol edilecek token sayısı. Her batch öğesindeki son `new_token_length` token kontrol edilir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek durdurma kriterleri için özel kwargs.

**Dönüş:** `torch.BoolTensor`. (`torch.BoolTensor`, şekli `(batch_size, 1)`)

`True`, belirli bir satır için üretimin durdurulacağını belirtir. `False`, devam edilmesi gerektiğini belirtir.

## Akışlar[[transformers.TextStreamer]]

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

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

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

**Parametreler:**

tokenizer (`AutoTokenizer`) : Tokenları çözmek için kullanılan tokenizer.

skip_prompt (`bool`, *isteğe bağlı*, varsayılan `False`) : `.generate()` için istemi atlayıp atlamayacağı. Örneğin sohbet botları için faydalıdır.

decode_kwargs (`dict`, *isteğe bağlı*) : Tokenizer'ın `decode` yöntemine iletilecek ek anahtar kelime argümanları.

Tam kelimeler oluşturulur oluşturulmaz token(lar)ı stdout'a yazan basit bir metin akışlayıcı.

Örnekler:

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

#### son[[transformers.TextStreamer.end]]

```python
end()
```

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

Kalan önbelleği boşaltır ve stdout'a yeni bir satır basar.

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

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

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

Yeni metni stdout'a yazdırır. Akış sona eriyorsa, bir de yeni satır yazdırır.

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

```python
put(value)
```

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

Tokenları alır, çözer ve tam kelimeler oluşturdukları anda stdout'a basar.

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

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

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

**Parametreler:**

tokenizer (`AutoTokenizer`) : Tokenları çözmek için kullanılan tokenizer.

skip_prompt (`bool`, *isteğe bağlı*, varsayılan `False`) : `.generate()` için istemi atlayıp atlamayacağı. Örneğin sohbet botları için faydalıdır.

timeout (`float`, *isteğe bağlı*) : Metin kuyruğu için zaman aşımı. `None` ise kuyruk sonsuza kadar bekler. Ayrı bir iş parçacığında çağrıldığında `.generate()` içindeki istisnaları işlemek için kullanışlıdır.

decode_kwargs (`dict`, *isteğe bağlı*) : Tokenizer'ın `decode` yöntemine iletilecek ek anahtar kelime argümanları.

Yazdırılmaya hazır metni bir kuyrukta saklayan ve aşağı akışlı bir uygulama tarafından bir iteratör olarak kullanılacak olan streamer. Bu, üretilen metne engelsiz (non-blocking) bir şekilde erişmenin faydalı olduğu uygulamalar için (ör. etkileşimli bir Gradio demosu) kullanışlıdır.

Örnekler:

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

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

Yeni metni kuyruğa koy. Akış sona eriyorsa, kuyruğa bir durma sinyali de koy.

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

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

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

**Parametreler:**

tokenizer (`AutoTokenizer`) : Tokenları çözmek için kullanılan tokenizer.

skip_prompt (`bool`, *isteğe bağlı*, varsayılan `False`) : `.generate()` için istemi atlayıp atlamayacağı. Örneğin sohbet botları için faydalıdır.

timeout (`float`, *isteğe bağlı*) : Metin kuyruğu için zaman aşımı. `None` ise kuyruk sonsuza kadar bekler. Ayrı bir iş parçacığında çağrıldığında `.generate()` içindeki istisnaları işlemek için kullanışlıdır.

decode_kwargs (`dict`, *isteğe bağlı*) : Tokenizer'ın `decode` yöntemine iletilecek ek anahtar kelime argümanları.

**Yükselen:** ``TimeoutError``

- ``TimeoutError`` -- Token üretim süresi zaman aşımı değerini aşıyorsa.

Yazdırılmaya hazır metni bir kuyruğa saklayan ve aşağı akışlı bir uygulama tarafından asenkron bir iteratör olarak kullanılacak olan Streamer. Bu, üretilen metne asenkron olarak erişmenin faydalı olduğu uygulamalar için (ör. etkileşimli bir Gradio demosu) kullanışlıdır.

Örnekler:

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

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

Yeni metni kuyruğa koy. Akış sona eriyorsa, kuyruğa bir durma sinyali de koy.

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

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

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

**Parametreler:**

tokenizer (`AutoTokenizer`) : Tokenları çözmek için kullanılan tokenizer.

skip_prompt (`bool`, *isteğe bağlı*, varsayılan `False`) : `.generate()` için istemi atlayıp atlamayacağı. Örneğin sohbet botları için faydalıdır.

sleep_time (`float`, *isteğe bağlı*) : Difüzyon taslakları arasında uyku süresi; ara çıktıları görselleştirmek için faydalı olabilir.

decode_kwargs (`dict`, *isteğe bağlı*) : Tokenizer'ın `decode` yöntemine iletilecek ek anahtar kelime argümanları.

Metin difüzyon çıktılarını yazdıran bir Streamer. Ara difüzyon adımları (taslaklar) geçicidir, sonraki taslaklar tarafından üzerine yazılır ve onaylı metin yazdırıldığında kaldırılır.

tmux gibi bir ortamda çalışıyorsanız, taslak metin kendini üzerine yazmayı başaramayabilir.

Örnekler:

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

#### son[[transformers.TextDiffusionStreamer.end]]

```python
end()
```

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

Kalan önbelleği boşaltır ve yeni bir satır basar.

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

```python
put(value)
```

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

Onaylanan jetonları alır, taslağı temizler ve bunları kalıcı olarak yazdırır.

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

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

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

Taslak jetonlarının tam dizisini alır, bunları çözer ve sarı renkte basar. Önceki taslağı üzerine yazar.

## Önbellekler[[transformers.CacheLayerMixin]]

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

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

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

Tek bir katmanın önbelleği için temel, soyut sınıf.

#### güncelle[[transformers.CacheLayerMixin.update]]

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

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

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

```python
get_seq_length()
```

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

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

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

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

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

```python
get_max_length()
```

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

Katmanın barındırabileceği maksimum dizi uzunluğunu döndürür. `-1` değeri, maksimumun bulunmadığı ya da tanımsız olduğu anlamına gelir; örneğin sınırsız olarak büyüyen dinamik bir dikkat katmanı veya dizi uzunluğu boyutuna sahip olmayan doğrusal bir dikkat katmanı.

#### sıfırla[[transformers.CacheLayerMixin.reset]]

```python
reset()
```

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

Nesneleri koruyarak önbellek değerlerini sıfırlar

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

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

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

Bu katmanın önbelleğini demet araması için yeniden sıralar.

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

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

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

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

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

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

Daha fazla token üretildikçe dinamik olarak büyüyen bir önbellek katmanıdır. Bu, üretken modeller için varsayılandır. Anahtar ve değer durumlarını `[batch_size, num_heads, seq_len, head_dim]` biçiminde tensörler olarak saklar.

#### güncelle[[transformers.DynamicLayer.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

**Dönüş:** tuple[`torch.Tensor`, `torch.Tensor`]

Anahtar ve değer durumları.

Anahtar ve değer önbelleklerini yerinde güncelleyin ve gerekli anahtar ve değer durumlarını döndürün.

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

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

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

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

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

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

Mevcut önbellek katmanından `tokens_to_remove` belirteçlerini kaldırır.

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

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

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

Önbelleği `repeats` kez parti boyutunda tekrarlayın.

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

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

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

Önbelleğin parti boyutundaki `indices` değerlerini koruyun.

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

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

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

**Parametreler:**

max_cache_len (`int`) : Geriye dönük hesaplamada (backpropagation) saklanacak maksimum token sayısı, tensör ön tahsisi için kullanılır.

`[batch_size, num_heads, max_cache_len, head_dim]` biçiminde statik tensörler olarak anahtar ve değer durumlarını saklayan statik bir önbellek katmanı. Tam destekleyici tensörlerini tembelce tahsis eder ve ardından bunları yerinde değiştirir. `torch.compile` desteği için tasarlanmıştır.

#### güncelle[[transformers.StaticLayer.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

**Dönüş:** tuple[`torch.Tensor`, `torch.Tensor`]

Anahtar ve değer durumları.

Anahtar ve değer önbelleklerini yerinde güncelleyin ve gerekli anahtar ve değer durumlarını döndürün.

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

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

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

Anahtar ve değer tensörlerinin tembel başlatılması. Bu, tüm özelliklerin (TP durumunda dtype, device, num_heads vb.) çalışma zamanında doğrudan alınmasını sağlar; bu, her `update` için daha sonra cihaz, dtype vb. taşımaktan kaçınıldığından son derece pratiktir (bu, statik dynamo adreslerini de bozabilirdi).

İstenmeyen bir durum ise, bu fonksiyonun önceden çağrılmasını sağlamak için Cache üzerinde doğrudan `early_initialization(...)` çağrılabilir (örneğin `torch.export` için bu gereklidir). Ayrıca prefill'in kendisi derlenmiş bir bölgede sonlandığında (örneğin parçalı prefill durumunda) da bu gereklidir.

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

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

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

**Parametreler:**

max_cache_len (`int`) : Geriye dönük hesaplamada (backpropagation) saklanacak maksimum token sayısı, tensör ön tahsisi için kullanılır.

sliding_window (`int`) : Kayan pencerenin boyutu.

`[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]` biçiminde statik tensörler olarak anahtar ve değer durumlarını saklayan statik bir önbellek katmanıdır. Tam destekleyici tensörlerini tembelce tahsis eder ve ardından bunları yerinde değiştirir. `torch.compile` desteği için tasarlanmıştır.

#### güncelle[[transformers.StaticSlidingWindowLayer.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

**Dönüş:** tuple[`torch.Tensor`, `torch.Tensor`]

Anahtar ve değer durumları.

Anahtar ve değer önbelleklerini yerinde güncelleyin ve gerekli anahtar ve değer durumlarını döndürün.

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

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

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

Anahtar ve değer tensörlerinin tembel başlatılması. Bu, tüm özelliklerin (TP durumunda dtype, device, num_heads vb.) çalışma zamanında doğrudan alınmasını sağlar; bu, her `update` için daha sonra cihaz, dtype vb. taşımaktan kaçınıldığından son derece pratiktir (bu, statik dynamo adreslerini de bozabilirdi).

İstenmeyen bir durum ise, bu fonksiyonun önceden çağrılmasını sağlamak için Cache üzerinde doğrudan `early_initialization(...)` çağrılabilir (örneğin `torch.export` için bu gereklidir). Ayrıca prefill'in kendisi derlenmiş bir bölgede sonlandığında (örneğin parçalı prefill durumunda) da bu gereklidir.

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

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

#### güncelle[[transformers.QuantoQuantizedLayer.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

**Dönüş:** tuple[`torch.Tensor`, `torch.Tensor`]

Anahtar ve değer durumları.

Anahtar ve değer önbelleklerini yerinde güncelleyin ve gerekli anahtar ve değer durumlarını döndürün.

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

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

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

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

```python
transformers.HQQQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128)
```

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

#### güncelle[[transformers.HQQQuantizedLayer.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

**Dönüş:** tuple[`torch.Tensor`, `torch.Tensor`]

Anahtar ve değer durumları.

Anahtar ve değer önbelleklerini yerinde güncelleyin ve gerekli anahtar ve değer durumlarını döndürün.

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

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

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

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

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

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

Anahtar ve değer durumlarını 8 bitlik kayan nokta olarak saklayan bir kuantize katman. Gerginlik ölçeği, ilk `update` işleminden sonra dondurulur; bu nedenle yeni durumlar olduğu gibi eklenir: artık önbellek yok, yeniden kuantizasyon yok.

Daha ince taneli bir varyant, `QuantizedLayer` altında değil de burada yer almalıdır; çünkü baş (head) boyutu boyunca gruplama, durumların eklenmesine (appendable) izin verirken depolanan ölçeği (scale) yalnızca bir tensöre dönüştürür.

#### güncelle[[transformers.Fp8QuantizedLayer.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

**Dönüş:** tuple[`torch.Tensor`, `torch.Tensor`]

Anahtar ve değer durumları.

Anahtar ve değer önbelleklerini yerinde güncelleyin ve gerekli anahtar ve değer durumlarını döndürün.

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

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

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

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

```python
transformers.Cache(layers: list[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin | transformers.cache_utils.DummyLayer] | None = None, layer_class_to_replicate: type[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin] | None = None, offloading: bool = False, offload_only_non_sliding: bool = True)
```

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

**Parametreler:**

layers (`Optional`, *isteğe bağlı*) : Önceden oluşturulmuş `CacheLayerMixin` veya `LinearAttentionCacheLayerMixin` listesi. Atlanırsa (`None`), `layer_class_to_replicate` kullanılır.

layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`, *isteğe bağlı*) : Yalnızca `layers` atlanırsa (`None`) kullanılır; bu durumda her katman için temel sınıf olarak kullanılır ve `update`, mevcut katman listesinden büyük bir `layer_idx` ile çağrıldığında katmanlar tembel (lazy) olarak eklenir.

offloading (`bool`, *isteğe bağlı*, varsayılan `False`) : GPU belleğini tasarruflu kullanmak için katmanların `cpu`'ya aktarılmasının (offloading) yapılıp yapılmayacağını belirtir.

offload_only_non_sliding (`bool`, *isteğe bağlı*, varsayılan `True`) : `offloading` `True` ise, bu parametre yalnızca kayan olmayan katmanların mı yoksa tüm katmanların mı offload edileceğini belirler (genellikle kayan katmanlar boyut olarak küçüktür, bu nedenle offload edilmelerine gerek yoktur ve atlamak daha hızlıdır).

`Cache`, büyük ölçüde her model katmanı için bir adet olmak üzere `CacheLayerMixin` nesnelerinden oluşan bir listedir. Her katmanın Cache'ini barındıran bir kapsayıcı olarak görev yapar.

#### güncelle[[transformers.Cache.update]]

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

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

**Parametreler:**

key_states (`torch.Tensor`) : Önbelleğe alınacak yeni anahtar durumları.

value_states (`torch.Tensor`) : Önbelleğe alınacak yeni değer durumları.

layer_idx (`int`) : Durumların önbelleğe alınacağı katmanın indeksi.

**Dönüş:**

Güncellenmiş anahtar ve değer durumlarını içeren bir demet (tuple).

`layer_idx` katmanı için önbelleği yeni `key_states` ve `value_states` ile günceller.

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

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

Tüm katmanları önceden başlatın (aksi halde ilk `update` çağrısında tembel başlatma yapılır). Bu, `export` tariflerimiz için faydalıdır, çünkü `export` her şeyin önceden hazır olmasını gerektirir.

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

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

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

Verilen katman için önbelleğin diziyi uzunluğunu döndürür.

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

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

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

Verilen `layer_idx` katmanı için döndürülecek uzunluk ve ofsete karşılık gelen bir demet (kv_length, kv_offset) döndürür. Maskeler, ardından her katman için verilen uzunluklara (kv_length, kv_offset) ve desenlere göre hazırlanır.

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

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

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

Önbelleğin maksimum uzunluğunu döndürür. `layer_idx` sağlanmazsa (varsayılan), bu, tüm katmanlar arasındaki maksimum değeri döndürür. Aksi halde, verilen katman için desteklenen maksimum değeri döndürür. `-1` değeri, maksimumun bulunmadığını veya tanımsız olduğunu belirtir; örneğin sınırsız olarak büyüyebilen dinamik dikkat katmanları veya bir dizi uzunluğu boyutuna sahip olmayan doğrusal dikkat katmanları için.

#### sıfırla[[transformers.Cache.reset]]

```python
reset()
```

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

Tüm katman tensörlerini özyinelemeli olarak sıfırla

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

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

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

Işın araması için önbelleği yeniden sırala

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

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

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

Mevcut Cache'ten `tokens_to_remove` token'ını kaldırır. Tüm geçmiş durumları bellekte tutmak zorunda olmayan katmanlar için, örneğin kayan pencere katmanları veya doğrusal dikkat katmanları için, bu işlem önbelleğe alınan durumların boyutunu da asgari çalışma boyutuna geri sınırlar. Bu, `crop(0)`'ın her zaman bir no-op (etkisiz işlem) olmayacağı anlamına gelir; çünkü Cache'ten gereksiz durumları (yani bir sonraki `forward` için ihtiyaç duyulmayan durumları) yine de kaldırabilir.

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

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

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

Önbelleği tekrarla ve iç içe geçir

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

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

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

Önbellekten indeksleri seçin

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

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

**Parametreler:**

ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`, *isteğe bağlı*) : Başlangıçta `torch.distributed` (DDP) ile uyumluluk için eklendi. Kısaca, bu `map(gather_map, zip(*caches))` ifadesidir; yani iterable'daki her öğe, torch.distributed tarafından replikalar arasında toplanan bir katman için anahtar ve değer durumlarını içerir (shape=[global batch size, num_heads, seq_len, head_dim]). Not: Doğru çalışması için bu, 1. argüman olarak da geçilmelidir

config (`PreTrainedConfig`, *isteğe bağlı*) : Bu Cache'in kullanılacağı modelin config'i. Verildiğinde, kayan veya hibrit katman yapısını kontrol etmek için kullanılır ve önbelleğe alınan tensörlerin bellek gereksinimini `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]` boyutuna büyük ölçüde düşürür.

offloading (`bool`, *isteğe bağlı*, varsayılan `False`) : GPU belleğini tasarruflu kullanmak için katmanların `cpu`'ya aktarılmasının (offloading) yapılıp yapılmayacağını belirtir.

offload_only_non_sliding (`bool`, *isteğe bağlı*, varsayılan `False`) : `offloading` `True` ise, bu parametre yalnızca kayan olmayan katmanların mı yoksa tüm katmanların mı offload edileceğini belirler (genellikle kayan katmanlar boyut olarak küçüktür, bu nedenle offload etmeye gerek yoktur ve atlamak daha hızlıdır).

Daha fazla token üretildikçe dinamik olarak büyüyen bir önbellek. Bu, üretken modeller için varsayılandır. Anahtar ve değer durumlarını, her katman için bir tane olmak üzere `CacheLayer` listesinin bir öğesi olarak saklar. `CacheLayer` içindeki her tensör için beklenen şekil `[batch_size, num_heads, seq_len, head_dim]`'dir. Bir yapılandırma (config) geçirilirse, kayan veya hibrit önbellek yapısı ayrıca kontrol edilir ve önbelleğe alınan tensörlerin bellek gereksinimi büyük ölçüde `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]` değerine düşürülür.

Tüm önbellek sınıfları tarafından uygulanan ortak yöntemler hakkında ayrıntılar için `Cache`'e bakın.

Örnek:

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

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

**Parametreler:**

config (`PreTrainedConfig`) : Bu Cache'in kullanılacağı modelin yapılandırması. Kayan veya hibrit katman yapısını kontrol etmek ve her katmanı buna göre başlatmak için kullanılacaktır.

max_cache_len (`int`) : Bu Cache'in tutması gereken maksimum token sayısı.

offloading (`bool`, *isteğe bağlı*, varsayılan `False`) : GPU belleğini tasarruflu kullanmak için katmanların `cpu`'ya aktarılmasının (offloading) yapılıp yapılmayacağını belirtir.

offload_only_non_sliding (`bool`, *isteğe bağlı*, varsayılan `True`) : `offloading` `True` ise, bu parametre yalnızca kayan olmayan katmanların mı yoksa tüm katmanların mı offload edileceğini belirler (genellikle kayan katmanlar boyut olarak küçüktür, bu nedenle offload edilmelerine gerek yoktur ve atlamak daha hızlıdır).

`torch.compile(model)` ve `torch.export()` ile kullanılacak Static Cache sınıfı. `config` içinde olası hibrit önbellek yapısını kontrol eder ve her katmanı buna göre başlatır.

Tüm önbellek sınıfları tarafından uygulanan ortak yöntemler hakkında ayrıntılar için `Cache`'e bakın.

Örnek:

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

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

**Parametreler:**

backend (`str`) : Kullanılacak kuantizasyon arka ucu. `("quanto", "hqq", "fp8")` değerlerinden biri.

config (`PreTrainedConfig`) : Bu Cache'in kullanılacağı modelin yapılandırması.

nbits (`int`, *opsiyonel*, varsayılan 4) : Kuantizasyon için bit sayısı.

axis_key (`int`, *opsiyonel*, varsayılan 0) : Anahtarların kuantize edileceği eksen.

axis_value (`int`, *opsiyonel*, varsayılan 0) : Değerlerin kuantize edileceği eksen.

q_group_size (`int`, *opsiyonel*, varsayılan 64) : Kuantizasyon, hem anahtarlar hem de değerler için belirlenen `q_group_size` setine göre kanal başına yapılır.

residual_length (`int`, *isteğe bağlı*, varsayılan 128) : Orijinal hassasiyet önbelleği için maksimum kapasite.

[KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache](https://huggingface.co/papers/2402.02750) makalesinde anlatılanlara benzer bir kuantizör önbelleği. Bu önbellek, kuantizasyon uygulayarak anahtarlar ve değerler için aşırı bellek ayırmadan modelin daha uzun dizi uzunlukları üretmesine olanak tanır. Önbelleğin iki tür depolama alanı vardır: biri orijinal hassasiyet için, diğeri kuantize edilmiş önbellek için. Orijinal hassasiyetli önbelleğin maksimum kapasitesi olarak bir `residual length` belirlenir. Uzunluk bu maksimum kapasiteyi aştığında, orijinal hassasiyetli önbellek atılır ve kuantize edilmiş önbelleğe taşınır. Kuantizasyon, makalede anlatılanların aksine, anahtarlar ve değerler için belirlenmiş bir `q_group_size` ile kanal başına yapılır.

Tüm önbellek sınıfları tarafından uygulanan ortak yöntemler hakkında ayrıntılar için `Cache`'e bakın.

Son beş argüman, grup bazlı tamsayı arka uçlarını yapılandırır. `fp8` arka ucu tensör başına kuantizasyon yapar ve bu argümanları reddeder.

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

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

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

**Parametreler:**

caches (`Iterable`) : Genellikle uzunluğu 2 olan, 2 `Cache` nesnesi içeren bir iterable'dir; ilki self-attention için, ikincisi cross-attention içindir. İsteğe bağlı olarak, uzunluğu 1 olan ve `tuple[tuple[torch.Tensor]]` içeren bir iterable de olabilir (genellikle torch dp ve ddp ile uyumluluk için kullanılır).

Tüm encoder-decoder önbellekleri için temel, soyut sınıf. Kendi dikkat (self-attention) ve çapraz dikkat (cross-attention) önbelleklerinin kombinasyonlarını tutmak için kullanılabilir.

Tüm önbellek sınıfları tarafından uygulanan ortak yöntemler hakkında ayrıntılar için `Cache`'e bakın.

Örnek:

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

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

Önbelleği `repeats` kez parti boyutunda tekrarlayın. Karşılaştırmalı aramada (Hub'da) kullanılır.

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

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

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

Önbelleğin batch boyutundaki `indices` değerlerini koruyun. Karşılaştırmalı aramada (Hub'da) kullanılır.

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

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

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

Mevcut önbellek katmanından `tokens_to_remove` belirteçlerini kaldırır.

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

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

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

Önbellek nesnesinin maksimum dizin uzunluğunu (yani maksimum kapasitesini) döndürür

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

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

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

Önbelleğe alınmış durumların diziyi uzunluğunu döndürür. İsteğe bağlı olarak bir katman indeksi geçirilebilir.

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

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

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

Seçilen ışın indeksleri verildiğinde, ışın araması için önbelleği yeniden sıralar.

## Watermark Yardımcıları[[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)
```

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

Su işareti üretimi için argümanları tutan ve `generate` sırasında `GenerationConfig`'e iletilmesi gereken sınıf. Argümanlar hakkında daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2306.04634) bakın.

Aşağıdaki anahtarları kabul eder:
- greenlist_ratio (`float`): Filigranlama için kullanılır. Sözlük boyutuna oranla kullanılan "yeşil" jetonların oranı. Varsayılan değeri 0.25'tir.
- bias (`float`): Filigranlama ile kullanılır. Seçilen "yeşil" jetonların logitlerine eklenen önyargı. Varsayılan değeri 2.0'dır.
- hashing_key (`int`): Filigranlama için kullanılan özetleme anahtarı. Varsayılan değeri 15485863'tür (bir milyonuncu asal sayı).
- seeding_scheme (`str`): Filigranlama için kullanılacak algoritma. Kabul edilen değerler:
  - "lefthash" (varsayılan): "green" jeton seçimi, son jetona bağlıdır (makaledeki Algoritma 2)
  - "selfhash": "green" token seçimi, mevcut tokenin kendisine bağlıdır (makaledeki Algoritma 3). Bu şemanın dezavantajı, olası tüm sonraki tokenleri dikkate alması ve "lefthash"ten daha yavaş olabilmesidir.
- context_width(`int`): Tohumlama işleminde kullanılacak önceki tokenların bağlam uzunluğu. Bağlam uzunluğu arttıkça filigranlama daha dayanıklı hale gelir.

#### __call__[[transformers.WatermarkingConfig.__call__]]

```python
__call__(*args, **kwargs)
```

self'yi bir fonksiyon olarak çağırın.

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L71)

**Parametreler:**

model_config (`PreTrainedConfig`) : Üretim sırasında kullanılacak model özel argümanlarını almak için kullanılacak model yapılandırması.

device (`str`) : Suya işlenmiş metin üretimi sırasında kullanılan cihaz.

watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : Metin üretimi sırasında kullanılan tam olarak aynı watermarking yapılandırması ve argümanları.

ignore_repeated_ngrams (`bool`, *isteğe bağlı*, varsayılan `False`) : Her benzersiz ngram'in yalnızca bir kez sayılıp sayılmayacağı.

max_cache_size (`int`, *opsiyonel*, varsayılan 128) : Her token için çağrılan seeding/sampling algoritmalarının LRU önbellekleme için kullanılacak en büyük boyut.

Su damgası uygulanmış metinlerin algılanması için algılayıcı. Algılayıcıya, su damgası yeşil listesinin oluşturulmasını yeniden oluşturabilmek ve böylece su damgasını tespit edebilmek için metin üretimi sırasında verilen ayarların aynısının verilmesi gerekir. Bunlar arasında, metin üretimi sırasında kullanılan doğru cihaz, doğru su damgası argümanları ve doğru tokenizer sözlük boyutu yer alır. Kod, [orijinal repoya](https://github.com/jwkirchenbauer/lm-watermarking/tree/main) dayanmaktadır.

Daha fazla bilgi için [makaleye](https://huggingface.co/papers/2306.04634) bakın.

Örnekler:

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L193)

**Parametreler:**

input_ids (`torch.LongTensor`) : Üretilen filigranlı metin. Tespiti etkileyebileceğinden, istemin (prompt) kaldırılması önerilir.

z_threshold (`Dict`, *isteğe bağlı*, varsayılan `3.0`) : Bu eşiği değiştirmek, algılayıcının duyarlılığını değiştirir. Daha yüksek z eşiği daha düşük duyarlılık sağlar, daha düşük z eşiği ise tam tersi şekilde daha yüksek duyarlılık sağlar.

return_dict (`bool`,  *isteğe bağlı*, varsayılan `False`) : `~generation.WatermarkDetectorOutput` döndürülecek mi yoksa döndürülmeyecek mi. Döndürülmezse boolean tahminler döndürülür,

**Dönüş:** `WatermarkDetectorOutput` veya `np.ndarray`

`return_dict=True` ise `WatermarkDetectorOutput`, aksi halde `np.ndarray`.

ma

#### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]]

```python
transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L252)

**Parametreler:**

watermarking_depth (`int`, *isteğe bağlı*) : Turnuva katmanlarının sayısı.

base_rate (`float`, *opsiyonel*, varsayılan 0.5) : Bir metnin filigranlı olma öncel olasılığı P(w).

Bu, [BayesianDetectorModel](/docs/transformers/main/tr/internal/generation_utils#transformers.BayesianDetectorModel) yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Bayesian Detector modeli örneklemek için kullanılır.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

#### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]]

```python
transformers.BayesianDetectorModel(config)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L359)

**Parametreler:**

config ([BayesianDetectorConfig](/docs/transformers/main/tr/internal/generation_utils#transformers.BayesianDetectorConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemeyi sağlamaz, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

Su işareti algılama için Bayes sınıflandırıcısı.

Bu algılayıcı, P(watermarked|g_values) ve P(unwatermarked|g_values) posterior olasılıklarının oranının logaritmasının sigmoidi olan filigran puanını hesaplamak için Bayes kuralını kullanır. Daha fazla ayrıntı için lütfen makaledeki BayesianScore bölümüne bakın. Makale URL'si: https://www.nature.com/articles/s41586-024-08025-4

Bu algılayıcının, Bernoulli(0.5) g-değeri dağılımı kullanan bozulmasız Turnuva tabanlı filigranlamayla çalıştığını unutmayın.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.BayesianDetectorModel.forward]]

```python
forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L448)

**Parametreler:**

g_values (`torch.Tensor`, şekli `(batch_size, seq_len, watermarking_depth, ...)`) : g-değerleri (0 veya 1 değerleri)

mask : Hangi g-değerlerinin kullanılacağını gösteren [batch_size, seq_len] biçiminde ikili bir dizi. Maske değeri 0 olan g-değerleri atılır.

**Dönüş:**

şekli [batch_size] olan p(watermarked | g_values).

Sulandırılmış posterior P(watermarked|g_values) hesaplar.

#### transformers.SynthIDTextWatermarkingConfig[[transformers.SynthIDTextWatermarkingConfig]]

```python
transformers.SynthIDTextWatermarkingConfig(ngram_len: int, keys: list, context_history_size: int = 1024, sampling_table_seed: int = 0, sampling_table_size: int = 65536, skip_first_ngram_calls: bool = False, debug_mode: bool = False)
```

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

**Parametreler:**

ngram_len (`int`) : Ngram uzunluğu.

keys (`list[int]`) : Her derinlik için bir tane olmak üzere filigran anahtarlarından oluşan bir dizi.

context_history_size (`int`, *isteğe bağlı*, varsayılan 1024) : Görülen bağlamları takip etmek için tutulacak tensörün boyutu.

sampling_table_seed (`int`, *opsiyonel*, varsayılan 0) : Örnekleme tablosunu oluşturmak için kullanılan rastgele tohum.

sampling_table_size (`int`, *isteğe bağlı*, varsayılan 65536) : Örnekleme tablosunun boyutu.

skip_first_ngram_calls (`bool`, *isteğe bağlı*, varsayılan `False`) : İlk ngram çağrılarının atlanıp atlanmayacağı.

debug_mode (`bool`, *isteğe bağlı*, varsayılan `False`) : Logitler, watermarking değişikliği uygulanmadan önce elde edilen düzgün bir dağılıma göre değiştirilir. Bu, uygulamanın test edilmesi içindir.

Su işareti üretimi için argümanları tutan ve `generate` sırasında `GenerationConfig`'e iletilmesi gereken sınıf. Argümanlar hakkında daha fazla ayrıntı için [bu makaleye](https://www.nature.com/articles/s41586-024-08025-4) bakın.

Örnekler:
```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)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L492)

**Parametreler:**

detector_module ([BayesianDetectorModel](/docs/transformers/main/tr/internal/generation_utils#transformers.BayesianDetectorModel)) : Parametrelerle başlatılmış Bayesian dedektör modül nesnesi. Kullanım için https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text adresine bakın.

logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : Filigranlama için kullanılan logits işlemcisi.

tokenizer (`Any`) : Model için kullanılan tokenizer.

SynthID metin filigranı algılayıcı sınıfı.

Bu sınıf, eğitimli bayesçi algılayıcı modülü ile başlatılmalıdır; örneğin examples/synthid_text/detector_training.py betiğinde bu algılayıcı modülünün eğitimi/kaydedilmesi/yüklenmesi gösterilmektedir. Klasör ayrıca bu algılayıcının örnek kullanım senaryosunu da sergilemektedir.

Örnekler:
```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)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L539)

## Derleme Yardımcıları[[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)
```

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

**Parametreler:**

fullgraph (`bool`, *isteğe bağlı*, varsayılan `False`) : False ise (varsayılan), optimize edilecek derlenebilir bölgeleri keşfetmeye çalışır. True ise, tüm işlevin tek bir grafiğe yakalanabilir olmasını gerektirir. Bu mümkün değilse (yani, grafik kırılmaları varsa), bir hata oluşturulur.

dynamic (`bool` veya `None`, *isteğe bağlı*) : Dinamik şekil grafiklerinin kullanılmaya çalışılıp çalışılmayacağı.

backend (`str` veya `Callable`, *isteğe bağlı*, varsayılan `"inductor"`) : Kullanılacak arka uç.

mode (`str`, *isteğe bağlı*, varsayılan `"reduce-overhead"`) : Performans ve ek yük arasındaki dengeyi kontrol eder.

options (`dict`, *isteğe bağlı*) : Arka uca iletilecek seçeneklerin sözlüğü.

`generate` içinde otomatik derleme kullanılırken `torch.compile` davranışına ilişkin argümanları tutan sınıf. Argümanlar hakkında daha fazla ayrıntı için [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html) bölümüne bakın.

Örnekler:
```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)
```

self'yi bir fonksiyon olarak çağırın.