# RWKV

## Genel Bakış

RWKV modeli (4. sürüm) [bu depoda](https://github.com/BlinkDL/RWKV-LM) önerilmiştir

Geleneksel Transformer dikkat mekanizmasında, onu doğrusal hale getirmek için bir ayarlama önerir. Bu sayede model, tekrarlayan bir ağ olarak kullanılabilir: zaman damgası 0 ve zaman damgası 1 için girdileri birlikte iletmek, önce zaman damgası 0'daki girdileri, ardından zaman damgası 0'ın durumuyla birlikte zaman damgası 1'deki girdileri iletmekle aynıdır (aşağıdaki örneğe bakınız).

Bu, standart bir Transformer'dan daha verimli olabilir ve herhangi bir uzunluktaki cümlelerle başa çıkabilir (model eğitim için sabit bir bağlam uzunluğu kullanıyor olsa bile).

Bu model [sgugger](https://huggingface.co/sgugger) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/BlinkDL/RWKV-LM) bulunabilir.

## Kullanım örneği

```python
import torch

from transformers import AutoTokenizer, RwkvModel

model = RwkvModel.from_pretrained("sgugger/rwkv-430M-pile", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("sgugger/rwkv-430M-pile")

inputs = tokenizer("This is an example.", return_tensors="pt").to(model.device)
# Feed everything to the model
outputs = model(inputs["input_ids"])
output_whole = outputs.last_hidden_state

outputs = model(inputs["input_ids"][:, :2])
output_one = outputs.last_hidden_state

# Using the state computed on the first inputs, we will get the same output
outputs = model(inputs["input_ids"][:, 2:], state=outputs.state)
output_two = outputs.last_hidden_state

torch.allclose(torch.cat([output_one, output_two], dim=1), output_whole, atol=1e-5)
```

Modelin `'\n\n'` algılandığında üretimi durdurduğundan emin olmak istiyorsanız, aşağıdaki durdurma kriterlerini kullanmanızı öneririz:

```python
from transformers import StoppingCriteria

class RwkvStoppingCriteria(StoppingCriteria):
    def __init__(self, eos_sequence = [187,187], eos_token_id = 537):
        self.eos_sequence = eos_sequence
        self.eos_token_id = eos_token_id

    def __call__(self, input_ids: torch.LongTensor, scores: torch.Tensor, **kwargs) -> bool:
        last_2_ids = input_ids[:,-2:].tolist()
        return self.eos_sequence in last_2_ids

output = model.generate(inputs["input_ids"], max_new_tokens=64, stopping_criteria = [RwkvStoppingCriteria()])
```

## Notlar

- Toplu üretim için sol dolguyu kullanın. [Dolgu tarafı](../llm_tutorial#padding-side) bölümüne bakın.

## RwkvConfig[[transformers.RwkvConfig]]

#### transformers.RwkvConfig[[transformers.RwkvConfig]]

```python
transformers.RwkvConfig(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 = 50277, context_length: int = 1024, hidden_size: int = 4096, num_hidden_layers: int = 32, attention_hidden_size: int | None = None, intermediate_size: int | None = None, layer_norm_epsilon: float = 1e-05, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 0, rescale_every: int = 6, tie_word_embeddings: bool = False, use_cache: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rwkv/configuration_rwkv.py#L25)

**Parametreler:**

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

context_length (`int`, *isteğe bağlı*, varsayılan 1024) : Bu modelin tek bir ileri geçişte (RNN modunda kullanıldığında herhangi bir dizi uzunluğu kullanılabilir) kullanılabileceği maksimum dizi uzunluğu.

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

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

attention_hidden_size (`int`, *isteğe bağlı*) : Dikkat gizli durumlarının boyutluluğu. Ayarlanmazsa varsayılan olarak `hidden_size` olur.

intermediate_size (`int`, *isteğe bağlı*) : MLP temsillerinin boyutu.

layer_norm_epsilon (`float`, *opsiyonel*, varsayılan `1e-05`) : Katman normalizasyonu katmanları tarafından kullanılan epsilon.

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 `0`) : Sözlükte akış sonu için kullanılan token kimliği.

rescale_every (`int`, *opsiyonel*, varsayılan 6) : Çıkarım sırasında gizli durumlar (ve ilgili çıktı katmanlarının ağırlıkları) her `rescale_every` katmanda 2'ye bölünür. 0 veya negatif bir sayı olarak ayarlanırsa yeniden ölçekleme yapılmaz.

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

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.

Bu, bir RwkvModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Rwkv modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [RWKV/rwkv-4-169m-pile](https://huggingface.co/RWKV/rwkv-4-169m-pile) modelinin yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/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/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import RwkvConfig, RwkvModel

>>> # Initializing a Rwkv configuration
>>> configuration = RwkvConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = RwkvModel(configuration)

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

## RwkvModel[[transformers.RwkvModel]]

#### transformers.RwkvModel[[transformers.RwkvModel]]

```python
transformers.RwkvModel(config: RwkvConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rwkv/modeling_rwkv.py#L487)

**Parametreler:**

config ([RwkvConfig](/docs/transformers/main/tr/model_doc/rwkv#transformers.RwkvConfig)) : 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/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

Üzerinde herhangi bir özel head olmadan ham hidden-state çıktısı üreten çıplak Rwkv Model.

Bu model [PreTrainedModel](/docs/transformers/main/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.RwkvModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, state: list[torch.Tensor] | None = 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/main/src/transformers/models/rwkv/modeling_rwkv.py#L508)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, input_ids_length)`) : `input_ids_length` = `sequence_length` eğer `past_key_values` `None` ise, aksi halde `past_key_values.get_seq_length()` (girdi geçmiş anahtar değer durumlarının `sequence_length`'i). Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. `past_key_values` kullanılıyorsa, geçmişleri hesaplanmamış olan `input_ids` değerleri `input_ids` olarak geçirilmelidir. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikleri (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.LongTensor`, ş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)

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.

state (`tuple`, beş adet `torch.Tensor`, şekli `(batch_size, hidden_size, num_hidden_layers)`, *isteğe bağlı*) : İletilirse, model tüm bloklarda önceki durumu kullanır (bu, modelin `state_input_ids + input_ids` bağlamını eklediği varsayımıyla, sağlanan `input_ids` için çıktıyı verir).

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, son durum döndürülür ve bir sonraki logits'leri hızlıca üretmek için kullanılabilir.

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/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

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

Yapılandırmaya ([RwkvConfig](/docs/transformers/main/tr/model_doc/rwkv#transformers.RwkvConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşan bir `RwkvOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda).

[RwkvModel](/docs/transformers/main/tr/model_doc/rwkv#transformers.RwkvModel) 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)`, *isteğe bağlı*) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **state** (`list`, beş adet `torch.Tensor`, şekli `(batch_size, hidden_size, num_hidden_layers)`) -- Modelin son zaman adımındaki durumu. Eski `input_ids` değerlerini sağlamak zorunluluğunu ortadan kaldırmak için, ileri yönlü bir yöntemde bir sonraki `input_ids` ile birlikte kullanılabilir.
- **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 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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

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

## RwkvLMHeadModel[[transformers.RwkvForCausalLM]]

#### transformers.RwkvForCausalLM[[transformers.RwkvForCausalLM]]

```python
transformers.RwkvForCausalLM(config: RwkvConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rwkv/modeling_rwkv.py#L667)

**Parametreler:**

config ([RwkvConfig](/docs/transformers/main/tr/model_doc/rwkv#transformers.RwkvConfig)) : 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/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

Üzerinde bir dil modelleme kafası (giriş gömlemelerine bağlı ağırlıklı doğrusal katman) bulunan RWKV Model dönüştürücüsü.

Bu model [PreTrainedModel](/docs/transformers/main/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.RwkvForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, state: list[torch.Tensor] | None = 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, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rwkv/modeling_rwkv.py#L684)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, input_ids_length)`) : `input_ids_length` = `sequence_length` eğer `past_key_values` `None` ise, aksi halde `past_key_values.get_seq_length()` (girdi geçmiş anahtar değer durumlarının `sequence_length`'i). Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. `past_key_values` kullanılıyorsa, geçmişleri hesaplanmamış olan `input_ids` değerleri `input_ids` olarak geçirilmelidir. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikleri (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.LongTensor`, ş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)

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.

state (`tuple`, beş adet `torch.Tensor`, şekli `(batch_size, hidden_size, num_hidden_layers)`, *isteğe bağlı*) : İletilirse, model tüm bloklarda önceki durumu kullanır (bu, modelin `state_input_ids + input_ids` bağlamını eklediği varsayımıyla, sağlanan `input_ids` için çıktıyı verir).

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dil modelleme için etiketler. Not: Etiketler model içinde **kaydırılır**, yani `labels = input_ids` olarak ayarlayabilirsiniz. İndisler `[-100, 0, ..., config.vocab_size]` aralığından seçilir. `-100` olarak ayarlanan tüm etiketler yok sayılır (maske uygulanır), kayıp yalnızca `[0, ..., config.vocab_size]` aralığındaki etiketler için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, son durum döndürülür ve bir sonraki logits'leri hızlıca üretmek için kullanılabilir.

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/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

logits_to_keep (`Union[int, torch.Tensor]`, *isteğe bağlı*, varsayılan `0`) : `int` ise, son `logits_to_keep` token için logits hesaplanır. `0` ise, tüm `input_ids` için logits hesaplanır (özel durum). Üretim için yalnızca son token'ın logits'ine ihtiyaç duyulur ve bunların yalnızca o token için hesaplanması bellek tasarrufu sağlar; bu, uzun diziler veya büyük sözlük boyutu için oldukça önemli hale gelir. `torch.Tensor` ise, dizi uzunluğu boyutunda tutulacak indekslere karşılık gelen 1B olmalıdır. Bu, paketlenmiş tensor biçimini (batch ve dizi uzunluğu için tek boyut) kullanırken faydalıdır.

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

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

[RwkvForCausalLM](/docs/transformers/main/tr/model_doc/rwkv#transformers.RwkvForCausalLM) 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ı (sonraki token tahmini için).
- **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).
- **state** (`list`, beş adet `torch.Tensor`, şekli `(batch_size, hidden_size, num_hidden_layers)`) -- Modelin son zaman adımındaki durumu. Eski `input_ids` değerlerini sağlamak zorunluluğunu ortadan kaldırmak için, ileri yönlü bir yöntemde bir sonraki `input_ids` ile birlikte kullanılabilir.
- **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 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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

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

Örnek:

```python
```

## Rwkv dikkati ve tekrarlayan formüller

Geleneksel otoregresif bir Transformer'de dikkat, şu şekilde yazılır

$$O = \hbox{softmax}(QK^{T} / \sqrt{d}) V$$

$Q$, $K$ ve $V$, sorgu, anahtar ve değer olarak adlandırılan, şekli `seq_len x hidden_size` olan matrislerdir (aslında bir parti boyutu ve bir dikkat başı boyutu içeren daha büyük matrislerdir ancak yalnızca son ikisiyle ilgileniyoruz, çünkü matris çarpımı burada alınır, bu nedenle sadelik adına yalnızca bu ikisini dikkate alıyoruz). $QK^{T}$ çarpımının şekli `seq_len x seq_len` olur ve $V$ ile matris çarpımını alarak diğerleriyle aynı şekle sahip çıktı $O$'yu elde edebiliriz.

Softmax'ın yerine değerini koyarsak:

$$O_{i} = \frac{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}} V_{j}}{\sum_{j=1}^{i} e^{Q_{i} K_{j}^{T} / \sqrt{d}}}$$

$QK^{T}$ içinde $j > i$'ye karşılık gelen girdilerin maskeleme altında olduğunu (toplamın j'de durduğunu) ve dikkatin gelecekteki token'lara bakmasına izin verilmediğini (yalnızca geçmiş token'lara) unutmayın.

Karşılaştırma olarak, RWKV dikkati şu şekilde verilir

$$O_{i} = \sigma(R_{i}) \frac{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}} V_{j}}{\sum_{j=1}^{i} e^{W_{i-j} + K_{j}}}$$

burada $R$, yazar tarafından reaktans olarak adlandırılan yeni bir matris, $K$ ve $V$ hâlâ anahtar ve değerdir ($\sigma$ burada sigmoid fonksiyonudur). $W$, token'ın konumunu temsil eden ve şu şekilde verilen yeni bir vektördür

$$W_{0} = u \hbox{  ve  } W_{k} = (k-1)w \hbox{ için } k \geq 1$$

kodda `time_first` ve `time_decay` olarak adlandırılan $u$ ve $w$ öğrenilebilir parametreleri ile. Pay ve payda her ikisi de özyinelemeli olarak ifade edilebilir. Bunlara $N_{i}$ ve $D_{i}$ adını verdiğimizde:

$$N_{i} = e^{u + K_{i}} V_{i} + \hat{N}_{i} \hbox{  burada  } \hat{N}_{i} = e^{K_{i-1}} V_{i-1} + e^{w + K_{i-2}} V_{i-2} \cdots + e^{(i-2)w + K_{1}} V_{1}$$

böylece `numerator_state` olarak adlandırılan `numerator_state` şu koşulu sağlar

$$\hat{N}_{0} = 0 \hbox{  ve  } \hat{N}_{j+1} = e^{K_{j}} V_{j} + e^{w} \hat{N}_{j}$$

ve

$$D_{i} = e^{u + K_{i}} + \hat{D}_{i} \hbox{  burada  } \hat{D}_{i} = e^{K_{i-1}} + e^{w + K_{i-2}} \cdots + e^{(i-2)w + K_{1}}$$

böylece `denominator_state` olarak adlandırılan `denominator_state` şu koşulu sağlar

$$\hat{D}_{0} = 0 \hbox{  ve  } \hat{D}_{j+1} = e^{K_{j}} + e^{w} \hat{D}_{j}$$

Gerçekte kullanılan yinelemeli formül biraz daha karmaşıktır, çünkü sayısal kararlılık için büyük sayıların üstel değerlerini hesaplamak istemeyiz. Genellikle softmax olduğu gibi hesaplanmaz; bunun yerine en büyük terimin üsteli, paydan ve paydadan bölünür:

$$\frac{e^{x_{i}}}{\sum_{j=1}^{n} e^{x_{j}}} = \frac{e^{x_{i} - M}}{\sum_{j=1}^{n} e^{x_{j} - M}}$$

burada $M$, tüm $x_{j}$ değerlerinin maksimumudur. Dolayısıyla burada pay durumunu ($\hat{N}$) ve payda durumunu ($\hat{D}$) saklamanın yanı sıra, üstel ifadelerde karşılaşılan tüm terimlerin maksimumunu da takip ediyoruz. Dolayısıyla aslında şunu kullanıyoruz

$$\tilde{N}_{i} = e^{-M_{i}} \hat{N}_{i} \hbox{  ve  } \tilde{D}_{i} = e^{-M_{i}} \hat{D}_{i}$$

aşağıdaki tekrarlayan formüllerle tanımlanır:

$$\tilde{N}_{0} = 0 \hbox{  ve  } \tilde{N}_{j+1} = e^{K_{j} - q} V_{j} + e^{w + M_{j} - q} \tilde{N}_{j} \hbox{  burada  } q = \max(K_{j}, w + M_{j})$$

ve

$$\tilde{D}_{0} = 0 \hbox{  ve  } \tilde{D}_{j+1} = e^{K_{j} - q} + e^{w + M_{j} - q} \tilde{D}_{j} \hbox{  burada  } q = \max(K_{j}, w + M_{j})$$

ve $M_{j+1} = q$. Bunlarla, ardından

$$N_{i} = e^{u + K_{i} - q} V_{i} + e^{M_{i}} \tilde{N}_{i} \hbox{  burada  } q = \max(u + K_{i}, M_{i})$$

ve

$$D_{i} = e^{u + K_{i} - q} + e^{M_{i}} \tilde{D}_{i} \hbox{  burada  } q = \max(u + K_{i}, M_{i})$$

which finally gives us

$$O_{i} = \sigma(R_{i}) \frac{N_{i}}{D_{i}}$$