# Üretim

Her framework, metin üretimi için kendi `GenerationMixin` sınıfında uygulanan bir generate yöntemine sahiptir:

- PyTorch [generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate), [GenerationMixin](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin) içinde uygulanmıştır.

generate metodunu bir [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig) sınıfı örneğiyle parametreleyebilirsiniz. Üretim metodunun davranışını kontrol eden üretim parametrelerinin tam listesi için lütfen bu sınıfa başvurun.

Bir modelin üretim yapılandırmasını nasıl inceleyeceğinizi, varsayılanların neler olduğunu, parametrelerin ad hoc olarak nasıl değiştirileceğini ve özelleştirilmiş bir üretim yapılandırmasının nasıl oluşturulup kaydedileceğini öğrenmek için [metin üretim stratejileri kılavuzuna](../generation_strategies) başvurun. Kılavuz, token akışı gibi ilgili özelliklerin nasıl kullanılacağını da açıklar.

## GenerationConfig[[transformers.GenerationConfig]]

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

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

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

**Çıktı uzunluğunu kontrol eden parametreler:**

max_length (`int`, *isteğe bağlı*) : Modelin kaç token üreteceğini kontrol etmek için `max_new_tokens` önerilir. `max_length` geriye dönük uyumluluk için korunmuştur.

max_new_tokens (`int`, *isteğe bağlı*) : İstekteki token sayısını göz ardı ederek üretilecek maksimum token sayısı.

min_length (`int`, *isteğe bağlı*) : Üretilecek dizinin minimum uzunluğu. Girdi isteminin uzunluğu + `min_new_tokens` değerine karşılık gelir. `min_new_tokens` de ayarlanmışsa, etkisi `min_new_tokens` tarafından geçersiz kılınır.

min_new_tokens (`int`, *isteğe bağlı*) : İstemindeki token sayısını göz ardı ederek üretilecek en az token sayısı.

early_stopping (`bool` veya `str`, *isteğe bağlı*) : beam-search gibi beam tabanlı yöntemler için durdurma koşulunu kontrol eder. Aşağıdaki değerleri kabul eder: `True`, üretim `num_beams` tam aday olduğu anda durur; `False`, bir heuristik uygulanır ve daha iyi adayların bulunma olasılığı çok düşük olduğunda üretim durur; `"never"`, beam search prosedürü daha iyi adayların olamayacağı duruma kadar devam eder (kanonik beam search algoritması).

max_time (`float`, *isteğe bağlı*) : Hesaplamaya saniye cinsinden izin verdiğiniz maksimum süre. Belirlenen süre aşıldıktan sonra generation, geçerli geçişi yine de tamamlar.

stop_strings (`str` veya `list[str]`, *isteğe bağlı*) : Model bunları çıktılarsa üretimi sonlandırmak için gereken bir dize veya dize listesi.

**Üretim stratejisini kontrol eden parametreler:**

do_sample (`bool`) : Örnekleme kullanılıp kullanılmayacağı; aksi takdirde açgözlü çözümleme (greedy decoding) kullanılır.

num_beams (`int`, *isteğe bağlı*) : Işın araması için ışın sayısı. 1, ışın aramasının yapılmadığını belirtir.

use_mtp : (`bool`): Model destekliyorsa Multi-Token Prediction (MTP) kullanılacak mı?

**Önbelleği kontrol eden parametreler:**

use_cache (`bool`) : Modelin, çözümlendirmeyi hızlandırmak için (modele uygulanabilirse) geçmiş son anahtar/değer dikkatlerini kullanıp kullanmaması.

cache_implementation (`str`, *isteğe bağlı*) : `generate` içinde daha hızlı çözümleme için örneklemesi yapılacak önbellek sınıfının adı. Olası değerler şunlardır:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/tr/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/tr/internal/generation_utils#transformers.QuantizedCache)  Hiçbiri belirtilmezse, modelin varsayılan önbelleği (çoğu zaman [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache)) kullanılır. Daha fazla bilgi için [önbellek belgelerimize](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

cache_config (`dict`, *isteğe bağlı*, varsayılan `None`) : Anahtar-değer önbellek sınıfında kullanılan argümanlar `cache_config` içinde geçirilebilir.

max_cache_len (`int`, *isteğe bağlı*) : Yalnızca statik önbelleklerle kullanılır (`cache_implementation` değeri `"static"` veya `"offloaded_static"` olarak ayarlandığında). Önbelleğin boyutunu, mevcut çağrının `max_length` değeri yerine bu uzunluğa önceden ayarlar. Tekrarlanan `generate()` çağrılarında daha uzun bir istem veya daha büyük bir `max_new_tokens` (bu üst sınıra kadar) kullanıldığında yeniden tahsis ve `torch.compile` yeniden derlemesini tetiklemek yerine aynı önbelleğin yeniden kullanılmasını sağlamak için, beklediğiniz en büyük çağrıya bir kez ayarlayın.

**Model çıktı logitlerinin manipülasyonu için parametreler:**

temperature (`float`, *isteğe bağlı*) : Bir sonraki token olasılıklarını modüle etmek için kullanılan değer. Bu değer, bir modelin `generation_config.json` dosyasında ayarlanır. Ayarlanmamışsa, varsayılan değer 1.0'dır.

top_k (`int`, *isteğe bağlı*) : top-k filtreleme için en yüksek olasılığa sahip kaç sözlük token'ının tutulacağını belirler. Bu değer, modelin `generation_config.json` dosyasında ayarlanır. Ayarlanmamışsa, varsayılan değer 50'dir.

top_p (`float`, *isteğe bağlı*) : float < 1 olarak ayarlanırsa, olasılıkları `top_p` veya daha yüksek bir toplamda birleşen en küçük en olası token kümesi üretime dahil edilir. Bu değer, modelin `generation_config.json` dosyasında ayarlanır. Ayarlanmamışsa varsayılan değer 1.0'dır.

min_p (`float`, *isteğe bağlı*) : 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).

top_h (`float`, *isteğe bağlı*) : Örnekleme sırasında dağılımın entropisinin ne kadarının korunduğunu kontrol eden entropi bütçesi ölçekleme çarpanı. 0 ile 1 arasında bir değer olmalıdır. Her adımda, jetonlar olasılığa göre sıralanır ve *yeniden normalize edilmiş* entropisi, tam dağılımın entropisinin `top_h` katına eşit veya daha küçük olan en küçük jeton öneki korunur. Daha küçük değerler (ör. 0.2–0.5) daha odaklı ve deterministik çıktılara yol açarken, 1.0'a yakın değerler daha fazla rastgelelik ve çeşitlilik sağlar. Tipik değerler 0.3–0.6 aralığındadır.

typical_p (`float`, *isteğe bağlı*) : Local typicality, üretilen kısmi metin verildiğinde, bir sonraki hedef token'ı tahmin etmenin koşullu olasılığının, bir sonraki rastgele bir token'ı tahmin etmenin beklenen koşullu olasılığına ne kadar benzer olduğunu ölçer. float < 1 olarak ayarlanırsa, olasılıkları `typical_p` veya daha yüksek bir toplamda birleşen en küçük yerel tipik token kümesi üretim için korunur. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2202.00666) bakın.

epsilon_cutoff (`float`, *isteğe bağlı*) : 0 ile 1 arasında kesin bir float değere ayarlanırsa, yalnızca koşullu olasılığı `epsilon_cutoff` değerinden büyük olan token'lar örneklenir. Makalede, modelin boyutuna bağlı olarak önerilen değerler 3e-4 ile 9e-4 arasında değişmektedir. Daha fazla ayrıntı için [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) başlıklı makaleye bakın.

eta_cutoff (`float`, *isteğe bağlı*) : Eta örneklemesi, yerel tipik örneklemesi ve epsilon örneklemesinin bir hibrididir. 0 ile 1 arasında katı bir float olarak ayarlanırsa, bir token yalnızca `eta_cutoff` veya `sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits)))` değerlerinden birinden büyükse dikkate alınır. İkinci terim, sezgisel olarak `sqrt(eta_cutoff)` ile ölçeklendirilmiş beklenen sonraki token olasılığıdır. Makalede, modelin boyutuna bağlı olarak önerilen değerler 3e-4 ile 2e-3 arasında değişmektedir. Daha fazla ayrıntı için [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) makalesine bakın.

repetition_penalty (`float`, *isteğe bağlı*) : Tekrar cezası parametresi. 1.0 ceza uygulanmadığı anlamına gelir. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/1909.05858) bakın.

encoder_repetition_penalty (`float`, *isteğe bağlı*) : encoder_repetition_penalty parametresi. Orijinal girdide bulunmayan dizilere uygulanan üstel ceza. 1.0 ceza uygulanmadığı anlamına gelir.

length_penalty (`float`, *opsiyonel*) : Işın tabanlı üretimde uzunluk için kullanılan üstel ceza. Bu ceza, dizinin uzunluğuna üstel olarak uygulanır ve sonuç, dizinin puanını bölmek için kullanılır. Puan, dizinin log olasıklığı olduğu için (yani negatif olduğu için), `length_penalty` > 0.0 daha uzun dizileri teşvik ederken, `length_penalty` < 0.0 daha kısa dizileri teşvik eder.

no_repeat_ngram_size (`int`, *opsiyonel*) : int > 0 olarak ayarlanırsa, bu boyuttaki tüm ngram'lar yalnızca bir kez görünebilir.

bad_words_ids (`list[list[int]]`, *isteğe bağlı*) : Üretilmesine izin verilmeyen token kimliklerinin listesi. Daha fazla belge ve örnek için [NoBadWordsLogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.NoBadWordsLogitsProcessor) sınıfına bakın.

renormalize_logits (`bool`) : Tüm logits işleyicileri (özel olanlar dahil) uygulandıktan sonra logits'lerin yeniden normalize edilip edilmeyeceğini belirtir. Arama algoritmaları, skor logits'lerinin normalize edildiğini varsaydığından ancak bazı logits işleyicileri normalizasyonu bozduğundan, bu bayrağın `True` olarak ayarlanması şiddetle önerilir.

forced_bos_token_id (`int`, *isteğe bağlı*, varsayılan `model.config.forced_bos_token_id`) : `decoder_start_token_id` sonrasında ilk üretilen token olarak zorlanacak token'ın kimliği. İlk üretilen token'ın hedef dil token'ı olması gereken [mBART](../model_doc/mbart) gibi çok dilli modeller için faydalıdır.

forced_eos_token_id (`int` or list[int]`, *optional*, defaults to `model.config.forced_eos_token_id`) : The id of the token to force as the last generated token when `max_length` is reached. Optionally, use a list to set multiple *end-of-sequence* tokens.

remove_invalid_values (`bool`) : Modelin olası *nan* ve *inf* çıktılarını, üretim yönteminin çökmesini önlemek için kaldırılacak mı? `remove_invalid_values` kullanmanın üretimi yavaşlatabileceğini unutmayın.

exponential_decay_length_penalty (`tuple(int, float)`, *isteğe bağlı*) : Bu Tuple, belirli bir sayıda token üretildikten sonra üstel olarak artan bir uzunluk cezası ekler. Tuple şu öğelerden oluşmalıdır: `(start_index, decay_factor)` burada `start_index` cezanın nerede başlayacağını belirtir ve `decay_factor` üstel azalmanın katsayısını temsil eder

suppress_tokens (`list[int]`, *isteğe bağlı*) : Üretim sırasında bastırılacak jetonların listesi. `SuppressTokens` logit işlemcisi, bunların log olasılıklarını `-inf` olarak ayarlayarak örneklenmelerini engeller.

begin_suppress_tokens  (`list[int]`, *isteğe bağlı*) : Üretimin başlangıcında bastırılacak tokenların listesi. `SuppressBeginTokens` logit işlemcisi, bunların log olasılıklarını `-inf` olarak ayarlayarak örneklenmelerini engeller.

sequence_bias (`dict[tuple[int], float]`, *isteğe bağlı*)) : Bir token dizisini, o dizinin sapma terimine eşleyen sözlük. Pozitif sapmalar, dizinin seçilme olasılığını artırırken, negatif sapmalar tam tersini yapar. Daha fazla belge ve örnek için [SequenceBiasLogitsProcessor](/docs/transformers/main/tr/internal/generation_utils#transformers.SequenceBiasLogitsProcessor)'ye bakın.

token_healing (`bool`) : İstemlerin kuyruk token'larını uygun uzantılarıyla değiştirerek onarır. Bu, açgözlü tokenizasyon yanlılığından etkilenen istemlerde tamamlamaların kalitesini artırır.

guidance_scale (`float`, *isteğe bağlı*) : 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, genellikle daha düşük kalite pahasına.

watermarking_config (`BaseWatermarkingConfig` veya `dict`, *isteğe bağlı*) : Model çıktılarını, rastgele seçilen "yeşil" token kümesine küçük bir önyargı ekleyerek filigran eklemek için kullanılan argümanlar. Daha fazla ayrıntı için [SynthIDTextWatermarkingConfig](/docs/transformers/main/tr/internal/generation_utils#transformers.SynthIDTextWatermarkingConfig) ve [WatermarkingConfig](/docs/transformers/main/tr/internal/generation_utils#transformers.WatermarkingConfig) belgelerine bakın. `Dict` olarak geçirilirse, içsel olarak `WatermarkingConfig` nesnesine dönüştürülür.

**generate'in çıktı değişkenlerini tanımlayan parametreler:**

num_return_sequences (`int`, *isteğe bağlı*) : Her bir parti öğesi için bağımsız olarak hesaplanan ve döndürülen dizilerin sayısı.

output_attentions (`bool`) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

output_scores (`bool`) : Tahmin skorlarının döndürülüp döndürülmemeye karar verir. Daha fazla ayrıntı için döndürülen tensörler altındaki `scores` bölümüne bakın.

output_logits (`bool`) : İşlenmemiş tahmin logit puanlarının döndürülüp döndürülmemeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `logits` bölümüne bakın.

return_dict_in_generate (`bool`) : Sadece üretilen diziyi döndürmek yerine bir [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülüp döndürülmediğini belirtir. Üretim önbelleğinin (eğer `use_cache` `True` ise) veya isteğe bağlı çıktıların (`output_` ile başlayan bayraklara bakınız) döndürülmesi için bu bayrağın `True` olarak ayarlanması gerekir.

**Üretim sırasında kullanılabilen özel jetonlar:**

pad_token_id (`int`, *isteğe bağlı*) : *padding* belirtecinin kimliği.

bos_token_id (`int`, *isteğe bağlı*) : *dizinin başlangıcı* belirtecinin kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*) : *dizinin sonu* belirtecinin kimliği. Birden fazla *dizinin sonu* belirteci ayarlamak için isteğe bağlı olarak bir liste kullanın.

**Sadece kodlayıcı-çözücü modellerine özgü üretim parametreleri:**

encoder_no_repeat_ngram_size (`int`, *isteğe bağlı*) : int > 0 olarak ayarlanırsa, `encoder_input_ids` içinde görülen o boyuttaki tüm n-gramlar `decoder_input_ids` içinde görülemez.

decoder_start_token_id (`int` veya `list[int]`, *isteğe bağlı*) : Bir kodlayıcı-çözücü modeli, *bos* ile farklı bir token ile çözmeye başlıyorsa, o token'ın kimliği veya `batch_size` uzunluğunda bir liste. Bir liste belirtmek, batch'teki her öğe için farklı başlangıç kimliklerini etkinleştirir (ör. bir batch içinde farklı hedef dillere sahip çok dilli modeller)

**Yalnızca asistan üretimi için geçerli üretim parametreleri:**

is_assistant (`bool`) : Modelin bir asistan (taslak) modeli olup olmadığı.

num_assistant_tokens (`int`, *isteğe bağlı*) : Her yinelemede hedef model tarafından kontrol edilmeden önce asistan modelinin üreteceği _spekülatif token_ sayısını tanımlar. `num_assistant_tokens` için daha yüksek değerler üretimi daha _spekülatif_ hale getirir: Asistan modeli performanslıysa daha büyük hızlanmalar elde edilebilir, asistan modeli çok fazla düzeltme gerektiriyorsa daha düşük hızlanmalar elde edilir.

num_assistant_tokens_schedule (`str`, *isteğe bağlı*) : Enformans sırasında max asistan tokenlarının değiştirileceği zamanlamayı tanımlar. - `"heuristic"`: Tüm spekülatif tokenlar doğruysa `num_assistant_tokens` değerini 2 artırır, aksi halde 1 azaltır. `num_assistant_tokens` değeri, aynı asistan modeliyle yapılan birden fazla üretim çağrısı boyunca kalıcıdır. - `"heuristic_transient"`: `"heuristic"` ile aynıdır ancak `num_assistant_tokens`, her üretim çağrısından sonra başlangıç değerine sıfırlanır. - `"constant"`: `num_assistant_tokens`, üretim sırasında değiştirilmez

assistant_confidence_threshold (`float`, *isteğe bağlı*) : Asistan modelinin güven eşiği. Asistan modelinin mevcut token için tahminine olan güveni bu eşiğin altındaysa, _spekülatif token_ sayısı (`num_assistant_tokens` ile tanımlanan) henüz ulaşılmamış olsa bile asistan modeli mevcut token üretim yinelemesini durdurur. Asistanın güven eşiği, gereksiz taslak ve hedef ileri geçişlerinin sayısını azaltmak amacıyla spekülatif yinelemeler boyunca, yanlış negatiflerden kaçınmaya yönelik bir eğilimle ayarlanır. `assistant_confidence_threshold` değeri, aynı asistan modeliyle yapılan birden fazla üretim çağrısı boyunca kalıcıdır. Dynamic Speculation Lookahead Accelerates Speculative Decoding of Large Language Models makalesindeki dinamik spekülasyon ileri bakışının denetimsiz bir versiyonudur.

prompt_lookup_num_tokens (`int`, *isteğe bağlı*) : Aday token olarak çıkarılacak token sayısı.

max_matching_ngram_size (`int`, *opsiyonel*) : İstemde eşleştirme için dikkate alınacak en büyük ngram boyutu. Verilmezse varsayılan olarak 2'dir.

assistant_early_exit(`int`, *optional*) : Pozitif bir tamsayı olarak ayarlanırsa, modelin erken çıkışı (early exit) bir asistan olarak kullanılacaktır. Yalnızca erken çıkışı destekleyen modellerle (yani ara katmanlardan gelen logit'lerin LM başlığı tarafından yorumlanabildiği modeller) kullanılabilir.

assistant_lookbehind(`int`, *isteğe bağlı*) : Pozitif bir tam sayı olarak ayarlanırsa, yeniden kodlama işlemi, token'ları doğru şekilde hizalamak için son `assistant_lookbehind` asistan token'larını da dikkate alır. Yalnızca spekülatif çözümlendirmede farklı tokenizörler kullanılırken kullanılabilir. Daha fazla ayrıntı için bu [blog](https://huggingface.co/blog/universal_assisted_generation)'a bakın.

target_lookbehind(`int`, *optional*) : Pozitif bir tamsayıya ayarlanırsa, yeniden kodlama süreci, token'ları doğru şekilde hizalamak için son `target_lookbehind` hedef token'larını da dikkate alır. Yalnızca spekülatif çözümlendirmede farklı tokenizörlerle kullanılabilir. Daha fazla ayrıntı için bu [blog](https://huggingface.co/blog/universal_assisted_generation)'a bakın.

assistant_ensemble_weight (`float`, *isteğe bağlı*) : Spekülatif çözümlendirmede statik ensemble doğrulamasını etkinleştirir. `(0.0, 1.0)` aralığında bir değere ayarlanırsa, doğrulayıcı jetonları `p_target` yerine `w * p_target + (1 - w) * q_draft` karışımına karşı kabul eder; böylece kontrollü bir dağılımsal sapma, daha yüksek bir kabul oranı karşılığında takas edilir. Varsayılan değer `None`'dir ve bu, çözümlendirmenin kayıpsız kalmasını sağlar. Asistan modelinin logit'leri döndürmesini gerektirdiğinden, prompt arama çözümlendirmesiyle uyumlu değildir.

speculation_type (`str`, *isteğe bağlı*) : İstenen spekülasyon türü. Kabul edilen değerler `dflash`.

**Performans ve derlemeyle ilgili parametreler:**

compile_config (CompileConfig, *isteğe bağlı*) : Derlenebilir bir önbellek kullanılıyorsa, bu, `generate`'in daha hızlı çıkarım için ileri geçişi nasıl `compile` edeceğini kontrol eder.

disable_compile (`bool`) : İleri geçişin otomatik derlenmesini devre dışı bırakıp bırakmayacağını belirtir. Otomatik derleme, derlenebilir bir önbellek kullanılması dahil olmak üzere belirli kriterler karşılandığında gerçekleşir. Bu bayrağı kullanma ihtiyacı hissederseniz lütfen bir sorun (issue) açın.

Bir üretim görevi için yapılandırmayı tutan sınıf. Bir `generate` çağrısı, metin-çözücü, metinden-metine, ses-metne ve görü-metne modelleri için aşağıdaki üretim yöntemlerini destekler:

- `num_beams=1` ve `do_sample=False` ise *greedy decoding*
- `num_beams=1` ve `do_sample=True` ise *multinomial sampling*
- `num_beams>1` ve `do_sample=False` ise *beam-search decoding*
- `num_beams>1` ve `do_sample=True` ise *beam-search multinomial sampling*
- `assistant_model` veya `prompt_lookup_num_tokens` `.generate()` fonksiyonuna geçiriliyorsa *assisted decoding*

Çözme stratejileri hakkında daha fazla bilgi için [metin oluşturma stratejileri kılavuzuna](../generation_strategies) bakın.

Bu bayrakların büyük bir kısmı, üretimin logitlerini veya durdurma kriterlerini kontrol eder. Olası manipülasyonların tam açıklaması ve kullanım örnekleri için [generate ile ilgili sınıfları](https://huggingface.co/docs/transformers/internal/generation_utils) kontrol etmeyi unutmayın.

Not: Hâlâ `None` olan yapılandırma alanları, üretim döngüsü sırasında `GenerationConfig._get_default_generation_params()` tarafından geçersiz kılınır. Bu alanlar için farklı değerler kullanmak istiyorsanız, bunları üretim yapılandırmasında açıkça belirlemeye özen gösterin.

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

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

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

**Parametreler:**

pretrained_model_name (`str` veya `os.PathLike`) : Şu seçeneklerden biri olabilir:  - huggingface.co üzerindeki bir model deposunda barındırılan önceden eğitilmiş bir model yapılandırmasının *model kimliği* olan bir dize. - [save_pretrained()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig.save_pretrained) yöntemiyle kaydedilmiş bir yapılandırma dosyası içeren bir *dizin* yolu, örneğin `./my_model_directory/`.

config_file_name (`str` veya `os.PathLike`, *isteğe bağlı*, varsayılan `"generation_config.json"`) : `pretrained_model_name` içinden yüklenecek üretim yapılandırması JSON dosyasının adı.

cache_dir (`str` veya `os.PathLike`, *isteğe bağlı*) : Standart önbellek kullanılmayacaksa, indirilen önceden eğitilmiş model yapılandırmasının önbelleğe alınacağı dizinin yolu.

force_download (`bool`, *isteğe bağlı*, varsayılan `False`) : Yapılandırma dosyalarının indirilmesini (yeniden) zorlayıp indirmeyecek ve varsa önbellekteki sürümleri geçersiz kılıp kılmayacağını belirtir.

proxies (`dict[str, str]`, *isteğe bağlı*) : Protokol veya uç nokta bazında kullanılacak vekil sunucuların sözlüğü, örn. `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Vekiller her istekte kullanılır.

token (`str` veya `bool`, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak belirteç. `True` ise veya belirtilmezse, `hf auth login` çalıştırıldığında oluşturulan belirteç ( `~/.huggingface` içinde saklanır) kullanılır.

revision (`str`, *isteğe bağlı*, varsayılan `"main"`) : Kullanılacak belirli model sürümü. huggingface.co üzerinde modelleri ve diğer artefaktları depolamak için git tabanlı bir sistem kullandığımız için, bir dal adı, etiket adı veya commit kimliği olabilir; bu nedenle `revision`, git tarafından izin verilen herhangi bir tanımlayıcı olabilir.    Hub'da oluşturduğunuz bir pull request'i test etmek için `revision="refs/pr/<pr_number>"` parametresini iletebilirsiniz.

return_unused_kwargs (`bool`, *isteğe bağlı*, varsayılan `False`) : `False` ise, bu fonksiyon yalnızca son yapılandırma nesnesini döndürür. `True` ise, bu fonksiyon `Tuple(config, unused_kwargs)` döndürür; burada *unused_kwargs*, anahtarları yapılandırma öznitelikleri olmayan anahtar/değer çiftlerinden oluşan bir sözlüktür; yani `kwargs` içindeki, `config` nesnesini güncellemek için kullanılmamış ve aksi halde yok sayılan kısımdır.

subfolder (`str`, *isteğe bağlı*, varsayılan `""`) : İlgili dosyalar huggingface.co üzerindeki model deposunun bir alt klasöründe bulunuyorsa, buraya klasör adını belirtebilirsiniz.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : kwargs içindeki değerlerden, anahtarları yapılandırma öznitelikleri olanlar, yüklenen değerlerin üzerine yazmak için kullanılacaktır. Anahtarları yapılandırma öznitelikleri *olmayan* anahtar/değer çiftlerinin davranışı, `return_unused_kwargs` anahtar parametresi tarafından kontrol edilir.

**Dönüş:** [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig)

Bu önceden eğitilmiş modelden örneklenen yapılandırma nesnesi.

Bir üretim yapılandırma dosyasından [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig) örneği oluşturun.

Örnekler:

```python
>>> from transformers import GenerationConfig

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

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

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

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

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

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

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

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

**Parametreler:**

model_config (`PreTrainedConfig | dict`) : Üretim yapılandırmasının oluşturulmasında kullanılacak model yapılandırması.

**Dönüş:** [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig)

Bu parametrelerden örneklenen yapılandırma nesnesi.

Bir [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) nesnesinden bir [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig) örnekler. Bu işlev, üretim parametreleri içerebilen eski [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) nesnelerini bağımsız bir [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig) nesnesine dönüştürmek için kullanışlıdır.

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

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

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

**Parametreler:**

save_directory (`str` veya `os.PathLike`) : Yapılandırma JSON dosyasının kaydedileceği dizin (varsa oluşturulur).

config_file_name (`str` veya `os.PathLike`, *isteğe bağlı*, varsayılan `"generation_config.json"`) : `save_directory` içinde kaydedilecek üretim yapılandırması JSON dosyasının adı.

push_to_hub (`bool`, *isteğe bağlı*, varsayılan `False`) : Modeli kaydettikten sonra Hugging Face model hub'ına gönderip göndermeyeceğinizi belirtir. Göndermek istediğiniz depoyu `repo_id` ile belirleyebilirsiniz (varsayılan olarak ad alanınızdaki `save_directory` adı kullanılır).

kwargs (`dict[str, Any]`, *isteğe bağlı*) : [push_to_hub()](/docs/transformers/main/tr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) yöntemine iletilen ek anahtar kelime argümanları.

Bir nesil yapılandırma nesnesini, [from_pretrained()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig.from_pretrained) sınıf yöntemiyle yeniden yüklenebilmesi için `save_directory` dizinine kaydedin.

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

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

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

**Parametreler:**

defaults_only (`bool`, *isteğe bağlı*, varsayılan `False`) : `kwargs` ile config'deki tüm anahtarların mı yoksa yalnızca `None` (yani varsayılan değer) olarak ayarlananların mı güncelleneceğini belirtir.

allow_custom_entries (`bool`, *isteğe bağlı*, varsayılan `False`) : Mevcut yapılandırmada bulunmuyorsa, `kwargs` ile özel girdilerin yapılandırmaya eklenmesine izin verilip verilmeyeceğini belirtir.

kwargs (`dict[str, Any]`) : Bu sınıfı geçici olarak güncellemek için nitelikler sözlüğü.

**Dönüş:** `dict[str, Any]`

Örneği güncellemek için kullanılmayan tüm anahtar-değer çiftlerini içeren sözlük.

Bu sınıf örneğinin özniteliklerini, `kwargs` içindeki öznitelikler mevcut özniteliklerle eşleşiyorsa onlarla günceller ve kullanılmayan tüm kwargs'ları döndürür.

#### doğrula[[transformers.GenerationConfig.validate]]

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

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

**Parametreler:**

strict (bool) : True ise, bulunan herhangi bir sorun için bir istisna fırlatılır. False ise, yalnızca sorunlar günlüğe kaydedilir.

user_set_attributes (set[str], *opsiyonel*) : Çağıranın açıkça sağladığı öznitelik adları. Sağlandığında, çakışan bayrak kombinasyonlarına (ör. `do_sample=False` iken yalnızca örneklemeye ait bayrakların ayarlanması) ilişkin "küçük sorun" uyarıları, yalnızca çakışan bayrak bu kümede varsa tetiklenir -- bu da değerin modelin varsayılan `generation_config.json`'inden devralınması durumunda gürültülü uyarıları önler. `None` olduğunda, ayarlanmış tüm öznitelikler kullanıcı tarafından ayarlanmış olarak kabul edilir (doğrudan `validate()` çağrıları için geriye dönük uyumlu davranış).

[GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig) örneğinin öznitelik değerlerini doğrular. Yalnızca yapılandırma örneğinden tespit edilebilecek hatalı parametrelendirmelerin varlığında istisnalar fırlatır.

Burada doğrulanmayan bazı parametrelerin, diğer girdilere ve/veya modele bağlı olabileceğinden (üretim uzunluğuyla ilgili parametreler gibi) generate çalışma zamanında doğrulanmasının en iyi sonuçları vereceğini unutmayın.

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

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

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

**Parametreler:**

assistant_model (`PreTrainedModel`, *isteğe bağlı*) : Destekli üretim için kullanılacak asistan modeli. Ayarlanırsa, üretim modu destekli üretim olacaktır.

**Dönüş:** `GenerationMode`

Örnek tarafından tetiklenen üretim modu.

[GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig) örneğinin tetiklediği üretim modunu döndürür.

## GenerationMixin[[transformers.GenerationMixin]]

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

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

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

Model sınıflarında karışım (mixin) olarak kullanılacak, otomatik-geriye dönük (auto-regressive) metin üretimi için tüm işlevleri içeren bir sınıf. Bu sınıftan türetme, modelin başlatma sırasında bir `GenerationConfig` yüklemesi veya `transformers` CI'de `generate`-ile ilgili testlerin çalıştırılmasını sağlama gibi üretimle ilgili özel davranışlara sahip olmasına neden olur.

Bir model sınıfı, `generate` gibi yöntemlerin çağrılmasını etkinleştirmek için veya `GenerationMixin`'e doğrudan veya dolaylı olarak bağımlı, `generate` gibi herkese açık yöntemlerle yaklaşık olarak aynı arayüze sahip özel bir `generate` yöntemi tanımladığında, `GenerationMixin`'den devralmalıdır. Üç örnek:
- `LlamaForCausalLM`, mixin içindeki `generate` ve diğer genel yöntemlerin çağrılabilmesini sağlamak için `GenerationMixin`'den devralmalıdır;
- `BlipForQuestionAnswering`, `GenerationMixin.generate` ile yaklaşık olarak aynı arayüze sahip özel bir `generate` yöntemine sahiptir (birkaç ek argümanı ve aynı çıktısı vardır). Bu fonksiyon ayrıca, iç bir model aracılığıyla dolaylı olarak `GenerationMixin.generate` çağrısını yapar. Bu nedenle, kod tabanımızdaki tüm üretimle ilgili otomasyondan yararlanmak için `BlipForQuestionAnswering`, `GenerationMixin` sınıfından türetilmelidir;
- `BarkModel` özel bir `generate` yöntemine sahiptir ve iç modellerinden biri `GenerationMixin.generate` çağrısı yapar. Ancak `generate` yöntemi, `GenerationMixin.generate` ile aynı arayüzü paylaşmaz. Bu durumda, `generate` arayüzünü bozduğu için `BarkModel`, `GenerationMixin` sınıfından miras almamalıdır.

Sınıf, şunlar için kullanılabilen [generate()](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationMixin.generate) yöntemini sunar:
- `num_beams=1` ve `do_sample=False` ise *greedy decoding*
- `num_beams=1` ve `do_sample=True` ise *multinomial sampling*
- `num_beams>1` ve `do_sample=False` ise *beam-search decoding*
- `num_beams>1` ve `do_sample=True` ise *beam-search multinomial sampling*
- `assistant_model` veya `prompt_lookup_num_tokens` `.generate()` fonksiyonuna geçiriliyorsa *assisted decoding*

Çözme stratejileri hakkında daha fazla bilgi için [metin oluşturma stratejileri kılavuzuna](../generation_strategies) bakın.

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

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

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

**Parametreler:**

inputs (`torch.Tensor`, modaliteye göre değişen şekle sahip, *isteğe bağlı*) : Üretim için istem olarak veya kodlayıcıya model girdisi olarak kullanılan dizi. `None` ise yöntem, `bos_token_id` ve 1 parti boyutu ile başlatır. Sadece çözücü modeller için `inputs`, `input_ids` biçiminde olmalıdır. Kodlayıcı-çözücü modeller için *inputs*, `input_ids`, `input_values`, `input_features` veya `pixel_values`'den herhangi birini temsil edebilir.

generation_config ([GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig), *opsiyonel*) : Üretim çağrısı için temel parametrelendirme olarak kullanılacak üretim yapılandırması. `generation_config` öznitelikleriyle eşleşen ve generate'e aktarılan `**kwargs` bunları geçersiz kılar. `generation_config` sağlanmazsa, varsayılan kullanılır ve bunun yükleme önceliği şöyledir: 1) varsa `generation_config.json` model dosyasından; 2) model yapılandırmasından. Belirtilmeyen parametrelerin, üretimi parametrelendirmek için belgelenmesi gereken [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig)'in varsayılan değerlerini devraldığını lütfen unutmayın.

logits_processor (`LogitsProcessorList`, *isteğe bağlı*) : Argümanlardan ve üretim yapılandırmasından oluşturulan varsayılan logits işleyicilerini tamamlayan özel logits işleyicileri. Argümanlarla veya bir üretim yapılandırmasıyla zaten oluşturulmuş bir logits işleyicisi geçirilirse bir hata fırlatılır. Bu özellik ileri düzey kullanıcılar için tasarlanmıştır.

stopping_criteria (`StoppingCriteriaList`, *isteğe bağlı*) : Argümanlardan ve bir üretim yapılandırmasından oluşturulan varsayılan durdurma ölçütlerini tamamlayan özel durdurma ölçütleri. Argümanlarla veya bir üretim yapılandırmasıyla zaten oluşturulmuş bir durdurma ölçütü geçirilirse bir hata fırlatılır. Durdurma ölçütleriniz `scores` girdisine bağlıysa, `generate` fonksiyonuna `return_dict_in_generate=True, output_scores=True` parametrelerini geçmeyi unutmayın. Bu özellik ileri düzey kullanıcılar için tasarlanmıştır.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *isteğe bağlı*) : Sağlanırsa, bu fonksiyon her adımda beam search'i yalnızca izin verilen token'lara kısıtlar. Sağlanmazsa hiçbir kısıtlama uygulanmaz. Bu fonksiyon 2 argüman alır: batch kimliği `batch_id` ve `input_ids`. Batch kimliği `batch_id` ve daha önce üretilen token'lara `inputs_ids` bağlı olarak, bir sonraki üretim adımı için izin verilen token'ların listesini döndürmelidir. Bu argüman, [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) başlıklı bölümde anlatıldığı gibi, önekle (prefix) koşullu kısıtlı üretim için faydalıdır.

synced_gpus (`bool`, *isteğe bağlı*) : while döngüsünün max_length değerine kadar çalışmaya devam edip etmeyeceğini belirtir. Aksi belirtilmedikçe, birden fazla GPU ile `FullyShardedDataParallel` veya DeepSpeed ZeRO Stage 3 kullanılıyorsa, bir GPU diğer GPU'lardan önce üretimi tamamlarsa ölü kilitlenmeyi (deadlock) önlemek için bu bayrak `True` olarak ayarlanır. Aksi halde varsayılan değer `False`'tür.

assistant_model (`PreTrainedModel`, *isteğe bağlı*) : Üretimi hızlandırmak için kullanılabilen bir asistan modelidir. Asistan modelin, tam olarak aynı tokenizer'a sahip olması gerekir. Hızlandırma, asistan model ile aday token'ları tahmin etmenin, generate çağrısını yaptığınız modelle üretim çalıştırmaktan çok daha hızlı olması durumunda elde edilir. Bu nedenle asistan modelin çok daha küçük olması gerekir.

streamer (`BaseStreamer`, *isteğe bağlı*) : Üretilen dizilerin akışını sağlamak için kullanılacak Streamer nesnesi. Üretilen jetonlar `streamer.put(token_ids)` üzerinden geçirilir ve sonraki işlemlerden streamer sorumludur.

negative_prompt_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : CFG gibi bazı işlemciler için gerekli negatif prompt. Batch boyutu, girdi batch boyutuyla eşleşmelidir. Bu deneysel bir özelliktir ve gelecekteki sürümlerde kırıcı API değişikliklerine tabi olabilir.

negative_prompt_attention_mask (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : `negative_prompt_ids` için Attention_mask.

custom_generate (`str` veya `Callable`, *isteğe bağlı*) : Aşağıdakilerden biri: - `str` (Hugging Face Hub deposu adı): standart `generate` yöntemi yerine, o depodaki `custom_generate/generate.py` adresinde tanımlanan özel `generate` işlevini çalıştırır. Depo, üretim mantığını tamamen değiştirir ve dönüş tipi farklı olabilir. - `str` (yerel depo yolu): yukarıdakiyle aynıdır ancak yerel bir yoldan yapılır. Yerel dizinler de, yerel `custom_generate/generate.py` dosyasının çalıştırılması nedeniyle `trust_remote_code=True` gerektirir. - `Callable`: `generate`, olağan girdi hazırlama adımlarını gerçekleştirir, ardından çözümleme döngüsünü çalıştırmak için sağlanan çağrılabilir öğeyi çağırır. Daha fazla bilgi için [belgeleri](../../generation_strategies#custom-generation-methods) inceleyin.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : `generation_config` için ad hoc parametrelendirme ve/veya modelin `forward` fonksiyonuna iletilecek ek model-özel kwargs'lar. Model bir encoder-decoder modeli ise, encoder'a özgü kwargs'lar öneklenmemeli ve decoder'a özgü kwargs'lar *decoder_* önekiyle başlatılmalıdır.

**Dönüş:** [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) veya `torch.LongTensor`

Bir [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) (`return_dict_in_generate=True` ise veya `config.return_dict_in_generate=True` ise) ya da bir `torch.LongTensor`.

Model bir encoder-decoder modeli *değilse* (`model.config.is_encoder_decoder=False`), olası [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) türleri şunlardır:

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

Model bir kodlayıcı-çözücü modeli (`model.config.is_encoder_decoder=True`) ise, olası [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) türleri şunlardır:

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

Dil modelleme başlığına sahip modeller için token kimliği dizileri üretir.

Çoğu üretim kontrol parametresi, `generation_config` içinde ayarlanır; bu parametre geçirilmezse, modelin varsayılan üretim yapılandırması kullanılır. `generation_config` içindeki herhangi bir değeri, generate() fonksiyonuna ilgili parametreleri geçirerek geçersiz kılabilirsiniz, örneğin `.generate(inputs, num_beams=4, do_sample=True)`.

Üretim stratejileri ve kod örneklerinin genel bakışı için [şu kılavuza](../generation_strategies) göz atın.

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

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

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

**Parametreler:**

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

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

beam_indices (`torch.LongTensor`, *isteğe bağlı*) : Her üretim adımında üretilen token kimliğinin beam indeksleri. `(batch_size*num_return_sequences, sequence_length)` biçiminde bir `torch.LongTensor`. Yalnızca üretim sırasında `num_beams>1` ise gereklidir.

normalize_logits (`bool`, *isteğe bağlı*, varsayılan `False`) : Logitlerin normalize edilip edilmeyeceğini belirtir (eski nedenlerden ötürü normalize edilmemiş olabilirler).

**Dönüş:** `torch.Tensor`

Geçiş puanlarını (logit'leri) içeren, `(batch_size*num_return_sequences, sequence_length)` biçiminde bir `torch.Tensor`

Üretim puanları (ve beam search kullanıldıysa beam indeksleri) verildiğinde dizilerin geçiş puanlarını hesaplar. Bu, üretim sırasında seçilen jetonların puanlarını hızlı bir şekilde elde etmek için kullanışlı bir yöntemdir.

Örnekler:

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

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

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

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

## ContinuousMixin[[transformers.ContinuousMixin]]

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

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

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

Modellerin sürekli toplama (continuous batching) yeteneklerini eklemesi için karışım (mixin) sınıfı. Sürekli toplamanın üç giriş noktası vardır:
- Sürekli toplu işleme (continuous batching) için asıl giriş noktası olan `init_continuous_batching`
- Kendisi `init_continuous_batching` etrafında bir sarmalayıcı olan `continuous_batching_context_manager`
- Aslında `continuous_batching_context_manager` etrafında bir sarmalayıcı olan `generate_batch`

Bunlar bu sırada tanımlanır. Bu üç giriş noktasından herhangi birinde yapılan değişiklik, diğer ikisinde de yansıtılmalıdır.

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

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

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

Sürekli toplu işleme (continuous batching) yöneticisini güvenli bir şekilde kullanmak için bir bağlam yöneticisi. Argümanlar, `init_continuous_batching` ile benzerdir, ancak şunlar hariç:
- block: yönetici durdurulurken iş parçacığının (thread) engellenip engellenmeyeceğini belirtir. Varsayılan değer True'dur.
- timeout: iş parçacığının durması için beklenmesi gereken maksimum süre. Varsayılan değer None (zaman aşımı yok).
- warmup: çalıştırılmadan önce en büyük boyutlarda CUDA grafiklerini önceden yakalamak için kullanılıp kullanılmayacağı. Varsayılan değer True'dur.

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

```python
destroy_cached_continuous_batching_manager()
```

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

Önbelleğe alınmış sürekli toplu işleme yöneticisini yok edin ve GPU kaynaklarını serbest bırakın.

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

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

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

**Parametreler:**

inputs : Girdi token dizilerinin listesi (istemler)

generation_config : İsteğe bağlı üretim yapılandırması

continuous_batching_config : İsteğe bağlı sürekli toplu işleme (continuous batching) yapılandırması

record_timestamps : true olarak ayarlanırsa, istekler üretilen her token için bir zaman damgası içerecektir

progress_bar : true olarak ayarlanırsa, bir ilerleme çubuğu görüntülenir

persistent_manager : üretim tamamlandıktan sonra yöneticinin kalıcı olarak saklanıp saklanmayacağı. Varsayılan değer False'tur.

warmup : istekleri işlemeden önce CUDA grafiklerini önceden yakalamak için. Varsayılan değer True'dur.

**Dönüş:** `dict[str, GenerationOutput]`

istek kimliklerinden GenerationOutput nesnelerine bir sözlük

Sürekli toplama (continuous batching) kullanarak bir istek (prompt) grubu için diziler (sequences) oluşturun.

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

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

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

**Parametreler:**

generation_config : İsteğe bağlı bir üretim yapılandırması, bir CompileConfig nesnesi içerebilir

continuous_batching_config : İsteğe bağlı sürekli toplama (continuous batching) yapılandırması

workload_hints : Varsayılan değerler için sürekli toplu işleme yöneticisinin daha iyi kararlar vermesine yardımcı olmak için isteğe bağlı WorkloadHints

**Dönüş:** `ContinuousBatchingManager`

İstekleri eklemek ve sonuçları almak için yönetici örneği.

Sürekli toplu işleme (continuous batching) çıkarımı için bir yönetici başlatın.

## ContinuousBatchingManager[[transformers.ContinuousBatchingManager]]

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

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

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

Üretim isteklerinin sürekli toplu işlenmesini (continuous batching) yöneten yönetici. Üretim isteklerini göndermek, sonuçları almak ve arka plandaki üretim iş parçacığını (thread) yönetmek için bir kullanıcı arayüzü sağlar. Bu sınıf doğrudan oluşturulmamalı, bunun yerine aşağıdaki giriş noktalarından (giriş noktaları) biri üzerinden oluşturulmalıdır (`ContinuousMixin` karışımının tüm yöntemleri):
- `init_continuous_batching`
- `continuous_batching_context_manager`
- `generate_batch`

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

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

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

**Parametreler:**

input_ids : İstem olarak kullanılacak girdi belirteç kimlikleri

request_id : İsteğe bağlı özel istek kimliği (None ise otomatik oluşturulur)

max_new_tokens : Üretilmesi gereken yeni token'ların maksimum sayısı

streaming : Tokenler üretildikçe akış olarak gönderilsin mi

record_timestamps : Her üretilen token için zaman damgalarının kaydedilip kaydedilmeyeceği

eos_token_id : Sıra sonu belirteç kimliği (ID)

logit_processor_kwargs : logits işleyicisi için anahtar kelime argümanları.

**Dönüş:** `str | None`

Süreç bir TP sürücüsü ise istek kimliği, aksi halde None.

Kuyruğa yeni bir üretim isteği ekler. Süreç bir TP sürücüsü değilse bu işlem bir işe yaramaz (no-op).

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

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

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

`add_request` işlemlerini toplu olarak yürütmek ve kimliklerini döndürmek için yardımcı işlev. Daha fazla ayrıntı için belgelerini kontrol edin.

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

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

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

İstek, kimliği kullanılarak iptal edilir. Bu işlem, bir TP sürücüsü olmayan bir süreçten çağrılırsa hiçbir şey yapmaz: yöneticiyle yalnızca TP sürücüsü süreçleri etkileşime girer.

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

```python
destroy()
```

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

Yöneticiyi sonlandırın ve dağıtık kaynakları serbest bırakın. Birden fazla kez çağrılması güvenlidir. Bu çağrının ardından yönetici yeniden başlatılamaz.

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

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

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

Çıktı kuyruğundan bir sonuç alınır. Bir kimlik (ID) sağlanırsa, eşleşen ilk istek döndürülür. Bir zaman aşımı (timeout) sağlanırsa, zaman aşımı (saniye cinsinden) sonrasında None döndürülür.

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

```python
is_running()
```

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

Arka plan üretim iş parçacığı başlatılmışsa ve hâlâ aktifse True döndürür.

#### katıl[[transformers.ContinuousBatchingManager.join]]

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

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

Arka plan iş parçacığının bitmesini bekleyin. Wait, timeout (saniye cinsinden) argümanı kullanılarak sınırlandırılabilir.

#### duraklat[[transformers.ContinuousBatchingManager.pause]]

```python
pause()
```

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

Üretim döngüsünü duraklatan bir bağlam yöneticisidir; bu sayede çağıran iş parçacığı modeli kullanabilir, genellikle onu yerinde güncellemek için. İş parçacığı yalnızca döngü duraklatıldığında bu bağlama girer ve çıkışta döngü, önbelleğini ve işlenmekte olan isteklerini koruyarak yeniden başlar: hiçbir şey boşaltılmaz ve hiçbir istek kaybolmaz. Birden fazla iş parçacığı aynı anda duraklatmayı tutabilir ve döngü, son iş parçacığı çıkana kadar yeniden başlatılmaz. TP etkinse, tüm sıraların bu bağlama girmesi gerekir; aksi halde diğer sıralar sonsuza kadar bekler.

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

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

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

**Parametreler:**

request_id (*str*) : Çıktıları almak için istek kimliği.

callback (*callable*) : Her sonuç için bir `GenerationOutput` ile çağrılır.

Sonuç teslimi (akışkan veya akışkan olmayan) için bir geri bildirim kaydedin.

Callback, bu istek için her sonuç üretildiğinde `call_soon_threadsafe` aracılığıyla olay döngüsünde (event loop) çağrılır. Akış (streaming) isteklerinde bu her token için; akış dışı isteklerde ise yalnızca tamamlanma anında gerçekleşir. İşleyici (handler), istek bittiğinde otomatik olarak temizlenir.

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

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

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

Belirli bir istek kimliğiyle eşleşen sonuçların üzerinden yinele (engelleyici).

Yeniden kuyruğa alma (requeue) ile paylaşılan çıktı kuyruğunu kullanır. Yüksek eşzamanlılıkta sunum için bunun yerine `register_result_handler` kullanın.

#### başlat[[transformers.ContinuousBatchingManager.start]]

```python
start()
```

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

Arka plan üretim iş parçacığını başlatın.

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

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

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

Arka plan üretim iş parçacığını durdurur. `block` bayrağı True olarak ayarlanmışsa, bu yöntem iş parçacığının durması için en fazla `timeout` saniye (None, zaman aşımının olmadığını belirtir) bekler. `keep_for_next_session` bayrağı True olarak ayarlanmışsa, yönetici gelecekteki kullanım için modelde önbelleğe alınır. `hard_stop` bayrağı ayarlanmışsa, arka plan üretim iş parçacığı derhal durdurulur ve bekleyen istekler başarısız sayılır.

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

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

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

attn uygulamasını CB ile uyumlu olacak şekilde değiştirin. auto_switch_to_flash True ise ve attn uygulaması SDPA veya eager ise, flash destekleniyor ve kullanılabilirse ona da geçin.

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

```python
warmup()
```

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

Dummy batch'ler çalıştırılarak varlen ve decode yolları için CUDA grafiklerini önceden yakalar. Henüz yapılmadıysa batch işleyicisini başlatır.

## Zamanlayıcı[[transformers.generation.Scheduler]]

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

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

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

Sürekli toplu işlemci içinde istekleri zamanlamak için soyut temel sınıf. Zamanlayıcılar, isteklerin bekleme kuyruğuna eklenmesinden işleme için zamanlanmasına kadar olan yaşam döngüsünü yönetir. Farklı zamanlayıcılar, istekleri önceliklendirme ve toplu işleme için farklı stratejiler uygular.

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

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

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

Bekleme listesine bir istek ekler.

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

```python
clear_cancelled_requests()
```

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

İptal edilen tüm istekleri aktif ve bekleme kuyruklarından kaldırın.

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

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

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

Bir isteğin işlenmesini tamamlar ve ona ayrılmış önbellek bloklarını serbest bırakır. Bu yöntem, bir istek üretimi tamamladığında veya bir hata ile karşılaştığında çağrılır.

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

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

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

Aktif bir istek için üretilen tokenları alır.

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

```python
has_pending_requests()
```

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

İşlenecek hazır isteklerin olup olmadığını kontrol eder.

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

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

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

Bir isteğin iptal edilip edilmediğini veya kaldırılıp kaldırılmadığını kontrol eder.

#### sıfırla[[transformers.generation.Scheduler.reset]]

```python
reset()
```

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

Yeni bir üretim döngüsü için zamanlayıcı durumunu sıfırlayın.

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

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

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

Mevcut token ve önbellek bütçelerine göre sonraki parti için istekleri zamanlar. Bu yöntem, bütçeleri ve zamanlayıcının önceliklendirme kurallarını dikkate alarak mevcut partide işlenecek istekleri seçer. token_budget, bir partide işlenebilecek maksimum token sayısını, cache_budget ise bir partide okunabilecek maksimum KV önbellek girdisi sayısını belirtir. Zamanlanmış istek listesini "FutureRequestState" biçiminde, decode hızlı yolunun kullanılıp kullanılamayacağını gösteren bir boolean, toplam sorgu token sayısı ve okunan maksimum kv token sayısını döndürür.

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

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

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

İptal isteğini işaretler.

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

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

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

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

Bu zamanlayıcı, istekleri geldikleri sırada işler; bu da çözümleme isteklerinin ön işleme isteklerine göre öncelikli olduğu anlamına gelir.

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

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

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

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

Bölünmüş prefill isteklerini çözümleme isteklerine göre önceliklendiren zamanlayıcı. Bu zamanlayıcı, yeni çözümleme istekleri işlenmeden önce bölünmüş prefill isteklerinin (kısmen işlenmiş istemlerin devamı olan istekler) tamamlanmasını sağlar.