# LED

[Longformer-Encoder-Decoder (LED)](https://huggingface.co/papers/2004.05150), özetleme gibi diziden-diziye (sequence-to-sequence) görevler için tasarlanmış bir kodlayıcı-çözücü (encoder-decoder) transformer modelidir. [Longformer](longformer)'ın, uzun girdileri işlemek için tasarlanmış yalnızca kodlayıcı (encoder-only) bir model olmasının üzerine, bir çözücü (decoder) katmanı ekleyerek genişletir. Çözücü, kodlanmış jetonlar ve daha önce çözülen konumlar üzerinde tam öz-dikkat (full self-attention) kullanır. Longformer'ın doğrusal öz-dikkat mekanizması sayesinde LED, uzun dizileri işlerken standart kodlayıcı-çözücü modellerine kıyasla daha verimlidir.

Tüm orijinal [LED] kontrol noktalarını [Ai2](https://huggingface.co/allenai/models?search=led) kuruluşu altında bulabilirsiniz.

> [!TIP]
> Bu model [patrickvonplaten](https://huggingface.co/patrickvonplaten) tarafından katkıda bulunmuştur.
>
> Farklı dil görevlerine LED'i uygulama konusunda daha fazla örnek için sağ kenar çubuğundaki LED modellerine tıklayın.

Aşağıdaki örnek, metni [Pipeline](/docs/transformers/v5.23.0/tr/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModel) ve komut satırından özetlemenin nasıl yapılacağını göstermektedir.

```python
import torch

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "allenai/led-base-16384"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
    "allenai/led-base-16384",
    device_map="auto"
)

input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)

# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1

output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

Quantization, ağırlıkları daha düşük bir hassasiyetle temsil ederek büyük modellerin bellek yükünü azaltır. Daha fazla kullanılabilir quantization backend'i için [Quantization](../quantization/overview) genel bakışına başvurun.

Aşağıdaki örnek, ağırlıkları yalnızca int4 olarak nicelleştirmek için [bitsandbytes](../quantization/bitsandbytes) kullanır.

```python
import torch

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
    "allenai/led-large-16384",
    device_map="auto",
    quantization_config=quantization_config
)

tokenizer = AutoTokenizer.from_pretrained(
    "allenai/led-large-16384"
)

input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)

# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1

output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

## Notlar

- [LEDForConditionalGeneration](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDForConditionalGeneration), geleneksel öz-dikkat katmanını Longformer'ın parçalı öz-dikkat katmanı ile değiştiren [BartForConditionalGeneration](/docs/transformers/v5.23.0/tr/model_doc/bart#transformers.BartForConditionalGeneration)'ın bir uzantısıdır. [LEDTokenizer](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.RobertaTokenizer), [BartTokenizer](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.RobertaTokenizer)'ın bir takma adıdır.
- LED, gerekirse `input_ids` değerlerini `config.attention_window` değerinin katına `pad_to_multiple_of` argümanı ile doldurur. [LEDTokenizer](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.RobertaTokenizer) kullanıldığında küçük bir hızlanma elde edilir.
- LED, `input_ids` 1024 token'dan belirgin şekilde daha uzun olan uzun menzilli diziden-diziye görevlerde en iyi performansı gösterir.
- LED, [LongformerModel](/docs/transformers/v5.23.0/tr/model_doc/longformer#transformers.LongformerModel)'de olduğu gibi `global_attention_mask` aracılığıyla küresel dikkat kullanır. Özetleme için küresel dikkatin yalnızca ilk `<s>` belirteçine uygulanması önerilir. Soru yanıtlama için ise küresel dikkatin sorudaki tüm belirteçlere uygulanması önerilir.
- LED'i tüm 16384 parametre üzerinde ince ayar yapmak için, eğitim bellek dışı (OOM) hatalarına yol açarsa gradient checkpointing etkinleştirilebilir. Bellek tasarrufu sağlamak için önbellekleme mekanizmasını devre dışı bırakmak üzere `model.gradient_checkpointing_enable()` ekleyerek ve `use_cache=False` ayarlayarak gradient checkpointing'i etkinleştirin.
- LED mutlak konum gömme kullanıldığından, girdiler sağ taraftan dolgu (padding) ile tamamlanmalıdır.

## Kaynaklar

- LED'nin Arxiv makale özetlemede son teknoloji performansını nasıl elde edebildiğini görmek için [Arxiv'de LED defterini](https://colab.research.google.com/drive/12INTTR6n64TzS4RrXZxMSXfrOd9Xzamo?usp=sharing) okuyun.
- LED'yi PubMed makalelerinde ince ayar yapmak için [Fine-tune LED notebook](https://colab.research.google.com/drive/12LjJazBl7Gam0XBPy_y0CTOJZeZ34c2v?usp=sharing) defterini okuyun.

## LEDConfig[[transformers.LEDConfig]]

#### transformers.LEDConfig[[transformers.LEDConfig]]

```python
transformers.LEDConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 50265, max_encoder_position_embeddings: int = 16384, max_decoder_position_embeddings: int = 1024, encoder_layers: int = 12, encoder_ffn_dim: int = 4096, encoder_attention_heads: int = 16, decoder_layers: int = 12, decoder_ffn_dim: int = 4096, decoder_attention_heads: int = 16, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 1024, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, decoder_start_token_id: int = 2, classifier_dropout: float | int = 0.0, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, attention_window: list[int] | int = 512, tie_word_embeddings: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/configuration_led.py#L24)

**Parametreler:**

is_encoder_decoder (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin bir kodlayıcı/çözücü olarak kullanılıp kullanılmadığı.

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

max_encoder_position_embeddings (`int`, *opsiyonel*, varsayılan 16384) : Kodlayıcının (encoder) kullanılabileceği maksimum dizi uzunluğu.

max_decoder_position_embeddings (`int`, *opsiyonel*, varsayılan 16384) : Dekoderin kullanılabileceği maksimum dizi uzunluğu.

encoder_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer kodlayıcısındaki gizli katman sayısı. Ayarlanmazsa `num_layers` ile aynı değeri kullanır.

encoder_ffn_dim (`int`, *opsiyonel*, varsayılan `4096`) : Kodlayıcıdaki "ara" (genellikle feed-forward olarak adlandırılan) katmanın boyutluluğu.

encoder_attention_heads (`int`, *isteğe bağlı*, varsayılan `16`) : Transformer kodlayıcısındaki her dikkat katmanı için dikkat başı sayısı.

decoder_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki gizli katman sayısı. Ayarlanmazsa `num_layers` ile aynı değer kullanılır.

decoder_ffn_dim (`int`, *opsiyonel*, varsayılan `4096`) : Dekoderdeki "ara" (genellikle feed-forward olarak adlandırılan) katmanın boyutluluğu.

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

encoder_layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Kodlayıcı için LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın.

decoder_layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Çözücü için LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın.

use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin son anahtar/değer dikkatlerini döndürüp döndürmeyeceğini belirtir (tüm modellerde kullanılmaz). Yalnızca `config.is_decoder=True` olduğunda veya model yalnızca çözücü tabanlı üretken bir model olduğunda geçerlidir.

activation_function (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

d_model (`int`, *isteğe bağlı*, varsayılan `1024`) : Kodlayıcı katmanlarının ve havuzlayıcı katmanının boyutu.

dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran.

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

activation_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Tamamen bağlı katmandaki aktivasyonlar için dropout oranı.

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

decoder_start_token_id (`int`, *opsiyonel*, varsayılan `2`) : Bir kodlayıcı-çözücü modeli, `bos` ile farklı bir token ile çözümlemeye başlıyorsa, o token'ın kimliği.

classifier_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Sınıflandırıcı için dropout oranı.

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

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

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

attention_window (`int` veya `list[int]`, *isteğe bağlı*, varsayılan 512) : Her token etrafındaki dikkat penceresinin boyutu. `int` ise, tüm katmanlar için aynı boyutu kullanın. Her katman için farklı bir pencere boyutu belirtmek için, `len(attention_window) == num_hidden_layers` olacak şekilde bir `list[int]` kullanın.

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.

Bu, bir LEDModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Led modelinin örneklenmesi ve model mimarisinin tanımlanması için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [allenai/led-base-16384](https://huggingface.co/allenai/led-base-16384) ile benzer bir yapılandırmaya yol açar.

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 LEDModel, LEDConfig

>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()

>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)

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

## LEDTokenizer[[transformers.RobertaTokenizer]]

#### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]]

```python
transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', bos_token: str = '<s>', eos_token: str = '</s>', sep_token: str = '</s>', cls_token: str = '<s>', unk_token: str = '<unk>', pad_token: str = '<pad>', mask_token: str = '<mask>', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/roberta/tokenization_roberta.py#L28)

**Parametreler:**

vocab (`str`, `dict` veya `list`, *isteğe bağlı*) : Özel sözlük. Sağlanmazsa, sözlük vocab_file'den yüklenir.

merges (`str` veya `list`, *isteğe bağlı*) : Özel birleştirmeler listesi. Sağlanmazsa, birleştirmeler merges_file'den yüklenir.

errors (`str`, *isteğe bağlı*, varsayılan `"replace"`) : Baytların UTF-8'e çözümlenirken izlenecek paradigma. Daha fazla bilgi için [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)'e bakın.

bos_token (`str`, *isteğe bağlı*, varsayılan `"<s>"`) : Ön eğitim sırasında kullanılan dizinin başlangıç jetonu. Bir dizi sınıflandırıcı jetonu olarak kullanılabilir. Özel jetonlar kullanılarak bir dizi oluşturulduğunda, dizinin başlangıcı için kullanılan jeton bu değildir. Kullanılan jeton `cls_token`'dur.

eos_token (`str`, *isteğe bağlı*, varsayılan `"</s>"`) : Sıra sonu belirteci. Özel belirteçler kullanılarak bir sıra oluşturulduğunda, sıra sonu için kullanılan belirteç bu değildir. Kullanılan belirteç `sep_token`'tur.

sep_token (`str`, *isteğe bağlı*, varsayılan `"</s>"`) : Birden fazla diziden bir dizi oluşturulurken kullanılan ayraç belirteci, örneğin dizi sınıflandırması için iki dizi veya soru cevaplamada bir metin ve bir soru için. Özel belirteçlerle oluşturulan bir dizinin son belirteci olarak da kullanılır.

cls_token (`str`, *isteğe bağlı*, varsayılan `"<s>"`) : Sıralı sınıflandırma (token başına sınıflandırma yerine tüm sıranın sınıflandırılması) yapılırken kullanılan sınıflandırıcı jetonu. Özel jetonlarla oluşturulduğunda sıranın ilk jetonudur.

unk_token (`str`, *isteğe bağlı*, varsayılan `"<unk>"`) : Bilinmeyen token. Sözlükte yer almayan bir token, bir kimliğe dönüştürülemez ve bunun yerine bu token olarak ayarlanır.

pad_token (`str`, *isteğe bağlı*, varsayılan `"<pad>"`) : Dolgu için kullanılan jeton, örneğin farklı uzunluklardaki dizileri toplu işleme (batching) sırasında.

mask_token (`str`, *isteğe bağlı*, varsayılan `"<mask>"`) : Değerleri maskelemek için kullanılan belirteç. Bu, modelin maskeli dil modelleme ile eğitildiğinde kullanılan belirteçtir. Modelin tahmin etmeye çalışacağı belirteç budur.

add_prefix_space (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdinin başına bir boşluk eklenip eklenmeyeceğini belirtir. Bu, baştaki kelimenin diğer kelimelerle aynı şekilde ele alınmasını sağlar. (RoBERTa tokenizer, kelimelerin başlangıcını önceki boşlukla tespit eder).

trim_offsets (`bool`, *isteğe bağlı*, varsayılan `True`) : Son işleme adımının, boşlukları dahil etmemek için ofsetleri kırpıp kırmayacağını belirtir.

Bir RoBERTa tokenizer'ı oluşturun (HuggingFace'in tokenizers kütüphanesi tarafından desteklenir). Byte-Pair-Encoding tabanlıdır.

Bu tokenizer, boşlukları tokenların parçaları gibi işlemek üzere eğitilmiştir (biraz da sentencepiece gibi) bu yüzden bir kelime

cümle başında (boşluksuz) mı yoksa değil mi olduğuna göre farklı kodlanabilir:

```python
>>> from transformers import RobertaTokenizer

>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]
```

Bu davranışın etrafından dolaşmak için bu tokenizer'ı örneklerken veya bazı metinler üzerinde çağırdığınızda `add_prefix_space=True` parametresini iletebilirsiniz; ancak model bu şekilde ön eğitilmediğinden, performans düşüşüne yol açabilir.

`is_split_into_words=True` ile kullanıldığında, bu tokenizer'ın `add_prefix_space=True` ile örneklenmesi gerekir.

Bu tokenizer, ana yöntemlerin çoğunu içeren [TokenizersBackend](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

#### get_special_tokens_mask[[transformers.RobertaTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1337)

**Parametreler:**

token_ids_0 : (muhtemelen biçimlendirilmiş) dizinin kimlik listesi.

token_ids_1 `already_has_special_tokens=True` olduğunda kullanılmaz. Bu durumda None olmalıdır.

already_has_special_tokens : Dizi, özel jetonlarla zaten biçimlendirilmiş mi?

**Dönüş:** [0, 1] aralığında tamsayılar listesi

özel bir jeton için 1, bir dizi jetonu için 0.

Özel tokenlar eklenmemiş bir token listesinden dizi kimliklerini (sequence ids) alın.

Hızlı tokenizörler için veri toplayıcılar, biçimlendirilmiş bir dizinin üzerine bir maske oluşturmak üzere bunu `already_has_special_tokens=True` ile çağırır. Bu durumda, maskenin hesaplanması `all_special_ids` içinde üyelik kontrolü yapılarak gerçekleştirilir.

#### save_vocabulary[[transformers.RobertaTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## LED'e özgü çıktılar[[transformers.models.led.modeling_led.LEDEncoderBaseModelOutput]]

#### transformers.models.led.modeling_led.LEDEncoderBaseModelOutput[[transformers.models.led.modeling_led.LEDEncoderBaseModelOutput]]

```python
transformers.models.led.modeling_led.LEDEncoderBaseModelOutput(last_hidden_state: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1063)

**Parametreler:**

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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Modelin her katmanının çıktısındaki 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, x + attention_window + 1)`, burada `x` küresel dikkat maskesine sahip token sayısıdır. Dikkat softmax'inden sonraki yerel dikkat ağırlıkları, öz-dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Bunlar, dizideki her token'dan küresel dikkate sahip her token'a (ilk `x` değer) ve dikkat penceresindeki her token'a (kalan `attention_window + 1` değer) olan dikkat ağırlıklarıdır. Dikkat edin, ilk `x` değer metindeki sabit konumlara sahip tokenlara işaret eder, ancak kalan `attention_window + 1` değer göreli konumlara sahip tokenlara işaret eder: bir token'ın kendisine olan dikkat ağırlığı `x + attention_window / 2` indeksinde bulunur ve `attention_window / 2` önceki (sonraki) değerler, `attention_window / 2` önceki (sonraki) tokenlara olan dikkat ağırlıklarıdır. Dikkat penceresi küresel dikkate sahip bir token içeriyorsa, ilgili indeksteki dikkat ağırlığı 0 olarak ayarlanır; değer, ilk `x` dikkat ağırlığından erişilmelidir. Bir token küresel dikkate sahipse, `attentions` içindeki diğer tüm tokenlara olan dikkat ağırlıkları 0 olarak ayarlanır, değerler `global_attentions` içinden erişilmelidir.

global_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, x)`, burada `x` global dikkat maskesine sahip token sayısıdır. Dikkat softmax'inden sonraki global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalama hesaplamak için kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

LEDEncoder çıktılarının taban sınıfı; potansiyel gizli durumlar, yerel ve global dikkat içerir.

#### transformers.models.led.modeling_led.LEDSeq2SeqModelOutput[[transformers.models.led.modeling_led.LEDSeq2SeqModelOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1102)

**Parametreler:**

last_hidden_state (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) : Modelin decoder'ının son katmanının çıktısındaki gizli durumlar dizisi. `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` şeklindeki dizilerin son gizli durumu çı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. Ardışık çözümlemeyi hızlandırmak için kullanılabilecek (bkz. `past_key_values` girdisi) decoder'ın önceden hesaplanmış gizli durumlarını (dikkat bloklarındaki anahtar ve değerleri) içerir.

decoder_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` (modelin bir 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 bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Çıktıdaki her katmanın ve başlangıç gömme çıktılarının gizli durumları.

decoder_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'inden sonraki, self-attention başlıklarında ağırlıklı ortalama hesaplamak için kullanılan decoder'ın dikkat ağırlıkları.

cross_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'inden sonra, çapraz dikkat başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, decoder'ın çapraz dikkat katmanının dikkat ağırlıkları.

encoder_last_hidden_state (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.

encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.

encoder_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)`. Kendi dikkat (self-attention) başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, dikkat softmax'inden sonraki kodlayıcı (encoder) dikkat ağırlıkları.

encoder_global_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, x)`, burada `x` global dikkat maskesine sahip token sayısıdır. Dikkat softmax'inden sonraki global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalama hesaplamak için kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

Ayrıca, ardışık çözümlemeyi hızlandırabilecek önceden hesaplanmış gizli durumları da içeren model kodlayıcısının çıktılarının temel sınıfı.

#### transformers.models.led.modeling_led.LEDSeq2SeqLMOutput[[transformers.models.led.modeling_led.LEDSeq2SeqLMOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1140)

**Parametreler:**

loss (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) : Dil modelleme kaybı.

logits (`torch.Tensor`, şekli `(batch_size, sequence_length, 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. Ardışık çözümlemeyi hızlandırmak için kullanılabilecek (bkz. `past_key_values` girdisi) decoder'ın önceden hesaplanmış gizli durumlarını (dikkat bloklarındaki anahtar ve değerleri) içerir.

decoder_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` (modelin bir 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 bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Çıktıdaki her katmanın ve başlangıç gömme çıktılarının gizli durumları.

decoder_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'inden sonraki, self-attention başlıklarında ağırlıklı ortalama hesaplamak için kullanılan decoder'ın dikkat ağırlıkları.

cross_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'inden sonra, çapraz dikkat başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, decoder'ın çapraz dikkat katmanının dikkat ağırlıkları.

encoder_last_hidden_state (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.

encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.

encoder_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)`. Kendi dikkat (self-attention) başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, dikkat softmax'inden sonraki kodlayıcı (encoder) dikkat ağırlıkları.

encoder_global_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, x)`, burada `x` global dikkat maskesine sahip token sayısıdır. Dikkat softmax'inden sonraki global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalama hesaplamak için kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

Sıralıdan sıralıya dil modelleri çıktıları için temel sınıf.

#### transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput[[transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1178)

**Parametreler:**

loss (`torch.Tensor` şekli `(1,)`, *isteğe bağlı*, `label` sağlandığında döndürülür) : Sınıflandırma (veya config.num_labels==1 ise regresyon) kaybı.

logits (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) : Sınıflandırma (veya config.num_labels==1 ise regresyon) puanları (SoftMax öncesi).

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. Ardışık çözümlemeyi hızlandırmak için kullanılabilecek (bkz. `past_key_values` girdisi) decoder'ın önceden hesaplanmış gizli durumlarını (dikkat bloklarındaki anahtar ve değerleri) içerir.

decoder_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` (modelin bir 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 bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Çıktıdaki her katmanın ve başlangıç gömme çıktılarının gizli durumları.

decoder_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'inden sonraki, self-attention başlıklarında ağırlıklı ortalama hesaplamak için kullanılan decoder'ın dikkat ağırlıkları.

cross_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'inden sonra, çapraz dikkat başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, decoder'ın çapraz dikkat katmanının dikkat ağırlıkları.

encoder_last_hidden_state (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.

encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.

encoder_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)`. Kendi dikkat (self-attention) başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, dikkat softmax'inden sonraki kodlayıcı (encoder) dikkat ağırlıkları.

encoder_global_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, x)`, burada `x` global dikkat maskesine sahip token sayısıdır. Dikkat softmax'inden sonraki global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalama hesaplamak için kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

Sıralıdan sıralıya cümle sınıflandırma modellerinin çıktıları için temel sınıf.

#### transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput[[transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput]]

```python
transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1216)

**Parametreler:**

loss (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) : Toplam span çıkarım kaybı, başlangıç ve bitiş konumları için Çapraz Entropinin (Cross-Entropy) toplamıdır.

start_logits (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Span başlangıç puanları (SoftMax'ten önce).

end_logits (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Span sonu puanları (SoftMax öncesi).

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. Ardışık çözümlemeyi hızlandırmak için kullanılabilecek (bkz. `past_key_values` girdisi) decoder'ın önceden hesaplanmış gizli durumlarını (dikkat bloklarındaki anahtar ve değerleri) içerir.

decoder_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` (modelin bir 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 bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Çıktıdaki her katmanın ve başlangıç gömme çıktılarının gizli durumları.

decoder_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'inden sonraki, self-attention başlıklarında ağırlıklı ortalama hesaplamak için kullanılan decoder'ın dikkat ağırlıkları.

cross_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'inden sonra, çapraz dikkat başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, decoder'ın çapraz dikkat katmanının dikkat ağırlıkları.

encoder_last_hidden_state (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.

encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.

encoder_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)`. Kendi dikkat (self-attention) başlıklarında ağırlıklı ortalama hesaplamak için kullanılan, dikkat softmax'inden sonraki kodlayıcı (encoder) dikkat ağırlıkları.

encoder_global_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, x)`, burada `x` global dikkat maskesine sahip token sayısıdır. Dikkat softmax'inden sonraki global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalama hesaplamak için kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

Sıralıdan sıralıya soru-cevap modellerinin çıktıları için temel sınıf.

## LEDModel[[transformers.LEDModel]]

#### transformers.LEDModel[[transformers.LEDModel]]

```python
transformers.LEDModel(config: LEDConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1723)

**Parametreler:**

config ([LEDConfig](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDConfig)) : 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 olmadan ham hidden-states çıkaran çıplak Led 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.LEDModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1749)

**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 (`torch.Tensor`, şekli `(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)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Sözlükte decoder giriş dizisi tokenlarının indeksleri. İndeksler `LedTokenizer` 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. [Giriş ID'leri nelerdir?](../glossary#input-ids) LED, `decoder_input_ids` üretimi için başlangıç tokenı olarak `eos_token_id` kullanır. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_input_ids` girdi olarak verilmelidir (bkz. `past_key_values`).

decoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Varsayılan davranış: `decoder_input_ids` içindeki dolgu (pad) jetonlarını yok sayan bir tensör oluşturur. Varsayılan olarak nedensel maske (causal mask) de kullanılır. Dolgu davranışını değiştirmek istiyorsanız, `modeling_led._prepare_decoder_inputs` dosyasını okuyup ihtiyaçlarınıza göre düzenlemelisiniz. Varsayılan strateji hakkında daha fazla bilgi için [makaledeki](https://huggingface.co/papers/1910.13461) 1 numaralı diyagrama bakın.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) içeren bir Tuple. `last_hidden_state`, `(batch_size, sequence_length, hidden_size)` biçiminde, *isteğe bağlı*) kodlayıcının (encoder) son katmanının çıktısındaki gizli durumlar (hidden-states) dizisidir. Çözücüde (decoder) çapraz dikkat (cross-attention) için kullanılır.

global_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı için her token'a verilen dikkati belirlemek için kullanılan maske; yerel dikkat veya global dikkat. Global dikkate sahip tokenlar diğer tüm tokenlara dikkat eder ve diğer tüm tokenlar da onlara dikkat eder. Bu, modeli görevi temsil etmede daha esnek hale getirdiği için görev bazlı ince ayar için önemlidir. Örneğin, sınıflandırma için  token'a global dikkat verilmelidir. Soru-cevap için, tüm soru tokenları da global dikkate sahip olmalıdır. Daha fazla ayrıntı için [Longformer makalesine](https://huggingface.co/papers/2004.05150) bakınız. `[0, 1]` aralığında seçilen maske değerleri:  - Yerel dikkat (kayan pencere dikkati) için 0, - Global dikkat (diğer tüm tokenlara dikkat eden ve diğer tüm tokenların da onlara dikkat ettiği tokenlar) için 1.

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.

decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi seçebilirsiniz. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_inputs_embeds` değerlerinin girdi olarak verilmesi yeterlidir (bkz. `past_key_values`). Bu, `decoder_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. `decoder_input_ids` ve `decoder_inputs_embeds` parametrelerinin ikisi de ayarlanmamışsa, `decoder_inputs_embeds` parametresi `inputs_embeds` değerini alır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

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

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

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** [LEDSeq2SeqModelOutput](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqModelOutput) veya `tuple(torch.Tensor)`

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

[LEDModel](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDModel) 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 decoder'ının 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.

  Dizisel çözümlendirmeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, çözücüdeki önceden hesaplanmış gizli durumları (dikkat bloklarındaki anahtar ve değerler) içerir.
- **decoder_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` (modelin bir 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 bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında dekodlayıcının gizli durumları.
- **decoder_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) -- Her katman için bir adet içeren `torch.Tensor` (şekil: `(batch_size, num_heads, sequence_length, sequence_length)`) bir demeti.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları.
- **cross_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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıkları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ı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.
- **encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.
- **encoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları.
- **encoder_global_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, x)` şeklindedir; burada `x`, global dikkat maskesine sahip jeton sayısıdır.

  Dikkat softmax'ı sonrası global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

## LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]]

#### transformers.LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]]

```python
transformers.LEDForConditionalGeneration(config: LEDConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1865)

**Parametreler:**

config ([LEDConfig](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDConfig)) : 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.

Dil modelleme başlığına sahip LED Modeli. Özetleme için kullanılabilir.

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.LEDForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L1897)

**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 (`torch.Tensor`, şekli `(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)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Sözlükte decoder giriş dizisi tokenlarının indeksleri. İndeksler `LedTokenizer` 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. [Giriş ID'leri nelerdir?](../glossary#input-ids) LED, `decoder_input_ids` üretimi için başlangıç tokenı olarak `eos_token_id` kullanır. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_input_ids` girdi olarak verilmelidir (bkz. `past_key_values`).

decoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Varsayılan davranış: `decoder_input_ids` içindeki dolgu (pad) jetonlarını yok sayan bir tensör oluşturur. Varsayılan olarak nedensel maske (causal mask) de kullanılır. Dolgu davranışını değiştirmek istiyorsanız, `modeling_led._prepare_decoder_inputs` dosyasını okuyup ihtiyaçlarınıza göre düzenlemelisiniz. Varsayılan strateji hakkında daha fazla bilgi için [makaledeki](https://huggingface.co/papers/1910.13461) 1 numaralı diyagrama bakın.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) içeren bir Tuple. `last_hidden_state`, `(batch_size, sequence_length, hidden_size)` biçiminde, *isteğe bağlı*) kodlayıcının (encoder) son katmanının çıktısındaki gizli durumlar (hidden-states) dizisidir. Çözücüde (decoder) çapraz dikkat (cross-attention) için kullanılır.

global_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı için her token'a verilen dikkati belirlemek için kullanılan maske; yerel dikkat veya global dikkat. Global dikkate sahip tokenlar diğer tüm tokenlara dikkat eder ve diğer tüm tokenlar da onlara dikkat eder. Bu, modeli görevi temsil etmede daha esnek hale getirdiği için görev bazlı ince ayar için önemlidir. Örneğin, sınıflandırma için  token'a global dikkat verilmelidir. Soru-cevap için, tüm soru tokenları da global dikkate sahip olmalıdır. Daha fazla ayrıntı için [Longformer makalesine](https://huggingface.co/papers/2004.05150) bakınız. `[0, 1]` aralığında seçilen maske değerleri:  - Yerel dikkat (kayan pencere dikkati) için 0, - Global dikkat (diğer tüm tokenlara dikkat eden ve diğer tüm tokenların da onlara dikkat ettiği tokenlar) için 1.

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.

decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi seçebilirsiniz. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_inputs_embeds` değerlerinin girdi olarak verilmesi yeterlidir (bkz. `past_key_values`). Bu, `decoder_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. `decoder_input_ids` ve `decoder_inputs_embeds` parametrelerinin ikisi de ayarlanmamışsa, `decoder_inputs_embeds` parametresi `inputs_embeds` değerini alır.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.vocab_size]` aralığında olmalı ya da -100 olmalı (`input_ids` docstring'ine bakın). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca `[0, ..., config.vocab_size]` aralığında etiketlere sahip tokenlar için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

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

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

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** [LEDSeq2SeqLMOutput](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqLMOutput) veya `tuple(torch.Tensor)`

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

[LEDForConditionalGeneration](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDForConditionalGeneration) 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ı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, 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.

  Dizisel çözümlendirmeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, çözücüdeki önceden hesaplanmış gizli durumları (dikkat bloklarındaki anahtar ve değerler) içerir.
- **decoder_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` (modelin bir 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 bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında dekodlayıcının gizli durumları.
- **decoder_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) -- Her katman için bir adet içeren `torch.Tensor` (şekil: `(batch_size, num_heads, sequence_length, sequence_length)`) bir demeti.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları.
- **cross_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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıkları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ı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.
- **encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.
- **encoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları.
- **encoder_global_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, x)` şeklindedir; burada `x`, global dikkat maskesine sahip jeton sayısıdır.

  Dikkat softmax'ı sonrası global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

Örnek Özetleme:

```python
>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")

>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
...     results in a wide range of natural language tasks including generative language modeling
...     (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
...     This success is partly due to the self-attention component which enables the network to capture contextual
...     information from the entire sequence. While powerful, the memory and computational requirements of
...     self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
...     process long sequences. To address this limitation, we present Longformer, a modified Transformer
...     architecture with a self-attention operation that scales linearly with the sequence length, making it
...     versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
...     long document classification, question answering (QA), and coreference resolution, where existing approaches
...     partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
...     of BERT-style pretrained models. Such partitioning could potentially result in loss of important
...     cross-partition information, and to mitigate this problem, existing methods often rely on complex
...     architectures to address such interactions. On the other hand, our proposed Longformer is able to build
...     contextual representations of the entire context using multiple layers of attention, reducing the need for
...     task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")

>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1

>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))
```

Örnek Koşullu üretim :

```python
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."

>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]

>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))
```

## LEDForQuestionAnswering[[transformers.LEDForQuestionAnswering]]

#### transformers.LEDForQuestionAnswering[[transformers.LEDForQuestionAnswering]]

```python
transformers.LEDForQuestionAnswering(config: LEDConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L2051)

**Parametreler:**

config ([LEDConfig](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDConfig)) : 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.

SQuAD gibi çıkarımsal soru-cevap görevleri için üstünde bir aralık sınıflandırma kafası bulunan Led dönüştürücüsü (gizli durum çıktısının üstünde, `span start logits` ve `span end logits` hesaplamak için bir doğrusal katman).

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.LEDForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/led/modeling_led.py#L2064)

**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 (`torch.Tensor`, şekli `(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)

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Sözlükte decoder giriş dizisi tokenlarının indeksleri. İndeksler `LedTokenizer` 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. [Giriş ID'leri nelerdir?](../glossary#input-ids) LED, `decoder_input_ids` üretimi için başlangıç tokenı olarak `eos_token_id` kullanır. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_input_ids` girdi olarak verilmelidir (bkz. `past_key_values`).

decoder_attention_mask (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Varsayılan davranış: `decoder_input_ids` içindeki dolgu (pad) jetonlarını yok sayan bir tensör oluşturur. Varsayılan olarak nedensel maske (causal mask) de kullanılır. Dolgu davranışını değiştirmek istiyorsanız, `modeling_led._prepare_decoder_inputs` dosyasını okuyup ihtiyaçlarınıza göre düzenlemelisiniz. Varsayılan strateji hakkında daha fazla bilgi için [makaledeki](https://huggingface.co/papers/1910.13461) 1 numaralı diyagrama bakın.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) içeren bir Tuple. `last_hidden_state`, `(batch_size, sequence_length, hidden_size)` biçiminde, *isteğe bağlı*) kodlayıcının (encoder) son katmanının çıktısındaki gizli durumlar (hidden-states) dizisidir. Çözücüde (decoder) çapraz dikkat (cross-attention) için kullanılır.

global_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı için her token'a verilen dikkati belirlemek için kullanılan maske; yerel dikkat veya global dikkat. Global dikkate sahip tokenlar diğer tüm tokenlara dikkat eder ve diğer tüm tokenlar da onlara dikkat eder. Bu, modeli görevi temsil etmede daha esnek hale getirdiği için görev bazlı ince ayar için önemlidir. Örneğin, sınıflandırma için  token'a global dikkat verilmelidir. Soru-cevap için, tüm soru tokenları da global dikkate sahip olmalıdır. Daha fazla ayrıntı için [Longformer makalesine](https://huggingface.co/papers/2004.05150) bakınız. `[0, 1]` aralığında seçilen maske değerleri:  - Yerel dikkat (kayan pencere dikkati) için 0, - Global dikkat (diğer tüm tokenlara dikkat eden ve diğer tüm tokenların da onlara dikkat ettiği tokenlar) için 1.

start_positions (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Token sınıflandırma kaybını hesaplamak için etiketli aralığın başlangıç konumunun (indeksinin) etiketleri. Konumlar, dizinin uzunluğuna (`sequence_length`) sınırlanır. Dizi dışındaki konumlar, kaybın hesaplanmasında dikkate alınmaz.

end_positions (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Token sınıflandırma kaybını hesaplamak için etiketli aralığın sonundaki konumun (indeksin) etiketleri. Konumlar, dizinin uzunluğuna (`sequence_length`) göre sınırlandırılır. Dizi dışındaki konumlar, kaybın hesaplanmasında dikkate alınmaz.

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.

decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi seçebilirsiniz. `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_inputs_embeds` değerlerinin girdi olarak verilmesi yeterlidir (bkz. `past_key_values`). Bu, `decoder_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. `decoder_input_ids` ve `decoder_inputs_embeds` parametrelerinin ikisi de ayarlanmamışsa, `decoder_inputs_embeds` parametresi `inputs_embeds` değerini alır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

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

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

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/v5.23.0/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** [LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput) veya `tuple(torch.Tensor)`

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

[LEDForQuestionAnswering](/docs/transformers/v5.23.0/tr/model_doc/led#transformers.LEDForQuestionAnswering) 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ı*, `labels` sağlandığında döndürülür) -- Toplam span çıkarım kaybı, başlangıç ve bitiş konumları için Çapraz Entropinin (Cross-Entropy) toplamıdır.
- **start_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) -- Span başlangıç puanları (SoftMax öncesi).
- **end_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) -- Aralık sonu puanları (SoftMax öncesi).
- **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.

  Dizisel çözümlendirmeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, çözücüdeki önceden hesaplanmış gizli durumları (dikkat bloklarındaki anahtar ve değerler) içerir.
- **decoder_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` (modelin bir 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 bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında dekodlayıcının gizli durumları.
- **decoder_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) -- Her katman için bir adet içeren `torch.Tensor` (şekil: `(batch_size, num_heads, sequence_length, sequence_length)`) bir demeti.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları.
- **cross_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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıkları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ı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.
- **encoder_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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.
- **encoder_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 yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları.
- **encoder_global_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, x)` şeklindedir; burada `x`, global dikkat maskesine sahip jeton sayısıdır.

  Dikkat softmax'ı sonrası global dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır. Bunlar, global dikkate sahip her token'dan dizideki her token'a olan dikkat ağırlıklarıdır.

Örnek:

```python
>>> from transformers import AutoTokenizer, LEDForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```