Buckets:
| # DiffusionGemma | |
| DiffusionGemma adalah model bahasa encoder-decoder berbasis block-diffusion. Encoder kausal membaca prompt bersih (dan blok yang telah dihasilkan sebelumnya) ke dalam KV cache, sedangkan decoder bidireksional melakukan denoising pada "canvas" berukuran tetap berisi `canvas_length` token dengan melakukan cross-attention ke cache tersebut. Proses generasi bergantian antara loop autoregresif luar untuk canvas dan loop denoising dalam, di mana setiap langkah mengambil sampel token kandidat, mengunci token yang paling percaya diri melalui [BlockRefinementScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) dalam mode korupsi seragam, dan melakukan renoising pada sisanya. Model itu sendiri berada di `transformers` sebagai `DiffusionGemmaForBlockDiffusion`; checkpoint yang dirilis adalah [`google/diffusiongemma-26B-A4B-it`](https://huggingface.co/google/diffusiongemma-26B-A4B-it). | |
| ## Penggunaan | |
| ```py | |
| import torch | |
| from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion | |
| from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline | |
| model_id = "google/diffusiongemma-26B-A4B-it" | |
| model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto") | |
| processor = AutoProcessor.from_pretrained(model_id) | |
| scheduler = BlockRefinementScheduler() | |
| pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor) | |
| pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, mode="reduce-overhead", fullgraph=True) | |
| output = pipe( | |
| prompt="Why is the sky blue?", | |
| gen_length=256, | |
| num_inference_steps=48, | |
| cache_implementation="static", | |
| ) | |
| print(output.texts[0]) | |
| ``` | |
| `num_inference_steps` adalah jumlah langkah denoising per kanvas (48 sesuai dengan checkpoint yang dirilis); langkah yang lebih sedikit lebih cepat tetapi kualitasnya lebih rendah. `cache_implementation="static"` memungkinkan decoder untuk di-`torch.compile`-kan dengan cudagraphs (lihat [Static cache and compilation](#static-cache-and-compilation)); hilangkan keduanya untuk eksekusi dynamic-cache yang lebih sederhana. | |
| Untuk input multi-turn atau multimodal, berikan percakapan `messages` mentah alih-alih `prompt`. Ini adalah daftar dict `{"role", "content"}` dalam format chat biasa, yang diproses oleh processor melalui chat template-nya: | |
| ```py | |
| messages = [ | |
| {"role": "user", "content": "Why is the sky blue?"}, | |
| ] | |
| # or with an image: | |
| messages = [ | |
| { | |
| "role": "user", | |
| "content": [ | |
| {"type": "image", "image": image}, | |
| {"type": "text", "text": "Describe this image."}, | |
| ], | |
| }, | |
| ] | |
| output = pipe(messages=messages, gen_length=256) | |
| ``` | |
| Untuk satu giliran pengguna, Anda dapat melewati `messages` dan meneruskan `image` bersama dengan `prompt`; prosesor akan mengubahnya menjadi input gambar model secara otomatis. | |
| ## Penjadwal | |
| Scheduler adalah sampler yang melakukan denoising pada setiap kanvas, dan dapat diganti: tukar untuk mengubah strategi sampling tanpa menyentuh bagian lain. Tiga scheduler tersedia: | |
| - [BlockRefinementScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (default): mengunci token yang paling yakin pada setiap langkah (di atas `threshold`, ditambah kuota per langkah yang merata) dan melakukan renoising pada sisanya. `editing_threshold` juga memungkinkan scheduler untuk mengedit ulang token yang sudah dikunci. | |
| - [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler): mengambil sampel setiap posisi dari posterior diskrit yang tepat dari proses korupsi seragam (D3PM). Tidak memiliki parameter, dan langkah akhir secara deterministik mengunci token yang diprediksi. | |
| - [EntropyBoundScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler): mengomitm posisi dengan entropi terendah yang entropi gabungannya tetap di bawah `entropy_bound`, sehingga token yang kira-kira independen diterima bersama. Jadwal ini menurunkan suhu samplingnya dari `t_max` (`0.8`) pada langkah pertama hingga `t_min` (`0.4`) pada langkah terakhir, sesuai dengan sampler dari checkpoint yang dirilis. | |
| ```py | |
| from diffusers import DiscreteDDIMScheduler, EntropyBoundScheduler | |
| pipe.scheduler = DiscreteDDIMScheduler() | |
| # or: pipe.scheduler = EntropyBoundScheduler(entropy_bound=0.1) | |
| output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48) | |
| print(output.texts[0]) | |
| ``` | |
| Parameter sampling spesifik scheduler (seperti `threshold`/`top_k` untuk penyempurnaan blok, batas entropi, ...) diatur pada konfigurasi scheduler: | |
| ```py | |
| from diffusers import BlockRefinementScheduler | |
| pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, threshold=0.9) | |
| ``` | |
| `EntropyBoundScheduler` melakukan annealing pada suhu sampling-nya (`t_max`/`t_min`) secara internal di sepanjang langkah denoising; `DiscreteDDIMScheduler` dan `BlockRefinementScheduler` menggunakan `temperature` datar yang diteruskan ke pipeline (`0.0` untuk greedy). | |
| ### Pem sampling predictor-corrector | |
| `DiscreteDDIMScheduler` mendukung predictor-corrector leave-one-out dari [Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation](https://huggingface.co/papers/2605.22765). Komponen ini menyempurnakan kanvas dengan `corrector_steps` Gibbs sweeps yang melakukan resampling pada posisi dengan keyakinan terendah dari kondisional satu-koordinat dari marginal berisik, yang membuat marginal tersebut tetap invarian dan meningkatkan kualitas generasi tanpa biaya pelatihan tambahan. Metode ini bekerja langsung pada checkpoint yang dirilis: untuk uniform diffusion, denoiser dan posterior leave-one-out dapat dipertukarkan dalam bentuk tertutup, sehingga corrector dapat memulihkan kuantitas leave-one-out yang dibutuhkan tanpa perlu pelatihan ulang. | |
| Sweep korektor dilipat ke dalam anggaran `num_inference_steps` alih-alih ditambahkan di atasnya: pipeline menjalankan langkah prediktor yang lebih sedikit dan mengalokasikan forwards yang dibebaskan untuk korektor, sehingga jumlah total model forwards tetap `num_inference_steps` dan biaya prediktor-korektor sama dengan sampling ancestral biasa. | |
| ```py | |
| from diffusers import DiscreteDDIMScheduler | |
| pipe.scheduler = DiscreteDDIMScheduler(corrector_steps=2, corrector_k=12) | |
| output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48) | |
| print(output.texts[0]) | |
| ``` | |
| ## Adaptasi PEFT | |
| Denoiser adalah model 🤗 Transformers, sehingga adapter dimuat melalui integrasi [PEFT](https://huggingface.co/docs/peft) natifnya, bukan melalui API `load_lora_weights` dari diffusers. Karena integrasi tersebut tidak bergantung pada jenis adapter, pemanggilan yang sama dapat memuat LoRA, DoRA, atau adapter PEFT lainnya (misalnya, keluaran dari `SFTTrainer` TRL). Kelola adapter langsung pada komponen model: | |
| ```py | |
| pipe.model.load_adapter("path/to/adapter", adapter_name="sft") # LoRA, DoRA, ... | |
| pipe.model.set_adapter("sft") | |
| output = pipe(prompt="Why is the sky blue?", gen_length=256) | |
| pipe.model.disable_adapters() # run the base model | |
| pipe.model.delete_adapter("sft") | |
| ``` | |
| Adapters tetap aktif dan tidak digabungkan: DiffusionGemma mengikat bobot dasar encoder dan decoder, sehingga menggabungkan adapter ke dalamnya akan merusak kedua cabang. | |
| ## Cache statis dan kompilasi | |
| Pipeline mem-prefill encoder sekali per blok ke dalam cache yang dapat digunakan ulang (secara default berupa `DynamicCache`). Menyalurkan `cache_implementation="static"` menggunakan `StaticCache` dengan bentuk tetap sebagai gantinya, di mana bentuk-bentuknya memungkinkan Anda untuk `torch.compile` decoder dengan cudagraphs untuk percepatan lebih lanjut (pipeline menandai setiap langkah dan meng-clone logits agar memori cudagraph tidak ditimpa); ini adalah konfigurasi yang ditunjukkan di [Penggunaan](#usage). Buanglah panggilan `torch.compile` dan `cache_implementation="static"` untuk menjalankan dengan cache dinamis yang lebih sederhana. | |
| ## Penghentian adaptif | |
| Sebuah blok biasanya konvergen sebelum semua `num_inference_steps` terpakai, sehingga secara default pipeline membekukan setiap contoh batch begitu prediksi argmax-nya stabil selama `stability_threshold` langkah dan entropi rata-rata per tokennya turun di bawah `confidence_threshold` (`0.005`, nilai yang digunakan oleh checkpoint yang dirilis). Loop denoising berakhir begitu semua contoh dibekukan. Hal ini secara kasar mengurangi jumlah forward decoder menjadi setengahnya pada kualitas yang setara dan merupakan tuas throughput tunggal terbesar. Lewatkan `confidence_threshold=None` untuk selalu menjalankan `num_inference_steps` penuh: | |
| ```py | |
| output = pipe(prompt="Why is the sky blue?", gen_length=256, confidence_threshold=None) # disable adaptive stopping | |
| ``` | |
| ## Callback | |
| Callbacks dijalankan setelah setiap langkah denoising. Sampaikan `callback_on_step_end_tensor_inputs` untuk memilih tensor mana yang disertakan dalam `callback_kwargs`; `canvas` (token blok saat ini) dan `logits` tersedia. Kembalikan `{"canvas": ...}` dari callback untuk mengganti canvas. | |
| ```py | |
| def on_step_end(pipe, step, timestep, callback_kwargs): | |
| canvas = callback_kwargs["canvas"] | |
| # Inspect or modify `canvas` here. | |
| return {"canvas": canvas} | |
| out = pipe( | |
| prompt="Why is the sky blue?", | |
| callback_on_step_end=on_step_end, | |
| callback_on_step_end_tensor_inputs=["canvas"], | |
| ) | |
| ``` | |
| ## DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]] | |
| #### diffusers.DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]] | |
| ```python | |
| diffusers.DiffusionGemmaPipeline(model: Any, scheduler: BlockRefinementScheduler | DiscreteDDIMScheduler | EntropyBoundScheduler, processor: Any) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L53) | |
| **Parameter:** | |
| model ([DiffusionGemmaForBlockDiffusion](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion)) : Denoiser block-diffusion (encoder kausal + decoder bidireksional dengan bobot terikat). | |
| scheduler ([BlockRefinementScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler), [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler) atau [EntropyBoundScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler)) : Sampler yang mengonfirmasi dan menambahkan noise pada token kanvas di setiap langkah denoising. | |
| processor ([ProcessorMixin](https://huggingface.co/docs/transformers/v5.22.2/en/main_classes/processors#transformers.ProcessorMixin)) : prosesor yang digunakan untuk menerapkan templat obrolan dan mendekode token yang dihasilkan. | |
| Pipeline untuk generasi teks block-diffusion DiffusionGemma. | |
| DiffusionGemma adalah model encoder-decoder berbasis block-diffusion: encoder kausal membaca prompt bersih (dan blok yang telah dihasilkan sebelumnya) ke dalam KV cache, sedangkan decoder bidireksional melakukan denoising pada "canvas" berukuran tetap berisi `canvas_length` token dengan melakukan cross-attention ke cache tersebut. Proses generasi bergantian antara loop autoregresif eksternal untuk canvas dan loop denoising internal, di mana setiap langkah mengambil sampel token kandidat, mengunci token yang paling yakin melalui [BlockRefinementScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (mode korupsi seragam, `mask_token_id=None`), dan melakukan renoising pada sisanya. | |
| Model yang diharapkan adalah instance `DiffusionGemmaForBlockDiffusion` yang mengekspos `forward(input_ids, decoder_input_ids=..., self_conditioning_logits=..., ...)` dan mengembalikan logits dengan bentuk `[batch, canvas_length, vocab_size]` di atas canvas. Lihat kartu model di https://huggingface.co/google/diffusiongemma-26B-A4B-it. | |
| #### __call__[[diffusers.DiffusionGemmaPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str] | None = None, messages: list[dict] | None = None, image: Any | list[Any] | None = None, add_generation_prompt: bool = True, gen_length: int = 256, num_inference_steps: int = 48, temperature: float = 0.0, cache_implementation: str | None = None, eos_early_stop: bool = True, eos_token_id: int | None = None, stability_threshold: int = 1, confidence_threshold: float | None = 0.005, generator: torch.Generator | None = None, output_type: str = 'text', return_dict: bool = True, callback_on_step_end: Callable[[Any, int, int, dict], dict] | PipelineCallback | MultiPipelineCallbacks | None = None, callback_on_step_end_tensor_inputs: list[str] | None = None) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L163) | |
| **Parameter:** | |
| prompt (`str` atau `List[str]`, *opsional*) : Teks prompt, dibungkus dalam template chat dan ditokenisasi oleh prosesor. Berikan salah satu dari ini atau `messages`. | |
| messages (`List[Dict]`, *opsional*) : Percakapan chat mentah untuk dienkod, misalnya `[{"role": "user", "content": "Hello"}]` atau percakapan multi-turn / multimodal. Gunakan ini alih-alih `prompt` untuk apa pun di luar satu giliran pengguna. | |
| image (`PIL.Image.Image` atau `List`, *opsional*) : Gambar yang akan dipasangkan dengan `prompt` untuk generasi multimodal; prosesor mengubahnya menjadi input gambar model. Untuk tata letak yang lebih kaya, letakkan konten gambar langsung di `messages`. | |
| add_generation_prompt (`bool`, defaultnya `True`) : Apakah akan menambahkan prompt generasi saat menerapkan template chat. | |
| gen_length (`int`, defaultnya `256`) : Jumlah token yang akan dihasilkan, dibulatkan ke atas menjadi kelipatan dari `canvas_length` model. | |
| num_inference_steps (`int`, defaultnya `48`) : Jumlah langkah denoising per kanvas. | |
| temperature (`float`, defaultnya `0.0`) : Suhu sampling untuk `DiscreteDDIMScheduler`/`BlockRefinementScheduler` (`0.0` adalah greedy); `EntropyBoundScheduler` mengabaikannya dan melakukan annealing pada suhu miliknya sendiri. Pengaturan sampling lainnya (mis. `top_k`, `threshold`, `t_min`/`t_max`) adalah konfigurasi scheduler; atur pada scheduler, mis. `pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, top_k=...)`. | |
| cache_implementation (`str`, *opsional*) : Atur ke `"static"` untuk mengisi awal encoder sekali per blok ke dalam `StaticCache` yang persisten dan menjalankan decoder terhadapnya dengan bentuk tetap, alih-alih meng-encode ulang seluruh urutan pada setiap langkah. Bentuk tetap ini juga memungkinkan Anda untuk mengompilasi decoder, misalnya `pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, fullgraph=True)`. | |
| eos_early_stop (`bool`, defaultnya `True`) : Apakah akan menghentikan pembuatan kanvas lebih lanjut setelah setiap urutan telah mengeluarkan EOS. | |
| eos_token_id (`int`, *opsional*) : ID token EOS untuk penghentian dini. Mengembalikan ke tokenizer dari prosesor. | |
| stability_threshold (`int`, defaultnya `1`) : Jumlah langkah berurutan di mana prediksi argmax dari sebuah contoh harus tetap tidak berubah agar contoh tersebut dihitung sebagai stabil. Hanya digunakan ketika `confidence_threshold` disetel. | |
| confidence_threshold (`float`, *opsional*, default `0.005`) : Bekukan setiap contoh begitu stabil (lihat `stability_threshold`) dan entropi rata-rata per token dari logit prediksi yang dibentuk oleh scheduler-nya berada di bawah nilai ini. Loop denoising blok berakhir begitu semua contoh dibekukan. Mempercepat generasi pada kualitas yang setara; nilai default sesuai dengan checkpoint yang dirilis. Atur ke `None` untuk selalu menjalankan semua `num_inference_steps`. | |
| generator (`torch.Generator`, *opsional*) : RNG untuk sampling. | |
| output_type (`str`, defaultnya `"text"`) : `"text"` mendekode urutan menjadi string (memerlukan prosesor); `"seq"` hanya mengembalikan ID token. | |
| return_dict (`bool`, defaultnya `True`) : Apakah akan mengembalikan [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) alih-alih tuple. | |
| callback_on_step_end (`Callable` atau `PipelineCallback`, *opsional*) : Callback yang dijalankan setelah setiap langkah denoising dengan tanda tangan `callback_on_step_end(self, step, timestep, callback_kwargs)`. Kunci tensor yang diizinkan: `canvas`, `logits`. | |
| callback_on_step_end_tensor_inputs (`List[str]`, *opsional*) : Kunci Tensor untuk diteruskan ke callback. | |
| **Mengembalikan:** [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/id/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) atau `tuple` | |
| ID token yang dihasilkan (`sequences`) dan, untuk `output_type="text"`, `texts` yang didekodekan. | |
| Generate teks dengan block diffusion. | |
| Contoh: | |
| ```python | |
| >>> import torch | |
| >>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion | |
| >>> from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline | |
| >>> model_id = "google/diffusiongemma-26B-A4B-it" | |
| >>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto") | |
| >>> processor = AutoProcessor.from_pretrained(model_id) | |
| >>> scheduler = BlockRefinementScheduler() | |
| >>> pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor) | |
| >>> output = pipe(prompt="Why is the sky blue?", gen_length=256) | |
| >>> print(output.texts[0]) | |
| ``` | |
| ## DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]] | |
| #### diffusers.DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]] | |
| ```python | |
| diffusers.DiffusionGemmaPipelineOutput(sequences: torch.LongTensor, texts: list[str] | None = None) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_output.py#L25) | |
| **Parameter:** | |
| sequences (`torch.LongTensor` dengan bentuk `(batch_size, gen_length)`) : ID token yang dihasilkan (prompt dihapus). | |
| texts (`list[str]`, *opsional*) : Teks yang didekodekan, satu string per sekuens. Hanya diset untuk `output_type="text"`. | |
| Kelas output untuk generasi block-diffusion DiffusionGemma. | |
Xet Storage Details
- Size:
- 18.3 kB
- Xet hash:
- 6f7781ecd8ef83fbfd820995c7deb0bbaf2e48b5d849b24cd504f37e4f6dfa39
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.