# DiffusionGemma

## Genel Bakış

DiffusionGemma, standart nedensel dil modellerinin ardışık darboğazlarını azaltmak üzere tasarlanmıştır. Çıkarım hızı için özellikle optimize edilmiş bir kodlayıcı-çözücü mimarisi kullanır.

Encoder, prefill kapasitesinde çalışarak başlangıç istemini işler ve KV önbelleğini oluşturur. Ardından decoder, çift yönlü dikkat (bidirectional attention) kullanarak bir token bloğunu (bir 'tuval') işler ve çapraz dikkat (cross-attention) aracılığıyla önbelleğe alınmış bağlama erişir.

Çıkarım sırasında DiffusionGemma, çoklu tuval örneklemesinden (multi-canvas sampling) yararlanır. Model, token'ları tek tek üretmek yerine, bir difüzyon örnekleme cihazı (diffusion sampler) kullanarak tam bir token bloğunu yinelemeli olarak gürültüden arındırır (denoise). Bir tuval tamamen gürültüden arındırıldığında, kodlayıcı (encoder) tarafından işlenir ve KV önbelleğine eklenir; ardından model bir sonraki tuvali üretir. Bu blok-otoregresif yaklaşım, daha yüksek hızlarda metin üretimini kolaylaştırır.

Model kartını ve checkpoint'i [burada](https://huggingface.co/google/diffusiongemma-26B-A4B-it) bulabilirsiniz. Modelin görsel rehberine [buradan](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma) ulaşabilirsiniz.

## Kullanım örnekleri

Bir metin difüzyon modeli olmasına ve özel bir üretim döngüsüne sahip olmasına rağmen, arayüzün büyük kısmı metin üretebilen diğer modellerle, [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate) ile paylaşılmaktadır. Uygulamanızda başka bir `transformers` modeli kullanıyorsanız, bu modeli doğrudan onun yerine kullanabilirsiniz.

> [!NOTE]
> DiffusionGemma hem Transformers hem de Diffusers'ta kullanılabilir, ancak Diffusers ana evi olarak kabul edilir. Diffusers, zamanlama seçeneklerinin tam setini, pipeline yardımcı programlarını ve yeni özellikleri (ek zamanlayıcılar, durdurma kriterleri, örneklem stratejileri) içerir ve bu özellikler yalnızca oraya eklenir. Kullanım örnekleri için [DiffusionGemma](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma) dokümanına bakın ve farklı zamanlayıcılarla deney yapmak veya bir özellik talep etmek için Diffusers'ta bir [issue](https://github.com/huggingface/diffusers/issues) açın. Transformers uygulaması yalnızca hata düzeltmeleri alır, yeni özellikler almaz.

### Sık karşılaşılan sorunlar

- DiffusionGemma `use_cache` parametresini kabul etmez. Her zaman bir KV önbelleği kullanır;
- `top_k` gibi yaygın bayrakların desteği, yayın günü itibarıyla mevcut olmayacak ancak metin difüzyonuyla uyumlu oldukları takdirde zamanla eklenecektir.

### Temel örnek

```python
from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor

model = DiffusionGemmaForBlockDiffusion.from_pretrained(
    "google/diffusiongemma-26B-A4B-it", device_map="auto",
)
processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

messages = [
    {
        "role": "user", "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "What is shown in this image?"},
        ]
    },
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    # Add the following to enable thinking
    # enable_thinking=True,
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

# Set `cache_implementation="static"` in `generate` to trigger `torch.compile`.
# Compilation is much faster, after warming up!
output = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(output.sequences[0][input_len:], skip_special_tokens=True))
```

### Akış

Diğer metin üretebilen modellerde olduğu gibi, metni akış olarak almak için bir streamer sınıfı ayarlayabilirsiniz. Diğer modellerden farklı olarak DiffusionGemma, nihai metinden önce ara taslaklar üretir. Bunları `TextDiffusionStreamer` ile görselleştirebilirsiniz.

```python
from transformers import TextDiffusionStreamer

# (... copy from the example above, up to the `generate` call)
streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
model.generate(**inputs, max_new_tokens=256, streamer=streamer)
```

### Başlangıç gürültü azaltma çıktısı ayarlama

Model, 256 jetonluk blokları iteratif olarak iyileştirmek üzere eğitilir. Bazı uygulamalarda, rastgele jetonlardan başlamak yerine dekodere bir başlangıç noktası sağlamak faydalı olabilir. Başlangıç tuvalini ayarlamak için tüm model arayüzlerinde mevcut olan `decoder_input_ids` parametresini kullanabilirsiniz.

```py
initial_estimate = ... # a tensor with shape (bsz, 256)
model.generate(**inputs, max_new_tokens=256, decoder_input_ids=initial_estimate)
```

## DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]]

#### transformers.DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]]

```python
transformers.DiffusionGemmaTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 262144, hidden_size: int = 2304, intermediate_size: int = 9216, num_hidden_layers: int = 30, num_attention_heads: int = 8, num_key_value_heads: int = 4, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = 2, tie_word_embeddings: bool = True, rope_parameters: dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, sliding_window: int = 512, layer_types: list[str] | None = None, use_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = None, num_experts: int | None = None, top_k_experts: int | None = None, moe_intermediate_size: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L35)

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `262144`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

hidden_size (`int`, *isteğe bağlı*, varsayılan `2304`) : Gizli temsillerin boyutu.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `9216`) : MLP temsil boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `30`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `8`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

num_key_value_heads (`int`, *opsiyonel*, varsayılan `4`) : Grouped Query Attention'ı uygulamak için kullanılması gereken key_value başlarının sayısıdır. `num_key_value_heads=num_attention_heads` ise model Multi Head Attention (MHA) kullanır, `num_key_value_heads=1` ise model Multi Query Attention (MQA) kullanır, aksi halde GQA kullanılır. Çok başlı bir checkpoint'i GQA checkpoint'ine dönüştürürken, her grup key ve value başı, o gruptaki tüm orijinal başların ortalama havuzlanması (meanpooling) ile oluşturulmalıdır. Daha fazla ayrıntı için [bu makaleye](https://huggingface.co/papers/2305.13245) göz atın. Belirtilmezse, varsayılan olarak `num_attention_heads` kullanılır.

head_dim (`int`, *isteğe bağlı*, varsayılan `256`) : Dikkat başı boyutu. None ise, hidden_size // num_attention_heads değerine ayarlanır.

hidden_activation (`str`, *isteğe bağlı*, varsayılan `gelu_pytorch_tanh`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `131072`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

rms_norm_eps (`float`, *opsiyonel*, varsayılan `1e-06`) : rms normalizasyon katmanları tarafından kullanılan epsilon.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `0`) : Sözlükte dolgu için kullanılan token kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*, varsayılan `1`) : Sözlükte akış sonu için kullanılan token kimliği.

bos_token_id (`int`, *isteğe bağlı*, varsayılan `2`) : Sözlükte akış başlangıcı için kullanılan token kimliği.

tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `True`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir.

rope_parameters (`dict`, *isteğe bağlı*) : RoPE gömme yapılandırma parametrelerini içeren sözlük. Sözlük, `rope_theta` için bir değer içermeli ve daha uzun `max_position_embeddings` ile RoPE kullanmak istiyorsanız ölçekleme için kullanılan parametreleri isteğe bağlı olarak içermelidir.

attention_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : Kendi kendine dikkat (self-attention) sırasında sorgu, anahtar, değer ve çıktı projeksiyon katmanlarında sapma (bias) kullanılıp kullanılmayacağı.

attention_dropout (`Union[int, float]`, *isteğe bağlı*, varsayılan `0.0`) : Dikkat olasılıkları için dropout oranı.

sliding_window (`int`, *isteğe bağlı*, varsayılan `512`) : Kayan pencere dikkat penceresi boyutu. `None` ise kayan pencere uygulanmaz.

layer_types (`list[str]`, *isteğe bağlı*) : Her katman indeksini katman türüyle açıkça eşleyen bir liste. Sağlanmazsa, yapılandırma değerlerine göre otomatik olarak oluşturulur.

use_bidirectional_attention (`str`, *isteğe bağlı*) : Çift yönlü dikkat davranışını kontrol eder. `"vision"` olarak ayarlandığında, görsel jetonlar çift yönlü dikkat kullanırken metin jetonları nedensel dikkat kullanır. `"all"` olarak ayarlandığında, tüm jetonlar çift yönlü dikkat kullanır.

num_experts (`int`, *isteğe bağlı*) : MoE katmanlarındaki yönlendirilmiş uzman sayısı.

top_k_experts (`int`, *isteğe bağlı*) : MoE katmanlarında token başına etkinleştirilen uzman sayısı.

moe_intermediate_size (`int`, *isteğe bağlı*) : MoE katmanlarında her uzmanın ileri beslemeli ağının ara (gizli) boyutu.

Bu, bir DiffusionGemmaModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Diffusion Gemma modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it) modelinin yapılandırmasına benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

## DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]]

#### transformers.DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]]

```python
transformers.DiffusionGemmaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: transformers.models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, initializer_range: float | None = 0.02, tie_word_embeddings: bool = True, canvas_length: int | None = 256)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L162)

**Parametreler:**

text_config (`Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]]`, *isteğe bağlı*) : Metin omurgasının yapılandırma nesnesi veya sözlüğü.

vision_config (`Union[~configuration_utils.PreTrainedConfig, dict[str, Any]]`, *isteğe bağlı*) : Görüntü iskeletinin config nesnesi veya sözlüğü.

boi_token_id (`int`, *opsiyonel*, varsayılan 255999) : Görsel istemi sarmak için kullanılan başlangıç görsel (begin-of-image) jeton indeksi.

eoi_token_id (`int`, *opsiyonel*, varsayılan 258882) : Görsel istemi sarmak için kullanılan görsel sonu (end-of-image) belirteç dizini.

image_token_id (`int`, *isteğe bağlı*, varsayılan `258880`) : Girdi görselleri için yer tutucu olarak kullanılan görsel jeton indeksi.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `True`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir.

canvas_length (`int`, *isteğe bağlı*, varsayılan 256) : Tuvalin boyutu veya başka bir deyişle, blok difüzyonundaki blok uzunluğu. Boş bir tuvali başlatmak için kullanılır.

Bu, bir DiffusionGemmaModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Diffusion Gemma modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it) modelinin yapılandırmasına benzer bir yapılandırma elde edilir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import (
>>>     DiffusionGemmaConfig,
>>>     DiffusionGemmaModel,
>>>     DiffusionGemmaTextConfig,
>>>     Gemma4VisionConfig,
>>> )

>>> # Initializing a DiffusionGemma Text config.
>>> text_config = DiffusionGemmaTextConfig()

>>> # Initializing a Gemma 4 vision config (DiffusionGemma uses Gemma 4's vision block).
>>> vision_config = Gemma4VisionConfig()

>>> # Initializing a DiffusionGemma text config
>>> configuration = DiffusionGemmaConfig(text_config, vision_config)

>>> # Initializing a model from the configuration
>>> model = DiffusionGemmaModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]]

#### transformers.DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]]

```python
transformers.DiffusionGemmaGenerationOutput(sequences: LongTensor, tokens_per_forward: int | None = None, past_key_values: transformers.cache_utils.Cache | None = None, logits: None = None, scores: None = None, hidden_states: None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L247)

**Parametreler:**

sequences (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : `generate` yöntemine `input_ids` sağlandıysa, istemi de içeren üretilmiş diziler.

tokens_per_forward (`torch.LongTensor`, şekli (`batch_size`)): Bu `generate` çağrısında, ileri yönlendirmede (forward) her bir token sayısı, batch'teki her üye için. Bu, metin difüzyon modelleri için genellikle ikincil bir değerlendirme metriği olarak kullanılır.

past_key_values (`Cache`) : Üretim için kullanılan önbellek. Çok turlu oturumlarda üretimi hızlandırmak için `generate` çağrılarının ardışık çağrılarında geçirilebilir.

logits (`None`) : Kullanılmıyor. Arayüzde geriye dönük uyumluluk için korunmuştur.

scores (`None`) : Kullanılmıyor. Arayüzde geriye dönük uyumluluk için korunmuştur.

hidden_states (`None`) : Kullanılmıyor. Arayüzde geriye dönük uyumluluk için korunmuştur.

DiffusionGemma üretimi için çıktı sınıfı.

## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

#### transformers.DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

```python
transformers.DiffusionGemmaGenerationMixin()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L543)

DiffusionGemma üretimi için Mixin sınıfı. Tüm model düzeyindeki yöntemleri içerir.

#### generate[[transformers.DiffusionGemmaGenerationMixin.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, streamer: transformers.generation.streamers.BaseStreamer | None = None, generation_config: transformers.models.diffusion_gemma.generation_diffusion_gemma.DiffusionGemmaGenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L548)

**Parametreler:**

input_ids (*torch.LongTensor*, şekli *(batch_size, sequence_length)*, *opsiyonel*) : Üretim için istem (prompt) olarak kullanılan dizi.

past_key_values ([Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache), *opsiyonel*) : Dekoder için geçmiş anahtar değerlerini ve geçmiş dikkat maskelerini içeren Cache nesnesi. Ayarlanmışsa, `input_ids` ve/veya `pixel_values` yalnızca önbelleğe alınmamış verilerle eşleşmelidir.

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 akışın herhangi bir sonraki işleme sorumluluğu streamer'a aittir. Streamer nesnesinin bir `put_draft` metodu varsa, gürültü azaltma adımlarından gelen jetonlar oraya gönderilir.

**Gelişmiş kullanıcılar için ek argümanlar:**

generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationConfig), *isteğe bağlı*) : Üretim çağrısı için temel parametrelendirme olarak kullanılacak üretim yapılandırması, model varsayılanlarını geçersiz kılar. Model kontrol noktasında bir `generation_config.json` dosyası varsa, model varsayılanı oradan yüklenir. Aksi takdirde, boş bir `DiffusionGemmaGenerationConfig` örneği olur. Ek bir kısayol olarak, `generation_config` içindeki özniteliklerle eşleşen `**kwargs` bu öznitelikleri geçersiz kılar.

logits_processor ([LogitsProcessorList](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.LogitsProcessorList), *opsiyonel*) : Argümanlardan ve üretim yapılandırmasından oluşturulan varsayılan logits işleyicilerini tamamlayan, difüzyon logits'lerine uygulanacak özel logits işleyicileri. Sağlanırsa, bu işleyiciler ilk olarak uygulanır. Bu özellik, ileri düzey kullanıcılar için tasarlanmıştır. Örneğin, AR LLM'lerle yaygın olarak kullanılan logits işleyicilerini buradan geçirebilirsiniz.

stopping_criteria ([StoppingCriteriaList](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.StoppingCriteriaList), *optional*) : Argümanlardan ve bir generation config'ten oluşturulan varsayılan blok otoregresif durdurma kriterlerini tamamlayan özel durdurma kriterleri. Sağlanırsa, bu kriterler ilk olarak uygulanır. Bu özellik ileri düzey kullanıcılar için tasarlanmıştır. Örneğin, AR LLM'lerle yaygın olarak kullanılan durdurma kriterlerini buradan geçirebilirsiniz.

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. Örneğin, başlangıç tuvalini `decoder_input_ids` ile ayarlayabilirsiniz.

**Dönüş:** `torch.LongTensor` veya [DiffusionGemmaGenerationOutput](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput)

- `torch.LongTensor`: kimlikler olarak üretilen metin.
- [DiffusionGemmaGenerationOutput](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput): üretilen metni (`sequences`) ve diğer isteğe bağlı çıktıları içeren bir `ModelOutput` örneği.

Difüzyon modelini kullanarak metin üretir.

Dışında tuval (token blokları) üretimi için otoregresif üretim yapan bir dış döngü ve içinde

her tuval üzerinde difüzyon yapan döngü. Algoritma kabaca şu şekilde çalışır:
```
1. Autoregressive canvas generation loop:
    a. Encode all previous tokens using the encoder, to get the KV cache.
    b. Prepare data for the new denoising loop
    c. For each denoising (diffusion) step:
        i.   Run the decoder, taking the current canvas, the encoder KV cache, and the self-conditioning logits
             (if available) as inputs.
        ii.  Select new canvas tokens from the output logits.
        iii. Apply the sampler acceptance and renoising logic.
        iv.  Update the diffusion stopping criteria.
        v.   Use the output logits as self-conditioning logits for the next step.
    d. Append the new denoised canvas to the sequence of generated tokens.
    e. Check if any autoregressive stopping criteria are met, and break the outer loop if all sequences have
       met them. Replaces generated tokens in finished sequences by pad.
    f. Prepare tensors for the next block
```

Örnekler:

```python
>>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(
...     "google/diffusiongemma-26B-A4B-it", device_map="auto",
>>> )

>>> chat = [{"role": "user", "content": "Why is the sky blue?"},]
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")
>>> input_ids = processor.apply_chat_template(chat, tokenize=True, return_tensors="pt")

>>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
>>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer)
```

## DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]]

#### transformers.DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L55)

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

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

max_length (`int`, *isteğe bağlı*) : Çıktı dizisinin maksimum uzunluğu. Modelin kaç token üreteceğini kontrol etmek için `max_new_tokens` önerilir.

**Diffusion parametreleri:**

max_denoising_steps (`int`) : Uygulanacak maksimum gürültü azaltma adımı sayısı.

sampler_config (`EntropyBoundSamplerConfig`) : Örnekleme aygıtı (sampler) yapılandırması. Metin difüzyon modelinde bir örnekleme aygıtının nasıl çalıştığını öğrenmek için [EntropyBoundSampler](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.EntropyBoundSampler) bölümüne bakın.

t_min (`float`) : Zamanlamadaki son sıcaklık, yani son gürültü azaltma adımındaki değer. Daha fazla ayrıntı için [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor)'a bakın.

t_max (`float`) : Zamanlamadaki başlangıç sıcaklığı, yani ilk gürültü azaltma adımındaki değer. Daha fazla ayrıntı için [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor)'e bakın.

stability_threshold (`int`) : Kabul edilen tuvalin durdurma kriterini tetiklemesi için aynı olması gereken adım sayısı. Daha fazla ayrıntı için [StableAndConfidentStoppingCriteria](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) bölümüne bakın.

confidence_threshold (`float`) : Sıcaklık ölçekli logitlerin entropisinin ortalamasının durdurma kriterlerini tetiklemesi için eşik değeri. Daha fazla ayrıntı için [StableAndConfidentStoppingCriteria](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) bölümüne bakın.

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

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/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.QuantizedCache)  Hiçbiri belirtilmezse, modelin varsayılan önbelleği (çoğu zaman [DynamicCache](/docs/transformers/v5.23.0/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.

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

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

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

[DiffusionGemmaGenerationMixin.generate()](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate) için parametrelendirmesi özelleştirilmiş bir GenerationConfig sınıfı.

## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

#### transformers.EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

```python
transformers.EntropyBoundSamplerConfig(entropy_bound: float)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L320)

**Parametreler:**

entropy_bound (`float`) : Entropi sınırı. Bu değer ne kadar yüksekse, o kadar çok token kabul edilir. Uygulanma şekliyle ilgili daha fazla ayrıntı için [EntropyBoundSampler.accept_canvas()](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.EntropyBoundSampler.accept_canvas) dokümantasyon dizesine bakın.

Entropi sınırı örnekleyicisi için yapılandırma sınıfı.

## EntropyBoundSampler[[transformers.EntropyBoundSampler]]

#### transformers.EntropyBoundSampler[[transformers.EntropyBoundSampler]]

```python
transformers.EntropyBoundSampler(config: EntropyBoundSamplerConfig, canvas_length: int, vocab_size: int, max_denoising_steps: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L343)

**Parametreler:**

config (`EntropyBoundSamplerConfig`) : Örnekleme aygıtının yapılandırması.

canvas_length (`int`) : Tuvalin uzunluğu.

vocab_size (`int`) : Sözlüğün boyutu.

max_denoising_steps (`int`) : Gürültü azaltma adımlarının maksimum sayısı. (Bu örnekleyicide kullanılmaz)

Rastgele jetonlarla bir tuvali başlatan, jeton düzeyindeki entropiye dayalı olarak jetonları kabul eden ve kabul edilmeyen jetonları yeniden gürültüleyen Sampler sınıfı.

Örnekleme döngüsünün nasıl çalıştığına dair kabaca bir taslak aşağıdadır:
```
          +-----------------------+
          | Canvas initialization |
          | x_T ∈ U(V)            |
          +-----------+-----------+
                      |
                      v
           +----------+---------+       +---------------------+
+--------->| Current canvas x_t |------>| Denoiser canvas x_D |
|          +----------+---------+       +----------+----------+
|                      \                          /
|                       \                        /
|                        \   Acceptance logic   /
|                         v                    v
|                       +-------------------------+
| Stop if max           | Accepted canvas x_{t-1} |
| denosing steps        +------------+------------+      +-------------------+
| reached or                          \                  | New canvas ∈ U(V) |
| adaptive stopping                    \                 +---------+---------+
| triggers                              \    Renoising logic      /
|                                        v                       v
|                                       +-------------------------+
+---------------------------------------| Next canvas x_{t-1}     |
                                        +-------------------------+
```

#### accept_canvas[[transformers.EntropyBoundSampler.accept_canvas]]

```python
accept_canvas(current_canvas: LongTensor, denoiser_canvas: LongTensor, logits: Tensor, cur_step: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L406)

**Parametreler:**

current_canvas (`torch.LongTensor`) : Mevcut tuval.

denoiser_canvas (`torch.LongTensor`) : Gürültüden arındırıcı tahminlerinden örneklenen tuval.

logits (`torch.Tensor`) : Gürültü azaltıcıdan gelen logitler.

cur_step (`int`) : Güncel adım.

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

Kabul edilen tuval.

Entropi sınırına göre denoiser'dan token'ları kabul eder. Daha somut olarak, örnekleme, en düşük entropiye sahip k token'ı kabul ederek ilerler, böylece

sum_i^k entropy_i - max(entropy_1, ..., entropy_k) <= entropy_bound,

burada sol taraf, bu tokenlar arasındaki ortak karşılıklı bilginin üst sınırını ifade eder ve dolayısıyla örnekleyici yaklaşık olarak bağımsız olan k tokenı seçer.

https://arxiv.org/pdf/2505.24857 adresinde ilk olarak önerilmiştir

#### initialize_canvas[[transformers.EntropyBoundSampler.initialize_canvas]]

```python
initialize_canvas(batch_size: int, device: device)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L394)

Sözlükten rastgele değerlere sahip, `canvas_length` token uzunluğunda yeni bir tuval başlatır ve döndürür.

#### renoise_canvas[[transformers.EntropyBoundSampler.renoise_canvas]]

```python
renoise_canvas(accepted_canvas: LongTensor, cur_step: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L450)

**Parametreler:**

accepted_canvas (`torch.LongTensor`) : Kabul edilen tuval.

cur_step (`int`) : Güncel adım. (Bu örnekleyicide kullanılmaz)

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

Gürültü eklenmiş tuval.

Tüm kabul edilmeyen tokenları yeniden örnekler.

## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

#### transformers.StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

```python
transformers.StableAndConfidentStoppingCriteria(stability_threshold: int, confidence_threshold: float)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L484)

**Parametreler:**

stability_threshold (`int`) : Durdurma kriterinin tetiklenmesi için kabul edilen tuvalin aynı olması gereken adım sayısı.

confidence_threshold (`float`) : Durdurma kriterini tetiklemek için, sıcaklık ölçekli logitlerin entropisinin ortalamasının eşiği.

Difüzyon süreci kendinden emin ve kararlı olduğunda duran adaptif durdurma stratejisi. Daha spesifik olarak:
- Kabul edilen tuval, `stability_threshold` adım boyunca aynı kaldığında difüzyon süreci kararlıdır.
- Diffüzyon süreci, işlenmiş logitlerin entropisinin ortalaması `confidence_threshold`'in altındaysa kendinden emindir.

## LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

#### transformers.LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

```python
transformers.LinearTemperatureScheduleLogitsProcessor(t_min: float, t_max: float, max_denoising_steps: int)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L276)

**Parametreler:**

t_min (`float`) : Zamanlamadaki son sıcaklık, yani son gürültü azaltma adımındaki değer.

t_max (`float`) : Zamanlamadaki başlangıç sıcaklığı, yani ilk gürültü azaltma adımındaki değer.

max_denoising_steps (`int`) : Gürültü azaltma adımlarının maksimum sayısı.

Logitlere doğrusal bir sıcaklık zamanlaması uygulayan logits işleyicisi. Bu, `TemperatureLogitsWarper`'a benzer; ancak sıcaklık, mevcut adımın bir fonksiyonudur.

N adımın n'inci adımında, sıcaklık t, t = t_min + ((t_max - t_min) * (n/N)) formülüyle verilir.

## DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

#### transformers.DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

```python
transformers.DiffusionGemmaPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L817)

**Parametreler:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.DiffusionGemmaPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Noktalı bir yol için sahte bir değer (ör. `torch.float32`): öznitelik erişim zincirleri, çağrılar geçiş (pass-through) dekoratörleri gibi davranır, `repr` noktalı yoldur ve bir taban sınıf olarak kullanıldığında düz bir `type` tabanı yerleştirilir (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir metasınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

#### transformers.DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

```python
transformers.DiffusionGemmaModel(config: DiffusionGemmaConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1452)

**Parametreler:**

config ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üzerinde herhangi bir özel head bulunmayan, ham hidden-states üreten çıplak Diffusion Gemma Model.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.DiffusionGemmaModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1494)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Tuval için bağlam olarak kodlanacak istem için önbelleğe alınmamış token kimlikleri.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)` veya `dict`, *isteğe bağlı*) : Girdi jetonları için maske.

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, canvas_length)`, *isteğe bağlı*) : İncelenecek tuval için token kimlikleri.

self_conditioning_logits (`torch.Tensor`, şekli `(batch_size, canvas_length, vocab_size)`, *isteğe bağlı*) : Önceki gürültü azaltma adımından gelen, öz-konumlama gömmelemelerini hesaplamak için kullanılan öz-konumlama logitleri.

self_conditioning_mask (`torch.BoolTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : `self_conditioning_logits` üzerinde örnek başına maske: `False` olarak ayarlanan örnekler, kendilerine logit geçirilmemiş gibi sıfırlanmış bir öz-konumlama sinyali alır. Öz-konumlamanın bazı olasılıklarla örnek başına etkinleştirildiği eğitim için faydalıdır.

decoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length+canvas_length)` veya `dict`, *isteğe bağlı*) : Dekoder KV önbelleği için dikkat maskesi. Dolgulu/doldurulmamış kodlayıcı KV önbelleği girdilerini belirtmek için kullanılır.

decoder_position_ids (`torch.LongTensor`, şekli `(batch_size, canvas_length)`, *isteğe bağlı*) : Tuvaldeki jetonların konum kimlikleri.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *isteğe bağlı*) : Anahtarları desteklenen modaliteler, değerleri ise o modalite için kodlanmış çıktılar olan bir sözlük. Her kodlanmış çıktı, (`pooler_output`, *isteğe bağlı*: `last_hidden_states`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `pooler_output` `(batch_size, sequence_length, hidden_size)` boyutunda, *isteğe bağlı*) şeklindedir ve kodlayıcının çok modlu özelliklerinin metin gömme (embedding) değerleriyle birleştirilmiş bir dizisidir.

**Dönüş:** `DiffusionGemmaModelOutputWithPast` veya `tuple(torch.Tensor)`

Bir `DiffusionGemmaModelOutputWithPast` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırma ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DiffusionGemmaModel](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **encoder_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Yalnızca `input_ids` sağlandığında ayarlanır; örneğin eğitim sırasında kodlayıcı üzerinde otoregresif bir kayıp hesaplamak için.

## DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

#### transformers.DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

```python
transformers.DiffusionGemmaEncoderModel(config: DiffusionGemmaConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L995)

**Parametreler:**

config ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

DifüzyonGemma kodlayıcı modeli, bir görme omurgası ve bir dil modelinden oluşur; *dil modelleme kafası yoktur*. Gemma4Model ile çok benzerdir, ancak ses veya video girdilerini desteklemez ve iç katmanlarda her zaman MoE kod yolunu varsayar.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.DiffusionGemmaEncoderModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, image_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1060)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri `image_processor_class` kullanılarak elde edilebilir. Ayrıntılar için `image_processor_class.__call__` bölümüne bakın ([Gemma4Processor](/docs/transformers/v5.23.0/tr/model_doc/gemma4#transformers.Gemma4Processor), görüntü işleme için `image_processor_class` kullanır).

attention_mask (`Union[torch.Tensor, dict]` biçimi `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

mm_token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Her modalliteyle eşleşen girdi dizisi belirteçlerinin (token) indeksleri. Örneğin metin (0), görüntü (1), video (2). Çok modallı belirteç türü kimlikleri [AutoProcessor](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoProcessor) kullanılarak elde edilebilir. Ayrıntılar için [ProcessorMixin.__call__()](/docs/transformers/v5.23.0/tr/main_classes/processors#transformers.ProcessorMixin.__call__) bölümüne bakın.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

image_position_ids (`torch.LongTensor`, şekli `(batch_size, max_patches, 2)`, *isteğe bağlı*) : Görsel işleyiciden gelen 2B yama konum koordinatları; `(-1, -1)` dolguyu (padding) belirtir. Konumsal gömme (positional embedding) hesabı için görsel kodlayıcıya (vision encoder) iletilir.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *isteğe bağlı*) : Anahtarları desteklenen modaliteler, değerleri ise o modalite için kodlanmış çıktılar olan bir sözlük. Her kodlanmış çıktı, (`pooler_output`, *isteğe bağlı*: `last_hidden_states`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `pooler_output` `(batch_size, sequence_length, hidden_size)` boyutunda, *isteğe bağlı*) şeklindedir ve kodlayıcının çok modlu özelliklerinin metin gömme (embedding) değerleriyle birleştirilmiş bir dizisidir.

**Dönüş:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DiffusionGemmaEncoderModel](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

#### transformers.DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

```python
transformers.DiffusionGemmaEncoderTextModel(config: DiffusionGemmaTextConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L881)

#### forward[[transformers.DiffusionGemmaEncoderTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L909)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`Union[torch.Tensor, dict]` biçimi `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

**Dönüş:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya `tuple(torch.Tensor)`

[BaseModelOutputWithPast](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DiffusionGemmaEncoderTextModel](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderTextModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

#### transformers.DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

```python
transformers.DiffusionGemmaDecoderModel(config: DiffusionGemmaConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1175)

DiffusionGemma için decoder modeli.

Tuval jetonlarını, çift yönlü öz-dikkat ve kodlayıcının KV önbelleğine çapraz dikkat ile işler. Çözücü, KV önbelleğini okur ancak güncellemez. Bu farklılıklar hariç tutulduğunda, `DiffusionGemmaEncoderTextModel` ile benzerdir ve ortak olan tüm ağırlıkları paylaşır.

#### forward[[transformers.DiffusionGemmaDecoderModel.forward]]

```python
forward(decoder_input_ids: LongTensor, past_key_values: transformers.cache_utils.Cache | None = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1217)

**Parametreler:**

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, canvas_length)`) : İncelenecek tuval için token kimlikleri.

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

self_conditioning_logits (`torch.Tensor`, şekli `(batch_size, canvas_length, vocab_size)`, *isteğe bağlı*) : Önceki gürültü azaltma adımından gelen, öz-konumlama gömmelemelerini hesaplamak için kullanılan öz-konumlama logitleri.

self_conditioning_mask (`torch.BoolTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : `self_conditioning_logits` üzerinde örnek başına maske: `False` olarak ayarlanan örnekler, kendilerine logit geçirilmemiş gibi sıfırlanmış bir öz-konumlama sinyali alır. Öz-konumlamanın bazı olasılıklarla örnek başına etkinleştirildiği eğitim için faydalıdır.

decoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length+canvas_length)` veya `dict`, *isteğe bağlı*) : Dekoder KV önbelleği için dikkat maskesi. Dolgulu/doldurulmamış kodlayıcı KV önbelleği girdilerini belirtmek için kullanılır.

decoder_position_ids (`torch.LongTensor`, şekli `(batch_size, canvas_length)`, *isteğe bağlı*) : Tuvaldeki jetonların konum kimlikleri.

**Dönüş:** [BaseModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DiffusionGemmaDecoderModel](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaDecoderModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

#### transformers.DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

```python
transformers.DiffusionGemmaForBlockDiffusion(config: DiffusionGemmaConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1579)

Blok difüzyonu için DiffusionGemma modeli. Girdi tuvalinin gizli durumlarını, bir istem KV önbelleğiyle koşullandırılmış olarak almak için `DiffusionGemmaModel` çağrısı yapar. LM Head ve öz-kondisyonlama bloklarını kullanarak bu gizli durumları, bir sonraki tuvali örneklemek için logitlere ve bir sonraki blok difüzyon adımı için öz-kondisyonlama gömme değerlerine dönüştürür.

#### forward[[transformers.DiffusionGemmaForBlockDiffusion.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1601)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Tuval için bağlam olarak kodlanacak istem için önbelleğe alınmamış token kimlikleri.

attention_mask (`torch.LongTensor`, şekli `(batch_size, sequence_length)` veya `dict`, *isteğe bağlı*) : Girdi jetonları için maske.

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, canvas_length)`, *isteğe bağlı*) : İncelenecek tuval için token kimlikleri.

self_conditioning_logits (`torch.Tensor`, şekli `(batch_size, canvas_length, vocab_size)`, *isteğe bağlı*) : Önceki gürültü azaltma adımından gelen, öz-konumlama gömmelemelerini hesaplamak için kullanılan öz-konumlama logitleri.

self_conditioning_mask (`torch.BoolTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : `self_conditioning_logits` üzerinde örnek başına maske: `False` olarak ayarlanan örnekler, kendilerine logit geçirilmemiş gibi sıfırlanmış bir öz-konumlama sinyali alır. Öz-konumlamanın bazı olasılıklarla örnek başına etkinleştirildiği eğitim için faydalıdır.

decoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length+canvas_length)` veya `dict`, *isteğe bağlı*) : Dekoder KV önbelleği için dikkat maskesi. Dolgulu/doldurulmamış kodlayıcı KV önbelleği girdilerini belirtmek için kullanılır.

decoder_position_ids (`torch.LongTensor`, şekli `(batch_size, canvas_length)`, *isteğe bağlı*) : Tuvaldeki jetonların konum kimlikleri.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *isteğe bağlı*) : Anahtarları desteklenen modaliteler, değerleri ise o modalite için kodlanmış çıktılar olan bir sözlük. Her kodlanmış çıktı, (`pooler_output`, *isteğe bağlı*: `last_hidden_states`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) `pooler_output` `(batch_size, sequence_length, hidden_size)` boyutunda, *isteğe bağlı*) şeklindedir ve kodlayıcının çok modlu özelliklerinin metin gömme (embedding) değerleriyle birleştirilmiş bir dizisidir.

**Dönüş:** `DiffusionGemmaBlockDiffusionOutputWithPast` veya `tuple(torch.Tensor)`

A `DiffusionGemmaBlockDiffusionOutputWithPast` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DiffusionGemmaForBlockDiffusion](/docs/transformers/v5.23.0/tr/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*) -- Dil modelleme kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, canvas_length, config.text_config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/v5.23.0/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki anahtar ve değerler) içerir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **encoder_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Yalnızca `input_ids` sağlandığında ayarlanır; örneğin eğitim sırasında kodlayıcı üzerinde otoregresif bir kayıp hesaplamak için.

Örnek:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained("google/diffusiongemma-26B-A4B-it")
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

