# Generasi

Setiap framework memiliki metode generate untuk generasi teks yang diimplementasikan di kelas `GenerationMixin` masing-masing:

- PyTorch [generate()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationMixin.generate) diimplementasikan di [GenerationMixin](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationMixin).

Anda dapat memparametrisasi metode generate dengan instance kelas [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig). Silakan merujuk ke kelas ini untuk daftar lengkap parameter generasi, yang mengontrol perilaku metode generasi.

Untuk mempelajari cara memeriksa konfigurasi generasi model, apa saja nilai defaultnya, cara mengubah parameter secara ad hoc, serta cara membuat dan menyimpan konfigurasi generasi yang dikustomisasi, silakan lihat [panduan strategi generasi teks](../generation_strategies). Panduan ini juga menjelaskan cara menggunakan fitur terkait, seperti streaming token.

## GenerationConfig[[transformers.GenerationConfig]]

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

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

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

**Parameter yang mengontrol panjang output:**

max_length (`int`, *opsional*) : `max_new_tokens` direkomendasikan untuk mengontrol berapa banyak token yang dihasilkan model. `max_length` tetap ada untuk kompatibilitas mundur.

max_new_tokens (`int`, *opsional*) : Jumlah maksimum token yang akan dihasilkan, mengabaikan jumlah token dalam prompt.

min_length (`int`, *opsional*) : Panjang minimum dari urutan yang akan dihasilkan. Bersesuaian dengan panjang prompt input + `min_new_tokens`. Efeknya ditimpa oleh `min_new_tokens`, jika juga disetel.

min_new_tokens (`int`, *opsional*) : Jumlah minimum token yang akan dihasilkan, mengabaikan jumlah token dalam prompt.

early_stopping (`bool` atau `str`, *opsional*) : Mengontrol kondisi penghentian untuk metode berbasis beam, seperti beam-search. Menerima nilai-nilai berikut: `True`, di mana generasi berhenti begitu ada `num_beams` kandidat lengkap; `False`, di mana heuristik diterapkan dan generasi berhenti ketika sangat tidak mungkin menemukan kandidat yang lebih baik; `"never"`, di mana prosedur beam search hanya berhenti ketika tidak ada lagi kandidat yang lebih baik (algoritma beam search kanonik).

max_time (`float`, *opsional*) : Jumlah waktu maksimum yang Anda izinkan untuk komputasi berjalan, dalam detik. generation akan tetap menyelesaikan pass saat ini setelah waktu yang dialokasikan habis.

stop_strings (`str` atau `list[str]`, *opsional*) : String atau daftar string yang harus mengakhiri generasi jika model mengoutputkannya.

**Parameter yang mengontrol strategi generasi yang digunakan:**

do_sample (`bool`) : Apakah akan menggunakan sampling; jika tidak, gunakan greedy decoding.

num_beams (`int`, *opsional*) : Jumlah beam untuk beam search. 1 berarti tidak ada beam search.

use_mtp : (`bool`): Apakah akan menggunakan Multi-Token Prediction (MTP) jika model mendukungnya.

**Parameter yang mengontrol cache:**

use_cache (`bool`) : Apakah model harus menggunakan perhatian kunci/nilai terakhir sebelumnya (jika berlaku untuk model) untuk mempercepat decoding.

cache_implementation (`str`, *opsional*) : Nama kelas cache yang akan diinstansiasi di `generate`, untuk decoding yang lebih cepat. Nilai yang mungkin adalah:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/id/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/id/internal/generation_utils#transformers.QuantizedCache)  Jika tidak ada yang ditentukan, kami akan menggunakan cache default untuk model (yang sering kali adalah [DynamicCache](/docs/transformers/main/id/internal/generation_utils#transformers.DynamicCache)). Lihat [dokumentasi cache](https://huggingface.co/docs/transformers/en/kv_cache) kami untuk informasi lebih lanjut.

cache_config (`dict`, *opsional*, default ke `None`) : Argumen yang digunakan dalam kelas cache key-value dapat diteruskan ke `cache_config`.

max_cache_len (`int`, *opsional*) : Hanya digunakan dengan cache statis (`cache_implementation` diatur ke `"static"` atau `"offloaded_static"`). Menetapkan ukuran awal cache ke panjang ini, bukan ke `max_length` dari panggilan saat ini. Atur sekali ke panggilan terbesar yang Anda perkirakan agar panggilan `generate()` berulang dengan prompt yang lebih panjang atau `max_new_tokens` yang lebih besar (hingga batas ini) dapat menggunakan ulang cache yang sama, alih-alih memicu alokasi ulang dan kompilasi ulang `torch.compile`.

**Parameter untuk manipulasi logit output model:**

temperature (`float`, *opsional*) : Nilai yang digunakan untuk memodulasi probabilitas token berikutnya. Nilai ini diatur dalam file `generation_config.json` model. Jika tidak diatur, nilai defaultnya adalah 1.0

top_k (`int`, *opsional*) : Jumlah token kosakata dengan probabilitas tertinggi yang dipertahankan untuk penyaringan top-k. Nilai ini diatur dalam file `generation_config.json` model. Jika tidak diatur, nilai defaultnya adalah 50.

top_p (`float`, *opsional*) : Jika diatur ke float < 1, hanya kumpulan token paling mungkin terkecil dengan probabilitas yang berjumlah `top_p` atau lebih tinggi yang dipertahankan untuk generasi. Nilai ini diatur dalam file `generation_config.json` model. Jika tidak diatur, nilai default adalah 1.0

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

top_h (`float`, *opsional*) : Faktor penskalaan anggaran entropi, yang mengontrol seberapa besar entropi distribusi yang dipertahankan saat pengambilan sampel. Harus berupa nilai antara 0 dan 1. Pada setiap langkah, token diurutkan berdasarkan probabilitas, dan prefiks terkecil dari token yang dipertahankan adalah yang entropi *ternormalisasi ulang*-nya kurang dari atau sama dengan `top_h` kali entropi dari distribusi penuh. Nilai yang lebih kecil (misalnya, 0,2–0,5) menghasilkan output yang lebih fokus dan deterministik, sedangkan nilai yang mendekati 1,0 memungkinkan lebih banyak keacakan dan keberagaman. Nilai tipikal berada dalam rentang 0,3–0,6.

typical_p (`float`, *opsional*) : Local typicality mengukur seberapa mirip probabilitas kondisional untuk memprediksi token target berikutnya dengan probabilitas kondisional yang diharapkan untuk memprediksi token acak berikutnya, mengingat teks parsial yang sudah dihasilkan. Jika diatur ke float < 1, himpunan terkecil dari token-token yang paling lokal-typical dengan probabilitas yang berjumlah `typical_p` atau lebih tinggi akan dipertahankan untuk generasi. Lihat [makalah ini](https://huggingface.co/papers/2202.00666) untuk detail lebih lanjut.

epsilon_cutoff (`float`, *opsional*) : Jika diatur ke float yang benar-benar berada di antara 0 dan 1, hanya token dengan probabilitas kondisional yang lebih besar dari `epsilon_cutoff` yang akan diambil sampelnya. Dalam makalah, nilai yang disarankan berkisar dari 3e-4 hingga 9e-4, tergantung pada ukuran model. Lihat [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) untuk detail lebih lanjut.

eta_cutoff (`float`, *opsional*) : Sampling eta adalah hibrida dari sampling lokal tipikal dan sampling epsilon. Jika diatur ke float yang benar-benar berada di antara 0 dan 1, sebuah token hanya dipertimbangkan jika nilainya lebih besar dari `eta_cutoff` atau `sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits)))`. Istilah terakhir secara intuitif adalah probabilitas token berikutnya yang diharapkan, yang diskalakan dengan `sqrt(eta_cutoff)`. Dalam makalahnya, nilai yang disarankan berkisar dari 3e-4 hingga 2e-3, tergantung pada ukuran model. Lihat [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) untuk detail lebih lanjut.

repetition_penalty (`float`, *opsional*) : Parameter untuk penalti pengulangan. 1.0 berarti tidak ada penalti. Lihat [makalah ini](https://huggingface.co/papers/1909.05858) untuk detail lebih lanjut.

encoder_repetition_penalty (`float`, *opsional*) : Parameter untuk encoder_repetition_penalty. Hukuman eksponensial untuk urutan yang tidak ada di input asli. 1.0 berarti tidak ada hukuman.

length_penalty (`float`, *opsional*) : Penalti eksponensial terhadap panjang yang digunakan dengan generasi berbasis beam. Penalti ini diterapkan sebagai eksponen terhadap panjang urutan, yang kemudian digunakan untuk membagi skor urutan. Karena skor adalah log likelihood dari urutan (yaitu negatif), `length_penalty` > 0.0 mendorong urutan yang lebih panjang, sedangkan `length_penalty` < 0.0 mendorong urutan yang lebih pendek.

no_repeat_ngram_size (`int`, *opsional*) : Jika diatur ke int > 0, semua ngram berukuran tersebut hanya dapat muncul sekali.

bad_words_ids (`list[list[int]]`, *opsional*) : Daftar dari daftar id token yang tidak diizinkan untuk dihasilkan. Periksa [NoBadWordsLogitsProcessor](/docs/transformers/main/id/internal/generation_utils#transformers.NoBadWordsLogitsProcessor) untuk dokumentasi dan contoh lebih lanjut.

renormalize_logits (`bool`) : Apakah logits akan dinormalisasi ulang setelah semua pemroses logits diterapkan (termasuk yang kustom). Sangat disarankan untuk mengatur flag ini ke `True` karena algoritma pencarian mengasumsikan bahwa skor logits telah dinormalisasi, tetapi beberapa pemroses logits dapat merusak normalisasi tersebut.

forced_bos_token_id (`int`, *opsional*, defaultnya `model.config.forced_bos_token_id`) : id token yang dipaksa sebagai token pertama yang dihasilkan setelah `decoder_start_token_id`. Berguna untuk model multibahasa seperti [mBART](../model_doc/mbart) di mana token pertama yang dihasilkan harus berupa token bahasa target.

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`) : Apakah akan menghapus kemungkinan output *nan* dan *inf* dari model untuk mencegah metode generasi mengalami crash. Perhatikan bahwa penggunaan `remove_invalid_values` dapat memperlambat proses generasi.

exponential_decay_length_penalty (`tuple(int, float)`, *opsional*) : Tuple ini menambahkan penalti panjang yang meningkat secara eksponensial, setelah sejumlah token tertentu telah dihasilkan. Tuple harus terdiri dari: `(start_index, decay_factor)` di mana `start_index` menunjukkan di mana penalti dimulai dan `decay_factor` mewakili faktor peluruhan eksponensial

suppress_tokens (`list[int]`, *opsional*) : Daftar token yang akan ditekan saat generasi. Prosesor logit `SuppressTokens` akan mengatur probabilitas log mereka menjadi `-inf` sehingga tidak diambil sampel.

begin_suppress_tokens  (`list[int]`, *opsional*) : Daftar token yang akan ditekan di awal generasi. Prosesor logit `SuppressBeginTokens` akan mengatur probabilitas log mereka menjadi `-inf` sehingga tidak diambil sampel.

sequence_bias (`dict[tuple[int], float]`, *opsional*)) : Kamus yang memetakan urutan token ke istilah bias-nya. Bias positif meningkatkan peluang urutan tersebut dipilih, sedangkan bias negatif melakukan kebalikannya. Lihat [SequenceBiasLogitsProcessor](/docs/transformers/main/id/internal/generation_utils#transformers.SequenceBiasLogitsProcessor) untuk dokumentasi dan contoh lebih lanjut.

token_healing (`bool`) : Memperbaiki token ekor dari prompt dengan menggantinya dengan ekstensi yang sesuai. Hal ini meningkatkan kualitas pelengkapan untuk prompt yang terpengaruh oleh bias tokenisasi serakah.

guidance_scale (`float`, *opsional*) : Skala panduan untuk classifier free guidance (CFG). CFG diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong model untuk menghasilkan sampel yang lebih erat kaitannya dengan prompt input, biasanya dengan mengorbankan kualitas yang lebih buruk.

watermarking_config (`BaseWatermarkingConfig` atau `dict`, *opsional*) : Argumen yang digunakan untuk memberi watermark pada keluaran model dengan menambahkan bias kecil pada himpunan token "green" yang dipilih secara acak. Lihat dokumentasi [SynthIDTextWatermarkingConfig](/docs/transformers/main/id/internal/generation_utils#transformers.SynthIDTextWatermarkingConfig) dan [WatermarkingConfig](/docs/transformers/main/id/internal/generation_utils#transformers.WatermarkingConfig) untuk detail lebih lanjut. Jika diteruskan sebagai `Dict`, akan dikonversi menjadi `WatermarkingConfig` secara internal.

**Parameter yang mendefinisikan variabel keluaran dari generate:**

num_return_sequences (`int`, *opsional*) : Jumlah urutan yang dikembalikan dan dihitung secara independen untuk setiap elemen dalam batch.

output_attentions (`bool`) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_scores (`bool`) : Apakah skor prediksi akan dikembalikan atau tidak. Lihat `scores` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_logits (`bool`) : Apakah akan mengembalikan skor logit prediksi yang belum diproses. Lihat `logits` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict_in_generate (`bool`) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) atau hanya mengembalikan urutan yang dihasilkan. Flag ini harus disetel ke `True` untuk mengembalikan cache generasi (ketika `use_cache` adalah `True`) atau output opsional (lihat flag yang diawali dengan `output_`)

**Token khusus yang dapat digunakan saat generasi:**

pad_token_id (`int`, *opsional*) : id dari token *padding*.

bos_token_id (`int`, *opsional*) : id dari token *awal-sekuens*.

eos_token_id (`Union[int, list[int]]`, *opsional*) : id dari token *end-of-sequence*. Secara opsional, gunakan daftar untuk mengatur beberapa token *end-of-sequence*.

**Parameter generasi yang hanya ada pada model encoder-decoder:**

encoder_no_repeat_ngram_size (`int`, *opsional*) : Jika diatur ke int > 0, semua ngram berukuran tersebut yang muncul di `encoder_input_ids` tidak boleh muncul di `decoder_input_ids`.

decoder_start_token_id (`int` atau `list[int]`, *opsional*) : Jika model encoder-decoder memulai decoding dengan token yang berbeda dari *bos*, id dari token tersebut atau daftar dengan panjang `batch_size`. Menunjukkan daftar memungkinkan id awal yang berbeda untuk setiap elemen dalam batch (misalnya model multibahasa dengan bahasa target yang berbeda dalam satu batch)

**Parameter generasi yang khusus untuk generasi asisten:**

is_assistant (`bool`) : Apakah model tersebut merupakan model asisten (draft).

num_assistant_tokens (`int`, *opsional*) : Menentukan jumlah _token spekulatif_ yang akan dihasilkan oleh model asisten sebelum diperiksa oleh model target pada setiap iterasi. Nilai yang lebih tinggi untuk `num_assistant_tokens` membuat generasi menjadi lebih _spekulatif_ : Jika model asisten memiliki performa yang baik, percepatan yang lebih besar dapat dicapai; jika model asisten memerlukan banyak koreksi, percepatan yang lebih rendah akan dicapai.

num_assistant_tokens_schedule (`str`, *opsional*) : Menentukan jadwal perubahan `num_assistant_tokens` maksimum selama inferensi. - `"heuristic"`: Jika semua token spekulatif benar, tingkatkan `num_assistant_tokens` sebesar 2, selain itu kurangi sebesar 1. Nilai `num_assistant_tokens` bersifat persisten di antara beberapa panggilan generasi dengan model asisten yang sama. - `"heuristic_transient"`: Sama seperti `"heuristic"` tetapi `num_assistant_tokens` direset ke nilai awalnya setelah setiap panggilan generasi. - `"constant"`: `num_assistant_tokens` tetap tidak berubah selama generasi

assistant_confidence_threshold (`float`, *opsional*) : Ambang batas kepercayaan untuk model asisten. Jika tingkat kepercayaan model asisten terhadap prediksinya untuk token saat ini lebih rendah dari ambang batas ini, model asisten akan menghentikan iterasi generasi token saat ini, bahkan jika jumlah _token spekulatif_ (yang didefinisikan oleh `num_assistant_tokens`) belum tercapai. Ambang batas kepercayaan asisten disesuaikan sepanjang iterasi spekulatif untuk mengurangi jumlah forward pass draft dan target yang tidak perlu, dengan bias untuk menghindari false negative. Nilai `assistant_confidence_threshold` bersifat persisten di antara beberapa panggilan generasi dengan model asisten yang sama. Ini adalah versi tanpa pengawasan dari dynamic speculation lookahead dari Dynamic Speculation Lookahead Accelerates Speculative Decoding of Large Language Models .

prompt_lookup_num_tokens (`int`, *opsional*) : Jumlah token yang akan dioutput sebagai token kandidat.

max_matching_ngram_size (`int`, *opsional*) : Ukuran ngram maksimum yang akan dipertimbangkan untuk pencocokan dalam prompt. Bawaan ke 2 jika tidak diberikan.

assistant_early_exit(`int`, *optional*) : Jika diset ke bilangan bulat positif, early exit dari model akan digunakan sebagai asisten. Hanya dapat digunakan dengan model yang mendukung early exit (yaitu model di mana logits dari lapisan antara dapat diinterpretasikan oleh LM head).

assistant_lookbehind(`int`, *opsional*) : Jika diatur ke bilangan bulat positif, proses re-encoding akan mempertimbangkan `assistant_lookbehind` token asisten terakhir untuk menyelaraskan token dengan benar. Hanya dapat digunakan dengan tokenizer yang berbeda dalam speculative decoding. Lihat [blog](https://huggingface.co/blog/universal_assisted_generation) ini untuk detail lebih lanjut.

target_lookbehind(`int`, *opsional*) : Jika diatur ke bilangan bulat positif, proses re-encoding akan mempertimbangkan `target_lookbehind` token target terakhir untuk menyelaraskan token dengan benar. Hanya dapat digunakan dengan tokenizer yang berbeda dalam speculative decoding. Lihat [blog](https://huggingface.co/blog/universal_assisted_generation) ini untuk detail lebih lanjut.

assistant_ensemble_weight (`float`, *opsional*) : Mengaktifkan verifikasi ensemble statis dalam dekode spekulatif. Jika diatur ke nilai dalam `(0.0, 1.0)`, penguji menerima token terhadap campuran `w * p_target + (1 - w) * q_draft` alih-alih `p_target`, menukar bias distribusi yang terkendali untuk tingkat penerimaan yang lebih tinggi. Bawaan adalah `None`, yang menjaga dekode tetap tanpa kehilangan. Memerlukan model asisten untuk mengembalikan logits, sehingga tidak kompatibel dengan dekode pencarian prompt.

speculation_type (`str`, *opsional*) : Jenis spekulasi yang diminta. Nilai yang diterima adalah `dflash`.

**Parameter terkait performa dan kompilasi:**

compile_config (CompileConfig, *opsional*) : Jika menggunakan cache yang dapat dikompilasi, ini mengontrol bagaimana `generate` akan `compile` forward pass untuk inferensi yang lebih cepat.

disable_compile (`bool`) : Apakah akan menonaktifkan kompilasi otomatis dari forward pass. Kompilasi otomatis terjadi ketika kriteria tertentu terpenuhi, termasuk penggunaan cache yang dapat dikompilasi. Silakan buka issue jika Anda merasa perlu menggunakan flag ini.

Kelas yang menyimpan konfigurasi untuk tugas generasi. Panggilan `generate` mendukung metode generasi berikut untuk model text-decoder, text-to-text, speech-to-text, dan vision-to-text:

- *greedy decoding* jika `num_beams=1` dan `do_sample=False`
- *multinomial sampling* jika `num_beams=1` dan `do_sample=True`
- *dekoding beam-search* jika `num_beams>1` dan `do_sample=False`
- *beam-search multinomial sampling* jika `num_beams>1` dan `do_sample=True`
- *assisted decoding* jika `assistant_model` atau `prompt_lookup_num_tokens` diteruskan ke `.generate()`

Untuk mempelajari lebih lanjut tentang strategi decoding, lihat [panduan strategi generasi teks](../generation_strategies).

Sejumlah besar flag ini mengontrol logits atau kriteria penghentian dari generasi. Pastikan Anda memeriksa [kelas terkait generate](https://huggingface.co/docs/transformers/internal/generation_utils) untuk deskripsi lengkap tentang manipulasi yang mungkin, serta contoh penggunaannya.

Catatan: field konfigurasi yang masih `None` akan ditimpa oleh `GenerationConfig._get_default_generation_params()` selama loop generasi. Jika Anda ingin menggunakan nilai yang berbeda untuk field-field ini, pastikan untuk menyetelnya secara eksplisit dalam konfigurasi generasi.

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

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

**Parameter:**

pretrained_model_name (`str` atau `os.PathLike`) : Ini bisa berupa:  - string, *model id* dari konfigurasi model pretrained yang dihosting di dalam repo model di huggingface.co. - path ke *directory* yang berisi file konfigurasi yang disimpan menggunakan metode [save_pretrained()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig.save_pretrained), misalnya `./my_model_directory/`.

config_file_name (`str` atau `os.PathLike`, *opsional*, defaultnya `"generation_config.json"`) : Nama file konfigurasi generasi JSON yang akan dimuat dari `pretrained_model_name`.

cache_dir (`str` atau `os.PathLike`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh harus di-cache jika cache standar tidak digunakan.

force_download (`bool`, *opsional*, default `False`) : Apakah akan memaksa (mengunduh ulang) file konfigurasi dan menimpa versi yang di-cache jika sudah ada.

proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Proxy digunakan pada setiap permintaan.

token (`str` atau `bool`, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, atau tidak ditentukan, akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Ini bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa identifikasi apa pun yang diizinkan oleh git.    Untuk menguji pull request yang Anda buat di Hub, Anda dapat meneruskan `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opsional*, defaultnya `False`) : Jika `False`, fungsi ini hanya mengembalikan objek konfigurasi akhir. Jika `True`, fungsi ini mengembalikan `Tuple(config, unused_kwargs)` di mana *unused_kwargs* adalah kamus yang terdiri dari pasangan kunci/nilai yang kuncinya bukan merupakan atribut konfigurasi: yaitu, bagian dari `kwargs` yang tidak digunakan untuk memperbarui `config` dan diabaikan.

subfolder (`str`, *opsional*, default `""`) : Jika file yang relevan berada di dalam subfolder dari repo model di huggingface.co, Anda dapat menentukan nama folder di sini.

kwargs (`dict[str, Any]`, *opsional*) : Nilai dalam kwargs untuk kunci mana pun yang merupakan atribut konfigurasi akan digunakan untuk menimpa nilai yang dimuat. Perilaku terkait pasangan kunci/nilai yang kuncinya *bukan* atribut konfigurasi dikendalikan oleh parameter kata kunci `return_unused_kwargs`.

**Mengembalikan:** [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig)

Objek konfigurasi yang diinstansiasi dari model pretrained ini.

Instansiasi [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig) dari file konfigurasi generasi.

Contoh:

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

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

**Parameter:**

model_config (`PreTrainedConfig | dict`) : Konfigurasi model yang akan digunakan untuk menginstansiasi konfigurasi generasi.

**Mengembalikan:** [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig)

Objek konfigurasi yang diinstansiasi dari parameter tersebut.

Membuat instans [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig) dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig). Fungsi ini berguna untuk mengonversi objek [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) lama, yang mungkin berisi parameter generasi, menjadi [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig) yang berdiri sendiri.

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

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

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Direktori tempat file konfigurasi JSON akan disimpan (akan dibuat jika belum ada).

config_file_name (`str` atau `os.PathLike`, *opsional*, defaultnya `"generation_config.json"`) : Nama file konfigurasi generasi JSON yang akan disimpan di `save_directory`.

push_to_hub (`bool`, *opsional*, default `False`) : Apakah model akan didorong ke Hugging Face model hub setelah disimpan. Anda dapat menentukan repositori tujuan dengan `repo_id` (defaultnya adalah nama `save_directory` di namespace Anda).

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke metode [push_to_hub()](/docs/transformers/main/id/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Simpan objek konfigurasi generasi ke direktori `save_directory` agar dapat dimuat ulang menggunakan metode kelas [from_pretrained()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig.from_pretrained).

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

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

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

**Parameter:**

defaults_only (`bool`, *opsional*, defaultnya `False`) : Apakah akan memperbarui semua kunci dalam config dengan `kwargs` atau hanya yang diset ke `None` (yaitu nilai default).

allow_custom_entries (`bool`, *opsional*, defaultnya `False`) : Apakah mengizinkan pembaruan entri kustom ke dalam config dengan `kwargs` jika tidak ada di config saat ini.

kwargs (`dict[str, Any]`) : Kamus atribut untuk memperbarui kelas ini secara sementara.

**Mengembalikan:** `dict[str, Any]`

Dictionary yang berisi semua pasangan kunci-nilai yang tidak digunakan untuk memperbarui instance.

Memperbarui atribut dari instance kelas ini dengan atribut dari `kwargs` jika cocok dengan atribut yang sudah ada, dan mengembalikan semua kwargs yang tidak terpakai.

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

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

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

**Parameter:**

strict (bool) : Jika True, lempar pengecualian untuk setiap masalah yang ditemukan. Jika False, hanya catat masalah.

user_set_attributes (set[str], *opsional*) : Nama atribut yang secara eksplisit disediakan oleh pemanggil. Ketika disediakan, peringatan "masalah kecil" tentang kombinasi bendera yang saling bertentangan (misalnya bendera khusus sampling disetel sementara `do_sample=False`) hanya muncul jika bendera yang bertentangan tersebut ada dalam set ini -- menghindari peringatan yang berisik ketika nilainya diwarisi dari `generation_config.json` bawaan model. Ketika `None`, semua atribut yang disetel dianggap disetel oleh pengguna (perilaku yang kompatibel mundur untuk panggilan `validate()` langsung).

Memvalidasi nilai atribut dari instans [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig). Membuang pengecualian jika terdapat parameterisasi yang dapat dideteksi sebagai salah hanya dari instans konfigurasi.

Perhatikan bahwa beberapa parameter yang tidak divalidasi di sini sebaiknya divalidasi pada saat runtime generate, karena parameter tersebut mungkin bergantung pada input lain dan/atau model, seperti parameter yang berkaitan dengan panjang generasi.

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

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

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

**Parameter:**

assistant_model (`PreTrainedModel`, *opsional*) : Model asisten yang akan digunakan untuk generasi terbantu. Jika diset, mode generasi akan menjadi generasi terbantu.

**Mengembalikan:** `GenerationMode`

Mode generasi yang dipicu oleh instance.

Mengembalikan mode generasi yang dipicu oleh instans [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig).

## GenerationMixin[[transformers.GenerationMixin]]

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

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

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

Kelas yang berisi semua fungsi untuk generasi teks auto-regresif, yang digunakan sebagai mixin dalam kelas model. Mengwarisi dari kelas ini menyebabkan model memiliki perilaku khusus terkait generasi, seperti memuat `GenerationConfig` pada waktu inisialisasi atau memastikan pengujian terkait `generate` dijalankan di CI `transformers`.

Kelas model harus mewarisi dari `GenerationMixin` untuk memungkinkan pemanggilan metode seperti `generate`, atau ketika telah mendefinisikan metode `generate` kustom yang bergantung pada `GenerationMixin`, baik secara langsung maupun tidak langsung, yang secara umum berbagi antarmuka yang sama untuk metode publik seperti `generate`. Tiga contoh:
- `LlamaForCausalLM` harus mewarisi dari `GenerationMixin` untuk memungkinkan pemanggilan `generate` dan metode publik lainnya dalam mixin;
- `BlipForQuestionAnswering` memiliki metode `generate` khusus yang secara aproximatif berbagi antarmuka yang sama dengan `GenerationMixin.generate` (memiliki beberapa argumen tambahan, dan output yang sama). Fungsi tersebut juga memanggil `GenerationMixin.generate` secara tidak langsung, melalui model internal. Dengan demikian, `BlipForQuestionAnswering` harus mewarisi dari `GenerationMixin` untuk mendapatkan manfaat dari semua otomasi terkait generasi di basis kode kami;
- `BarkModel` memiliki metode `generate` khusus dan salah satu model internalnya memanggil `GenerationMixin.generate`. Namun, `generate` miliknya tidak berbagi antarmuka yang sama dengan `GenerationMixin.generate`. Dalam kasus ini, `BarkModel` TIDAK seharusnya mewarisi dari `GenerationMixin`, karena hal itu merusak antarmuka `generate`.

Kelas ini mengekspos [generate()](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationMixin.generate), yang dapat digunakan untuk:
- *greedy decoding* jika `num_beams=1` dan `do_sample=False`
- *multinomial sampling* jika `num_beams=1` dan `do_sample=True`
- *dekoding beam-search* jika `num_beams>1` dan `do_sample=False`
- *beam-search multinomial sampling* jika `num_beams>1` dan `do_sample=True`
- *assisted decoding* jika `assistant_model` atau `prompt_lookup_num_tokens` diteruskan ke `.generate()`

Untuk mempelajari lebih lanjut tentang strategi decoding, lihat [panduan strategi generasi teks](../generation_strategies).

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

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

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

**Parameter:**

inputs (`torch.Tensor` dengan bentuk yang bervariasi tergantung pada modalitas, *opsional*) : Urutan yang digunakan sebagai prompt untuk generasi atau sebagai input model ke encoder. Jika `None`, metode ini menginisialisasinya dengan `bos_token_id` dan ukuran batch 1. Untuk model decoder-only, `inputs` harus dalam format `input_ids`. Untuk model encoder-decoder, *inputs* dapat mewakili salah satu dari `input_ids`, `input_values`, `input_features`, atau `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig), *opsional*) : Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi. `**kwargs` yang diteruskan ke generate dan cocok dengan atribut dari `generation_config` akan menimpanya. Jika `generation_config` tidak disediakan, nilai default akan digunakan, yang memiliki prioritas pemuatan sebagai berikut: 1) dari file model `generation_config.json`, jika ada; 2) dari konfigurasi model. Harap diperhatikan bahwa parameter yang tidak ditentukan akan mewarisi nilai default dari [GenerationConfig](/docs/transformers/main/id/main_classes/text_generation#transformers.GenerationConfig), dan dokumentasinya harus diperiksa untuk memparametrisasi generasi.

logits_processor (`LogitsProcessorList`, *opsional*) : Prosesor logits kustom yang melengkapi prosesor logits bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika prosesor logits yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Fitur ini ditujukan untuk pengguna tingkat lanjut.

stopping_criteria (`StoppingCriteriaList`, *opsional*) : Kriteria penghentian kustom yang melengkapi kriteria penghentian bawaan yang dibangun dari argumen dan konfigurasi generasi. Jika kriteria penghentian yang sudah dibuat dengan argumen atau konfigurasi generasi diteruskan, sebuah error akan dilempar. Jika kriteria penghentian Anda bergantung pada input `scores`, pastikan Anda meneruskan `return_dict_in_generate=True, output_scores=True` ke `generate`. Fitur ini ditujukan untuk pengguna tingkat lanjut.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opsional*) : Jika disediakan, fungsi ini membatasi beam search hanya pada token yang diizinkan di setiap langkah. Jika tidak disediakan, tidak ada batasan yang diterapkan. Fungsi ini mengambil 2 argumen: ID batch `batch_id` dan `input_ids`. Fungsi ini harus mengembalikan daftar token yang diizinkan untuk langkah generasi berikutnya yang dikondisikan pada ID batch `batch_id` dan token yang sebelumnya dihasilkan `inputs_ids`. Argumen ini berguna untuk generasi yang dibatasi berdasarkan prefiks, seperti yang dijelaskan dalam [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opsional*) : Apakah akan terus menjalankan loop while hingga max_length. Kecuali ditimpa, flag ini akan disetel ke `True` jika menggunakan `FullyShardedDataParallel` atau DeepSpeed ZeRO Stage 3 dengan beberapa GPU untuk menghindari deadlocking jika satu GPU selesai menghasilkan sebelum GPU lainnya. Jika tidak, defaultnya adalah `False`.

assistant_model (`PreTrainedModel`, *opsional*) : Model asisten yang dapat digunakan untuk mempercepat generasi. Model asisten harus memiliki tokenizer yang persis sama. Percepatan tercapai ketika memprediksi token kandidat dengan model asisten jauh lebih cepat daripada menjalankan generasi dengan model yang Anda panggil generate dari. Oleh karena itu, model asisten harus jauh lebih kecil.

streamer (`BaseStreamer`, *opsional*) : Objek Streamer yang akan digunakan untuk streaming urutan yang dihasilkan. Token yang dihasilkan diteruskan melalui `streamer.put(token_ids)` dan streamer bertanggung jawab untuk pemrosesan lebih lanjut.

negative_prompt_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Prompt negatif yang diperlukan untuk beberapa prosesor seperti CFG. Ukuran batch harus sesuai dengan ukuran batch input. Ini adalah fitur eksperimental, yang dapat mengalami perubahan API yang merusak (breaking changes) di versi mendatang.

negative_prompt_attention_mask (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Attention_mask untuk `negative_prompt_ids`.

custom_generate (`str` atau `Callable`, *opsional*) : Salah satu dari berikut: - `str` (nama repositori Hugging Face Hub): menjalankan fungsi `generate` kustom yang didefinisikan di `custom_generate/generate.py` pada repositori tersebut, bukan metode `generate` standar. Repositori ini sepenuhnya menggantikan logika generasi, dan tipe pengembalian dapat berbeda. - `str` (jalur repositori lokal): sama seperti di atas tetapi dari jalur lokal. Direktori lokal juga memerlukan `trust_remote_code=True` karena `custom_generate/generate.py` lokal akan dieksekusi. - `Callable`: `generate` akan melakukan langkah-langkah persiapan input yang biasa, lalu memanggil callable yang diberikan untuk menjalankan loop decoding. Untuk informasi lebih lanjut, lihat [dokumentasinya](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opsional*) : Parametrisasi ad hoc untuk `generation_config` dan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsi `forward` dari model. Jika model adalah model encoder-decoder, kwargs spesifik encoder tidak boleh diberi awalan dan kwargs spesifik decoder harus diberi awalan *decoder_*.

**Mengembalikan:** [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) atau `torch.LongTensor`

[ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) (jika `return_dict_in_generate=True` atau ketika `config.return_dict_in_generate=True`) atau `torch.LongTensor`.

Jika model *bukan* model encoder-decoder (`model.config.is_encoder_decoder=False`), tipe [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) yang mungkin adalah:

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

Jika model adalah model encoder-decoder (`model.config.is_encoder_decoder=True`), tipe [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) yang mungkin adalah:

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

Membuat rangkaian id token untuk model dengan kepala pemodelan bahasa.

Sebagian besar parameter pengendali generasi diatur di `generation_config` yang, jika tidak diteruskan, akan disetel ke konfigurasi generasi default model. Anda dapat menimpa `generation_config` mana pun dengan meneruskan parameter yang sesuai ke generate(), misalnya `.generate(inputs, num_beams=4, do_sample=True)`.

Untuk ringkasan strategi generasi dan contoh kode, lihat [panduan berikut](../generation_strategies).

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

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

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

**Parameter:**

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

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

beam_indices (`torch.LongTensor`, *opsional*) : Indeks beam dari id token yang dihasilkan pada setiap langkah generasi. `torch.LongTensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)`. Hanya diperlukan jika `num_beams>1` saat generate.

normalize_logits (`bool`, *opsional*, defaultnya `False`) : Apakah akan menormalisasi logits (yang, karena alasan legacy, mungkin belum dinormalisasi).

**Mengembalikan:** `torch.Tensor`

`torch.Tensor` dengan bentuk `(batch_size*num_return_sequences, sequence_length)` yang berisi skor transisi (logits)

Menghitung skor transisi dari sekuens yang diberikan berdasarkan skor generasi (dan indeks beam, jika beam search digunakan). Ini adalah metode yang praktis untuk dengan cepat memperoleh skor dari token yang dipilih pada saat generasi.

Contoh:

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

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

Kelas Mixin untuk model guna menambahkan kemampuan continuous batching. Continuous batching memiliki tiga titik masuk:
- `init_continuous_batching`, yang merupakan titik masuk sebenarnya untuk continuous batching
- `continuous_batching_context_manager`, yang sendiri merupakan pembungkus di sekitar `init_continuous_batching`
- `generate_batch`, yang sebenarnya adalah pembungkus di sekitar `continuous_batching_context_manager`

Mereka didefinisikan dalam urutan ini. Setiap perubahan yang dilakukan pada salah satu dari tiga titik masuk tersebut harus tercermin pada dua titik masuk lainnya.

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

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

Manajer konteks untuk menggunakan manajer continuous batching dengan aman. Argumennya mirip dengan argumen `init_continuous_batching`, kecuali untuk:
- block: apakah akan memblokir thread saat menghentikan manager. Default adalah True.
- timeout: waktu maksimum untuk menunggu thread berhenti. Default adalah None (tanpa timeout).
- warmup: apakah akan pre-capture CUDA graphs pada ukuran terbesar sebelum menjalankan. Default adalah True.

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

```python
destroy_cached_continuous_batching_manager()
```

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

Hancurkan manajer continuous batching yang di-cache dan bebaskan sumber daya GPU.

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

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

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

**Parameter:**

inputs : Daftar sekuens token input (prompt)

generation_config : Konfigurasi generasi opsional

continuous_batching_config : Konfigurasi continuous batching opsional

record_timestamps : Jika diatur ke true, permintaan akan memiliki timestamp untuk setiap token yang dihasilkan

progress_bar : Jika diatur ke true, bilah kemajuan akan ditampilkan

persistent_manager : apakah akan mempertahankan manager setelah generasi selesai. Default adalah False.

warmup : apakah akan menangkap grafik CUDA terlebih dahulu sebelum memproses permintaan. Nilai default adalah True.

**Mengembalikan:** `dict[str, GenerationOutput]`

kamus dari id permintaan ke objek GenerationOutput

Generate sequences untuk batch prompt menggunakan continuous batching.

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

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

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

**Parameter:**

generation_config : Konfigurasi generasi opsional, yang dapat berisi objek CompileConfig

continuous_batching_config : Konfigurasi continuous batching opsional

workload_hints : WorkloadHints opsional untuk membantu manajer continuous batching membuat keputusan yang lebih baik untuk nilai default

**Mengembalikan:** `ContinuousBatchingManager`

Instans manager untuk menambahkan permintaan dan mengambil hasil.

Inisialisasi manajer untuk inferensi pengelompokan berkelanjutan.

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

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

Manajer untuk menangani pengelompokan berkelanjutan (continuous batching) permintaan generasi. Kelas ini menyediakan antarmuka pengguna untuk mengirim permintaan generasi, mengambil hasil, dan mengelola thread generasi di latar belakang. Kelas ini tidak boleh dibuat secara langsung, melainkan melalui salah satu titik masuk berikut (semua metode dari mixin `ContinuousMixin`):
- `init_continuous_batching`
- `continuous_batching_context_manager`
- `generate_batch`

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

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

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

**Parameter:**

input_ids : ID token input yang akan digunakan sebagai prompt

request_id : ID permintaan kustom opsional (dibuat secara otomatis jika None)

max_new_tokens : Jumlah maksimum token baru yang akan dihasilkan

streaming : Apakah akan mengalirkan token saat token tersebut dihasilkan

record_timestamps : Apakah akan merekam stempel waktu untuk setiap token yang dihasilkan

eos_token_id : ID token akhir urutan

logit_processor_kwargs : Argumen kata kunci untuk pemroses logits.

**Mengembalikan:** `str | None`

ID permintaan jika proses adalah driver TP, None selain itu.

Tambahkan permintaan generasi baru ke antrean. Jika proses tersebut bukan driver TP, ini tidak melakukan apa-apa.

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

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

Fungsi utilitas untuk mem-batch `add_request` dan mengembalikan ID-nya. Periksa dokumentasinya untuk detail lebih lanjut.

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

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

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

Batalkan permintaan berdasarkan ID-nya. Jika ini dipanggil dari proses yang bukan driver TP, ini tidak melakukan apa-apa: hanya proses driver TP yang berinteraksi dengan manager.

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

```python
destroy()
```

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

Akhiri manager dan lepaskan sumber daya terdistribusi. Aman untuk dipanggil beberapa kali. Setelah memanggil ini, manager tidak dapat dimulai ulang.

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

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

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

Ambil satu hasil dari antrean keluaran. Jika ID diberikan, kembalikan permintaan yang cocok pertama kali. Jika timeout diberikan, kembalikan None setelah timeout (dalam detik).

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

```python
is_running()
```

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

Mengembalikan True jika thread generasi latar belakang telah dimulai dan masih aktif.

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

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

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

Tunggu hingga thread latar belakang selesai. Wait dapat dibatasi menggunakan argumen timeout (dalam detik).

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

```python
pause()
```

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

Manajer konteks yang menjeda loop generasi, sehingga thread pemanggil dapat menggunakan model, biasanya untuk memperbaruinya secara in-place. Thread hanya masuk ke konteks ini setelah loop dijeda, dan loop dilanjutkan saat keluar, dengan mempertahankan cache dan permintaan yang sedang diproses: tidak ada yang dibuang dan tidak ada permintaan yang hilang. Beberapa thread dapat memegang jeda secara bersamaan, dan loop dilanjutkan setelah thread terakhir keluar. Jika TP diaktifkan, semua rank harus masuk ke konteks ini, jika tidak rank lain akan menggantung selamanya.

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

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

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

**Parameter:**

request_id (*str*) : ID permintaan untuk menerima output.

callback (*callable*) : Dipanggil dengan `GenerationOutput` untuk setiap hasil.

Daftarkan callback untuk pengiriman hasil (streaming atau non-streaming).

Callback dipanggil pada event loop melalui `call_soon_threadsafe` setiap kali hasil dihasilkan untuk permintaan ini. Untuk permintaan streaming, hal ini terjadi pada setiap token; untuk non-streaming, hanya saat selesai. Handler dibersihkan secara otomatis ketika permintaan selesai.

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

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

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

Iterasi hasil yang cocok dengan id permintaan tertentu (blocking).

Menggunakan antrean output bersama dengan requeue. Untuk penyajian dengan konkurensi tinggi, gunakan `register_result_handler` sebagai gantinya.

#### mulai[[transformers.ContinuousBatchingManager.start]]

```python
start()
```

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

Mulai thread generasi latar belakang.

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

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

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

Hentikan thread generasi latar belakang. Jika flag `block` disetel ke True, maka metode ini akan menunggu thread berhenti selama waktu maksimum `timeout` detik (None berarti tidak ada batas waktu). Jika flag `keep_for_next_session` disetel ke True, maka manager akan di-cache pada model untuk digunakan di kemudian hari. Jika flag `hard_stop` disetel, thread generasi latar belakang akan dihentikan segera dan permintaan yang tertunda akan gagal.

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

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

Ganti implementasi attn menjadi satu yang kompatibel dengan CB. Jika auto_switch_to_flash bernilai True, dan implementasi attn adalah SDPA atau eager, juga beralih ke flash jika didukung dan tersedia.

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

```python
warmup()
```

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

Graf CUDA pra-capture untuk jalur varlen dan decode dengan menjalankan batch dummy. Menginisialisasi pemroses batch jika belum dilakukan.

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

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

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

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

Kelas basis abstrak untuk menjadwalkan permintaan dalam pemroses batch kontinu. Penjadwal mengelola siklus hidup permintaan dari saat ditambahkan ke antrean tunggu hingga dijadwalkan untuk diproses. Penjadwal yang berbeda menerapkan strategi yang berbeda untuk memprioritaskan dan membundel permintaan.

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

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

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

Menambahkan permintaan ke daftar tunggu.

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

```python
clear_cancelled_requests()
```

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

Hapus semua permintaan yang dibatalkan dari antrean aktif dan menunggu.

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

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

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

Menyelesaikan pemrosesan permintaan dan membebaskan blok cache yang dialokasikannya. Metode ini dipanggil ketika permintaan telah selesai menghasilkan atau mengalami kesalahan.

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

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

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

Mendapatkan token yang dihasilkan untuk permintaan yang aktif.

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

```python
has_pending_requests()
```

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

Memeriksa apakah ada permintaan yang siap diproses.

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

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

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

Memeriksa apakah permintaan telah dibatalkan atau dihapus.

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

```python
reset()
```

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

Reset status scheduler untuk loop generasi baru.

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

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

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

Merencanakan permintaan untuk batch berikutnya berdasarkan anggaran token dan cache yang tersedia. Metode ini memilih permintaan mana yang harus diproses dalam batch saat ini, dengan mempertimbangkan anggaran dan aturan prioritas scheduler. token_budget adalah jumlah maksimum token yang dapat diproses dalam satu batch, dan cache_budget adalah jumlah maksimum entri KV cache yang dapat dibaca dalam satu batch. Mengembalikan daftar permintaan yang dijadwalkan dalam bentuk "FutureRequestState", boolean yang menunjukkan apakah jalur cepat decode dapat digunakan, jumlah total token query, dan jumlah maksimum token kv yang dibaca.

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

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

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

Menandai permintaan pembatalan.

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

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

Penjadwal ini memproses permintaan sesuai urutan kedatangannya, yang berarti permintaan decoding memiliki prioritas lebih tinggi daripada permintaan prefilling.

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

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

Scheduler yang memprioritaskan permintaan split prefill di atas permintaan decoding. Scheduler ini memastikan bahwa permintaan split prefill (yang merupakan kelanjutan dari prompt yang diproses sebagian) diselesaikan sebelum memproses permintaan decoding baru.