# Reformer

## Genel Bakış

Reformer modeli, Nikita Kitaev, Łukasz Kaiser ve Anselm Levskaya tarafından yazılan [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451) makalesinde önerilmiştir.

Makalenin özeti aşağıdaki gibidir:

*Büyük Transformer modelleri, çeşitli görevlerde rutin olarak en iyi sonuçları elde eder ancak bu modellerin eğitimi, özellikle uzun dizilerde son derece maliyetli olabilir. Transformer'ların verimliliğini artırmak için iki teknik sunuyoruz. Birincisi, nokta çarpımı dikkatini, yerel duyarlı örnekleme (locality-sensitive hashing) kullanan bir dikkatle değiştiriyoruz; bu, karmaşıklığını O(L^2)'den O(Llog(L))'ye değiştirir, burada L dizinin uzunluğudur. Ayrıca, standart artıkları yerine geri dönüşümlü artımlı katmanlar (reversible residual layers) kullanıyoruz; bu, eğitim sürecinde aktivasyonların N kez yerine yalnızca bir kez saklanmasına olanak tanır, burada N katman sayısıdır. Sonuç olarak ortaya çıkan model olan Reformer, Transformer modelleriyle benzer performans sergilerken çok daha bellek verimli ve uzun dizilerde çok daha hızlıdır.*

Bu model [patrickvonplaten](https://huggingface.co/patrickvonplaten) tarafından katkıda bulunmuştur. Yazarların kodu [burada](https://github.com/google/trax/tree/master/trax/models/reformer) bulunabilir.

## Kullanım ipuçları

- Reformer, PyTorch'taki bir hata nedeniyle *torch.nn.DataParallel* ile **çalışmaz**; bkz. [issue #36035](https://github.com/pytorch/pytorch/issues/36035).
- Axial position encoding kullanın (daha fazla ayrıntı için aşağıya bakın). Bu, dizin uzunluğu çok büyük olduğunda devasa bir konumsal kodlama matrisine sahip olmaktan kaçınmak için onu daha küçük matrislere faktörize eden bir mekanizmadır.
- Geleneksel dikkati, LSH (yerel duyarlı özetleme) dikkati ile değiştirin (daha fazla ayrıntı için aşağıya bakın). Bu, dikkat katmanlarında tam sorgu-anahtar çarpımını hesaplamaktan kaçınmak için kullanılan bir tekniktir.
- Ara katman sonuçlarını saklamaktan kaçınmak için, geriye yayılım sırasında bu sonuçları elde etmek üzere tersinir dönüştürücü katmanları kullanın (bir sonraki katmanın girdisinden artıkları çıkarmak bu sonuçları geri verir) veya belirli bir katmanın içindeki sonuçlar için bunları yeniden hesaplayın (saklamaktan daha az verimli olsa da bellek tasarrufu sağlar).
- Feedforward işlemlerini tüm batch üzerinde değil, parçalar halinde (chunks) hesaplayın.

### Aksiyel Konumsal Kodlamalar

Axial Positional Encodings, ilk olarak Google'ın [trax kütüphanesinde](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29) uygulanmış ve bu modelin makalesinin yazarları tarafından geliştirilmiştir. Çok uzun girdi dizilerini işleyen modellerde, geleneksel konum kimliği kodlamaları, her bir $i, \ldots, n_s$ konumu için boyutu $d$ olan bir gömme vektörü saklar; burada $d$, `config.hidden_size`'dır ve $n_s$, `config.max_embedding_size`'dir. Bu, $n_s = 2^{19} \approx 0.5M$ uzunluğunda bir dizi ve $d = 2^{10} \approx 1000$ değerinde bir `config.hidden_size` kullanıldığında, aşağıdaki konum kodlama matrisinin elde edileceği anlamına gelir:

$$X_{i,j}, \text{ with } i \in \left[1,\ldots, d\right] \text{ and } j \in \left[1,\ldots, n_s\right]$$

ki yalnızca saklanması gereken 500M'den fazla parametreye sahiptir. Aksiyel konumsal kodlamalar $X_{i,j}$'yi iki matrise ayırt eder:

$$X^{1}_{i,j}, \text{ burada } i \in \left[1,\ldots, d^1\right] \text{ ve } j \in \left[1,\ldots, n_s^1\right]$$

ve

$$X^{2}_{i,j}, \text{ burada } i \in \left[1,\ldots, d^2\right] \text{ ve } j \in \left[1,\ldots, n_s^2\right]$$

şu şekilde:

$$d = d^1 + d^2 \text{ ve } n_s = n_s^1 \times n_s^2 .$$

Dolayısıyla aşağıdaki geçerlidir:

$$X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{if }\ i < d^1 \text{ with } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{if } i \ge d^1 \text{ with } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}$$

İçgüdüsel olarak bu, bir konum gömme vektörü $x_j \in \mathbb{R}^{d}$'nin artık iki faktörize edilmiş gömme vektörünün bileşimi, $x^1_{k, l} + x^2_{l, k}$, olduğu anlamına gelir; burada `config.max_embedding_size` boyutu $j$, $k \text{ ve } l$ olarak faktörize edilir. Bu tasarım, her konum gömme vektörü $x_j$'nin benzersiz olmasını sağlar.

Yukarıdaki örneği tekrar kullanarak, $d^1 = 2^9, d^2 = 2^9, n_s^1 = 2^9, n_s^2 = 2^{10}$ değerlerine sahip eksenel konum kodlaması, parametre sayısını 500 000 000'den $2^{18} + 2^{19} \approx 780 000$ parametreye kadar büyük ölçüde azaltabilir; bu da %85 daha az bellek kullanımı anlamına gelir.

Uygulamada, `config.axial_pos_embds_dim` parametresi, toplamının `config.hidden_size` değerine eşit olması gereken $(d^1, d^2)$ bir demete ayarlanır ve `config.axial_pos_shape`, çarpımının `config.max_embedding_size` değerine eşit olması gereken $(n_s^1, n_s^2)$ bir demete ayarlanır; bu değer, eğitim sırasında `input_ids`'in *dizgi uzunluğu*na eşit olmalıdır.

### LSH Kendi Dikkati

Yerel duyarlı örnekleme (LSH) öz-dikkatinde anahtar ve sorgu projeksiyon ağırlıkları bağlıdır. Dolayısıyla anahtar sorgu gömme vektörleri de bağlıdır. LSH öz-dikkati, [Practical and Optimal LSH for Angular Distance](https://huggingface.co/papers/1509.02897) makalesinde önerilen yerel duyarlı örnekleme mekanizmasını kullanarak bağlı anahtar sorgu gömme vektörlerinden her birini `config.num_buckets` olası kovadan birine atar. Temel varsayım, birbirine daha "benzer" olan anahtar sorgu gömme vektörlerinin (*cosine similarity* açısından) aynı kovaya atanma olasılığının daha yüksek olmasıdır.

LSH mekanizmasının doğruluğu, LSH öz-dikkatinin çıktısının "normal" tam öz-dikkat çıktısını daha iyi yakıtlaması için `config.num_hashes`'i veya doğrudan forward fonksiyonunun `num_hashes` argümanını artırarak iyileştirilebilir. Kovalar daha sonra sıralanır ve her biri `config.lsh_chunk_length` uzunluğunda sorgu anahtar gömme vektörü parçalarına bölünür. Her parça için, sorgu gömme vektörleri kendi anahtar vektörlerine (kendileriyle eşleşen) ve `config.lsh_num_chunks_before` önceki komşu parçaların ile `config.lsh_num_chunks_after` sonraki komşu parçaların anahtar gömme vektörlerine dikkat eder.

Daha fazla bilgi için [orijinal makaleye](https://huggingface.co/papers/2001.04451) veya bu harika [blog yazısına](https://www.pragmatic.ml/reformer-deep-dive/) bakın.

`config.num_buckets`'un $(n_{\text{buckets}}^1, n_{\text{buckets}}^2)$ şeklinde bir listeye ayrıştırılabileceğini de unutmayın. Bu sayede sorgu anahtar gömme vektörleri $(1,\ldots, n_{\text{buckets}})$ içindekilerden birine atanmak yerine $(1-1,\ldots, n_{\text{buckets}}^1-1, \ldots, 1-n_{\text{buckets}}^2, \ldots, n_{\text{buckets}}^1-n_{\text{buckets}}^2)$ içindekilerden birine atanır. Bu, bellek tasarrufu sağlamak için çok uzun dizilerde hayati önem taşır.

Bir modeli sıfırdan eğitirken, `config.num_buckets=None` bırakılması önerilir; böylece `num_buckets` için iyi bir değer, dizi uzunluğuna bağlı olarak anlık olarak hesaplanır. Bu değer daha sonra otomatik olarak yapılandırmaya kaydedilir ve çıkarım için yeniden kullanılmalıdır.

LSH öz-dikkat kullanılarak, $n_s$ dizinin uzunluğu olmak üzere, bir transformer modelinde genellikle bellek ve zaman darboğazını temsil eden sorgu-anahtar matris çarpımı işleminin bellek ve zaman karmaşıklığı $\mathcal{O}(n_s \times n_s)$'den $\mathcal{O}(n_s \times \log(n_s))$'a indirgenebilir.

### Yerel Kendi Dikkati

Yerel öz-dikkat, temel olarak anahtar, sorgu ve değer projeksiyonlarına sahip “normal” bir öz-dikkat katmanıdır; ancak parçalanmıştır, böylece `config.local_chunk_length` uzunluğundaki her parçada sorgu gömme vektörleri yalnızca kendi parçasındaki anahtar gömme vektörlerine, `config.local_num_chunks_before` önceki komşu parçalardaki anahtar gömme vektörlerine ve `config.local_num_chunks_after` sonraki komşu parçalardaki anahtar gömme vektörlerine dikkat eder.

Local self attention kullanılarak, $n_s$ dizinin uzunluğu olmak üzere, transformer modelinde genellikle bellek ve zaman darboğazını temsil eden query-key matmul işleminin bellek ve zaman karmaşıklığı $\mathcal{O}(n_s \times n_s)$'den $\mathcal{O}(n_s \times \log(n_s))$'a indirgenebilir.

### Eğitim

Eğitim sırasında, dizi uzunluğunun `config.lsh_chunk_length` ile `config.local_chunk_length`'in en küçük ortak katına bölünebilecek bir değere ayarlandığından ve yukarıda belirtildiği gibi Axial Positional Encodings parametrelerinin doğru şekilde ayarlandığından emin olmalıyız. Reformer çok bellek verimlidir, bu nedenle model kolayca 64000 token'a kadar uzunlukta diziler üzerinde eğitilebilir.

Eğitim için [ReformerModelWithLMHead](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerModelWithLMHead) aşağıdaki gibi kullanılmalıdır:

```python
input_ids = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device)
loss = model(input_ids, labels=input_ids)[0]
```

## Kaynaklar

- [Metin sınıflandırma görevi kılavuzu](../tasks/sequence_classification)
- [Soru yanıtlama görevi kılavuzu](../tasks/question_answering)
- [Nedensel dil modelleme görevi kılavuzu](../tasks/language_modeling)
- [Masked dil modelleme görevi kılavuzu](../tasks/masked_language_modeling)

## ReformerConfig[[transformers.ReformerConfig]]

#### transformers.ReformerConfig[[transformers.ReformerConfig]]

```python
transformers.ReformerConfig(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, attention_head_size: int = 64, attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh'), axial_norm_std: float = 1.0, axial_pos_embds: bool = True, axial_pos_shape: list[int] | tuple[int, ...] = (64, 64), axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192), chunk_size_lm_head: int = 0, eos_token_id: int | list[int] | None = 2, feed_forward_size: int = 512, hash_seed: int | None = None, hidden_act: str = 'relu', hidden_dropout_prob: float | int = 0.05, hidden_size: int = 256, initializer_range: float = 0.02, is_decoder: bool = False, layer_norm_eps: float = 1e-12, local_num_chunks_before: int = 1, local_num_chunks_after: int = 0, local_attention_probs_dropout_prob: float | int = 0.05, local_attn_chunk_length: int = 64, lsh_attn_chunk_length: int | None = 64, lsh_attention_probs_dropout_prob: float | None = 0.0, lsh_num_chunks_before: int | None = 1, lsh_num_chunks_after: int | None = 0, max_position_embeddings: int = 4096, num_attention_heads: int = 12, num_buckets: int | list[int] | None = None, num_hashes: int = 1, vocab_size: int = 320, tie_word_embeddings: bool = False, use_cache: bool = True, classifier_dropout: float | int | None = None, bos_token_id: int | None = None, pad_token_id: int | None = 0)
```

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

**Parametreler:**

attention_head_size (`int`, *isteğe bağlı*, varsayılan 64) : Projelendirilmiş anahtar, sorgu ve değer vektörlerinin boyutluluğu

attn_layers (`list[str]`, *isteğe bağlı*, varsayılan `["local", "lsh", "local", "lsh", "local", "lsh"]`) : Artan sırada dikkat katmanı türlerinin listesi. LSHSelfAttention katmanı (`"lsh"`) ile LocalSelfAttention katmanı (`"local"`) arasında seçim yapılabilir. LSHSelfAttention katmanı hakkında daha fazla bilgi için [LSH Self Attention](reformer#lsh-self-attention) bölümüne bakın. LocalSelfAttention katmanı hakkında daha fazla bilgi için [Local Self Attention](reformer#local-self-attention) bölümüne bakın.

axial_norm_std (`float`, *opsiyonel*, varsayılan 1.0) : Aksiyel konumsal kodlamaların ağırlık matrislerini başlatmak için normal_initializer'ın standart sapması.

axial_pos_embds (`bool`, *isteğe bağlı*, varsayılan `True`) : Aksiyel konum gömme kullanılıp kullanılmayacağı. Aksiyel konum kodlamalarının nasıl çalıştığına dair daha fazla bilgi için [Aksiyel Konum Kodlamaları](reformer#axial-positional-encodings) bölümüne bakın.

axial_pos_shape (`list[int]`, *isteğe bağlı*, varsayılan `[64, 64]`) : Aksiyel konum kodlamalarının konum boyutları. Eğitim sırasında, konum boyutlarının çarpımı dizinin uzunluğuna eşit olmalıdır. Aksiyel konum gömme işlemlerinin nasıl çalıştığına dair daha fazla bilgi için [Aksiyel Konum Kodlamaları](reformer#axial-positional-encodings) bölümüne bakın.

axial_pos_embds_dim (`list[int]`, *isteğe bağlı*, varsayılan `[64, 192]`) : Aksiyel konum kodlamalarının gömme boyutları. Gömme boyutlarının toplamı gizli boyuta eşit olmalıdır. Aksiyel konum gömme işlemlerinin nasıl çalıştığına dair daha fazla bilgi için [Aksiyel Konum Kodlamaları](reformer#axial-positional-encodings) bölümüne bakın.

chunk_size_lm_head (`int`, *isteğe bağlı*, varsayılan 0) : Son dil modeli ileri besleme (feed forward) baş katmanının parça boyutu. Parça boyutu 0 ise ileri besleme katmanı parçalanmaz. Parça boyutu n ise ileri besleme katmanı, her seferinde n < sequence_length gömme (embedding) işler. İleri besleme parçalama hakkında daha fazla bilgi için [Feed Forward Chunking nasıl çalışır?](../glossary#feed-forward-chunking) bölümüne bakın.

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.

feed_forward_size (`int`, *isteğe bağlı*, varsayılan 512) : Kalıntı dikkat bloğundaki feed_forward katmanının boyutluluğu.

hash_seed (`int`, *opsiyonel*) : `LSHSelfAttention` içindeki yerel duyarlı özetlemeyi (local sensitive hashing) deterministik hale getirmek için kullanılabilen tohum. Bu değer yalnızca test amaçlı ayarlanmalıdır. Değerlendirme ve eğitim amaçları için, yerel duyarlı özetleme şemasında tamamen rastgele dönüşümleri sağlamak adına `hash_seed` değeri `None` olarak bırakılmalıdır.

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

hidden_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.05`) : Gömme, kodlayıcı ve havuzlayıcıdaki tüm tam bağlı katmanlar için dropout olasılığı.

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

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

is_decoder (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelin bir çözücü olarak kullanılıp kullanılmadığı. `False` ise model, bir kodlayıcı olarak kullanılır.

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

local_num_chunks_before (`int`, *isteğe bağlı*, varsayılan 1) : `LocalSelfAttention` katmanında kendisine dikkat etmesi için kullanılan önceki komşu parçaların sayısı.

local_num_chunks_after (`int`, *opsiyonel*, varsayılan 0) : `LocalSelfAttention` katmanında kendisine ek olarak dikkat edilecek ardışık komşu parçaların sayısı.

local_attention_probs_dropout_prob (`float`, *opsiyonel*, varsayılan 0.1) : `LocalSelfAttention` içindeki dikkat olasılıkları için dropout oranı.

local_attn_chunk_length (`int`, *isteğe bağlı*, varsayılan 64) : Yerel dikkat katmanlarında her parçanın uzunluğu.

lsh_attn_chunk_length (`int`, *opsiyonel*, varsayılan 64) : `LSHSelfAttention` içinde kendisine dikkat eden parçanın uzunluğu. Parçalama, bellek karmaşıklığını dizi uzunluğu x dizi uzunluğu (kendi kendine dikkat) değerinden parça uzunluğu x parça uzunluğu x dizi uzunluğu / parça uzunluğu (parçalı kendi kendine dikkat) değerine düşürür.

lsh_attention_probs_dropout_prob (`float`, *opsiyonel*, varsayılan 0.1) : `LSHSelfAttention` içindeki dikkat olasılıkları için dropout oranı.

lsh_num_chunks_before (`int`, *isteğe bağlı*, varsayılan 1) : `LSHSelfAttention` katmanında kendisine dikkat etmesi için kullanılan önceki komşu parçaların sayısı.

lsh_num_chunks_after (`int`, *isteğe bağlı*, varsayılan 0) : `LSHSelfAttention` katmanında kendisine dikkat etmesi için takip eden komşu parçaların sayısı.

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

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

num_buckets (`int` veya `list[int]`, *isteğe bağlı*) : Yerel duyarlı özetleme (locality sensitive hashing) şeması kullanılarak anahtar sorgu vektörlerinin "özetlenebileceği" (hashed into) kovaların sayısı. Her sorgu anahtar vektörü, `1, ..., num_buckets` aralığında bir özeğe (hash) özetlenir. Kovaların sayısı, bellek karmaşıklığını iyileştirmek için bir liste olarak çarpanlarına ayrılabilir. Bu durumda, `num_buckets` iki çarpana ayrılıyorsa her sorgu anahtar vektörü, `1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1]` aralığında bir özeğe özetlenir. Kovaların sayısı (veya çarpanların çarpımı), yaklaşık olarak dizi uzunluğu / lsh_chunk_length değerine eşit olmalıdır. `num_buckets` ayarlanmazsa, iyi bir değer anlık olarak hesaplanır.

num_hashes (`int`, *opsiyonel*, varsayılan 1) : Local Sensitive Hashing şemasında hashleme turlarının sayısı (ör. rastgele döndürme sayısı). `num_hashes` ne kadar yüksekse, `LSHSelfAttention` o kadar doğru hale gelir; ancak hashleme işlemi de o kadar fazla bellek ve zaman gerektirir.

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

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.

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

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

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

Bu, bir ReformerModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Reformer modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [google/reformer-crime-and-punishment](https://huggingface.co/google/reformer-crime-and-punishment) 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.

Örnekler:

```python
>>> from transformers import ReformerConfig, ReformerModel

>>> # Initializing a Reformer configuration
>>> configuration = ReformerConfig()

>>> # Initializing a Reformer model (with random weights)
>>> model = ReformerModel(configuration)

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

## ReformerTokenizer[[transformers.ReformerTokenizer]]

#### transformers.ReformerTokenizer[[transformers.ReformerTokenizer]]

```python
transformers.ReformerTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, eos_token: str = '</s>', unk_token: str = '<unk>', _spm_precompiled_charsmap: str | None = None, additional_special_tokens: list | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/tokenization_reformer.py#L31)

**Parametreler:**

vocab_file (`str`) : Bir tokenizer'ı örneklemek için gerekli sözlüğü içeren [SentencePiece](https://github.com/google/sentencepiece) dosyası (genellikle *.spm* uzantısına sahiptir).

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.

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.

additional_special_tokens (`list[str]`, *isteğe bağlı*) : Tokenizer tarafından kullanılan ek özel tokenlar.

vocab (`str` veya `dict[str, int]`, *isteğe bağlı*) : Özel sözlük. Sağlanmazsa, sözlük `vocab_file` içinden yüklenir.

merges (`str` veya `list[str]`, *isteğe bağlı*) : Özel birleştirme listesi. Sağlanmazsa, birleştirmeler `vocab_file` içinden yüklenir.

Bir Reformer tokenizer'ı oluşturun (HuggingFace'in tokenizers kütüphanesi tarafından desteklenir). [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models) tabanlıdır.

Bu tokenizer, ana yöntemlerin çoğunu içeren [TokenizersBackend](/docs/transformers/main/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.

#### save_vocabulary[[transformers.ReformerTokenizer.save_vocabulary]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546)

## ReformerModel[[transformers.ReformerModel]]

#### transformers.ReformerModel[[transformers.ReformerModel]]

```python
transformers.ReformerModel(config: ReformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L1931)

**Parametreler:**

config ([ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig)) : 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 göz atın.

Üzerinde herhangi bir özel başlık olmadan ham gizli durumları (hidden-states) üreten çıplak Reformer Modeli.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L1951)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Eğitim sırasında input_ids dizisinin sequence_length değeri, ilgili modelin parça uzunluklarının (lsh, local veya her ikisi) katı olmalıdır. Değerlendirme sırasında indeksler, parça uzunluğunun katı olacak şekilde otomatik olarak dolgu (padding) ile tamamlanır. İ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 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)

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

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.

num_hashes (`int`, *isteğe bağlı*) : Bucketing sırasında gerçekleştirilmesi gereken hashleme turu sayısı. Bu argümanı ayarlamak, `config.num_hashes` içinde tanımlanan varsayılan değeri yazar. Daha fazla bilgi için [ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig) içindeki `num_hashes` parametresine bakın.

past_buckets_states (`ReformerDynamicCache`, *isteğe bağlı*) : `config.n_layers` uzunluğunda, ilk öğesi `(batch_size, num_heads, num_hashes, sequence_length)` biçiminde önceki *buckets* olan, ikincisi ise `(batch_size, sequence_length, hidden_size)` biçiminde önceki *hidden_states* olan `tuple(torch.LongTensor, torch.Tensor` listesidir. Ön hesaplanmış gizli durumları ve varilleri (yalnızca LSH Self-Attention için geçerlidir) içerir. Sıralı çözümlemeyi hızlandırmak için kullanılabilir.

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_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.

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.

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üş:** `ReformerModelOutput` veya `tuple(torch.Tensor)`

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

[ReformerModel](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerModel) 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, num_predict, hidden_size)`) -- Modelin son katmanındaki gizli durumlar dizisi.

  `num_predict`, `target_mapping.shape[1]` ile eşleşir. `target_mapping` `None` ise, `num_predict` `sequence_length` ile eşleşir.
- **past_buckets_states** (`list[tuple(torch.LongTensor, torch.Tensor)]`, *opsiyonel*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- `config.n_layers` uzunluğunda, ilk öğesi `(batch_size, num_heads, num_hashes, sequence_length)` biçiminde önceki *buckets* olan ve ikincisi `(batch_size, sequence_length, hidden_size)` biçiminde önceki *hidden_states* olan `tuple(torch.LongTensor, torch.Tensor` listesi.

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

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(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.

## ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

#### transformers.ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

```python
transformers.ReformerModelWithLMHead(config: ReformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2150)

**Parametreler:**

config ([ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig)) : 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 göz atın.

Üzerinde `language modeling` başlığı bulunan Reformer 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.ReformerModelWithLMHead.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: list[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2176)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Eğitim sırasında input_ids dizisinin sequence_length değeri, ilgili modelin parça uzunluklarının (lsh, local veya her ikisi) katı olmalıdır. Değerlendirme sırasında indeksler, parça uzunluğunun katı olacak şekilde otomatik olarak dolgu (padding) ile tamamlanır. İ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 kimlikları (input IDs) nedir?](../glossary#input-ids)

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

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)

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.

num_hashes (`int`, *isteğe bağlı*) : Bucketing sırasında gerçekleştirilmesi gereken hashleme turu sayısı. Bu argümanı ayarlamak, `config.num_hashes` içinde tanımlanan varsayılan değeri yazar. Daha fazla bilgi için [ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig) içindeki `num_hashes` parametresine bakın.

past_buckets_states (`list[tuple(torch.LongTensor, torch.Tensor)]`, *isteğe bağlı*) : `config.n_layers` uzunluğunda, ilk öğesi `(batch_size, num_heads, num_hashes, sequence_length)` biçiminde önceki *buckets* olan ve ikinci öğesi `(batch_size, sequence_length, hidden_size)` biçiminde önceki *hidden_states* olan `tuple(torch.LongTensor, torch.Tensor` listesi. Ön hesaplanmış gizli durumları ve sepetleri içerir (yalnızca LSH Self-Attention için geçerlidir). Sıralı çözümlemeyi hızlandırmak için kullanılabilir.

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_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.

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.

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?

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size - 1]` aralığında olmalıdır. `-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.

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üş:** [CausalLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) veya `tuple(torch.Tensor)`

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

[ReformerModelWithLMHead](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerModelWithLMHead) 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).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

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

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

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerModelWithLMHead.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

#### transformers.ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

```python
transformers.ReformerForMaskedLM(config: ReformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2287)

**Parametreler:**

config ([ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig)) : 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 göz atın.

Üstünde `language modeling` başlığı bulunan Reformer Modeli."

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2307)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Eğitim sırasında input_ids dizisinin sequence_length değeri, ilgili modelin parça uzunluklarının (lsh, local veya her ikisi) katı olmalıdır. Değerlendirme sırasında indeksler, parça uzunluğunun katı olacak şekilde otomatik olarak dolgu (padding) ile tamamlanır. İ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 kimlikları (input IDs) nedir?](../glossary#input-ids)

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

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)

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.

num_hashes (`int`, *isteğe bağlı*) : Bucketing sırasında gerçekleştirilmesi gereken hashleme turu sayısı. Bu argümanı ayarlamak, `config.num_hashes` içinde tanımlanan varsayılan değeri yazar. Daha fazla bilgi için [ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig) içindeki `num_hashes` parametresine bakın.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size]` aralığında olmalıdır (bkz. `input_ids` docstring). Endeksleri `-100` olarak ayarlanan jetonlar yok sayılır (maskelenir), kayıp yalnızca etiketleri olan jetonlar için hesaplanır    Bu örnek, Reformer mimarisi için maskeli dil modelleme görevinde kullanılabilir önceden eğitilmiş bir modelimiz olmadığından sahte bir checkpoint kullanır.

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.

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.

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üş:** [MaskedLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya `tuple(torch.Tensor)`

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

[ReformerForMaskedLM](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerForMaskedLM) 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) -- Maskeli dil modelleme (MLM) 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).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

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

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

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-reformer")
>>> model = ReformerForMaskedLM.from_pretrained("hf-internal-testing/tiny-random-reformer")

>>> # add mask_token
>>> tokenizer.add_special_tokens({"mask_token": "[MASK]"})
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> # resize model's embedding matrix
>>> model.resize_token_embeddings(new_num_tokens=model.config.vocab_size + 1)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> predicted_token = tokenizer.decode(predicted_token_id)
```

```python
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(
...     inputs.input_ids == tokenizer.mask_token_id, labels[:, : inputs["input_ids"].shape[-1]], -100
... )

>>> outputs = model(**inputs, labels=labels)
>>> loss = round(outputs.loss.item(), 2)
```

## ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

#### transformers.ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

```python
transformers.ReformerForSequenceClassification(config: ReformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2425)

**Parametreler:**

config ([ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig)) : 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 göz atın.

Reformer Model transformer, üstünde bir dizi sınıflandırma/geri dönüşüm başlığı (toplanmış çıktının üstünde doğrusal bir katman) ile, örneğin GLUE görevleri için.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2439)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Eğitim sırasında input_ids dizisinin sequence_length değeri, ilgili modelin parça uzunluklarının (lsh, local veya her ikisi) katı olmalıdır. Değerlendirme sırasında indeksler, parça uzunluğunun katı olacak şekilde otomatik olarak dolgu (padding) ile tamamlanır. İ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 kimlikları (input IDs) nedir?](../glossary#input-ids)

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

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)

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.

num_hashes (`int`, *isteğe bağlı*) : Bucketing sırasında gerçekleştirilmesi gereken hashleme turu sayısı. Bu argümanı ayarlamak, `config.num_hashes` içinde tanımlanan varsayılan değeri yazar. Daha fazla bilgi için [ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig) içindeki `num_hashes` parametresine bakın.

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüş kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır.

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.

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.

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üş:** [SequenceClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) veya `tuple(torch.Tensor)`

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

[ReformerForSequenceClassification](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerForSequenceClassification) 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) -- Sınıflandırma (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).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

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

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

Tek etiketli sınıflandırma örneği:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> label = model.config.id2label[predicted_class_id]
```

```python
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
```

## ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

#### transformers.ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

```python
transformers.ReformerForQuestionAnswering(config: ReformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2572)

**Parametreler:**

config ([ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig)) : 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 göz atın.

SQuAD gibi çıkarımsal soru-cevap görevleri için üstünde bir span sınıflandırma kafası bulunan Reformer transformer (gizli durum çıktısının üzerine, `span start logits` ve `span end logits` hesaplamak için eklenmiş doğrusal bir katman).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/reformer/modeling_reformer.py#L2584)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Eğitim sırasında input_ids dizisinin sequence_length değeri, ilgili modelin parça uzunluklarının (lsh, local veya her ikisi) katı olmalıdır. Değerlendirme sırasında indeksler, parça uzunluğunun katı olacak şekilde otomatik olarak dolgu (padding) ile tamamlanır. İ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 kimlikları (input IDs) nedir?](../glossary#input-ids)

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

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)

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.

num_hashes (`int`, *isteğe bağlı*) : Bucketing sırasında gerçekleştirilmesi gereken hashleme turu sayısı. Bu argümanı ayarlamak, `config.num_hashes` içinde tanımlanan varsayılan değeri yazar. Daha fazla bilgi için [ReformerConfig](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerConfig) içindeki `num_hashes` parametresine bakın.

start_positions (`torch.Tensor`, ş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.Tensor`, ş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.

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.

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.

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üş:** [QuestionAnsweringModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) veya `tuple(torch.Tensor)`

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

[ReformerForQuestionAnswering](/docs/transformers/main/tr/model_doc/reformer#transformers.ReformerForQuestionAnswering) 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)`) -- Span başlangıç puanları (SoftMax öncesi).
- **end_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`) -- Span sonu puanları (SoftMax öncesi).
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

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

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

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")

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