# Veri toplayıcısı

Data collator'lar, girdi olarak veri seti öğelerinin bir listesini kullanarak bir batch oluşturacak nesnelerdir. Bu öğeler, `train_dataset` veya `eval_dataset` öğeleriyle aynı tiptedir.

Partiler oluşturabilmek için veri toplayıcılar bazı işlemler uygulayabilir (örneğin dolgu). Bunlardan bazıları (örneğin [DataCollatorForLanguageModeling](/docs/transformers/v5.23.0/tr/main_classes/data_collator#transformers.DataCollatorForLanguageModeling)), oluşturulan parti üzerinde bazı rastgele veri artırma teknikleri (örneğin rastgele maskeleme) uygular.

Kullanım örnekleri [örnek defterlerde](https://github.com/huggingface/notebooks/tree/main/examples) bulunabilir.

## Varsayılan veri toplayıcısı[[transformers.default_data_collator]]

#### transformers.default_data_collator[[transformers.default_data_collator]]

```python
transformers.default_data_collator(features: list[typing.Any], return_tensors = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L71)

Diz benzeri nesnelerin partilerini bir araya getiren ve potansiyel olarak şu adlara sahip anahtarlar için özel işleme uygulayan çok basit bir veri toplayıcı:

- `label`: nesne başına tek bir değer (int veya float) işler
- `label_ids`: nesne başına bir değer listesini işler

Ek bir ön işleme yapmaz: girdi nesnesinin özellik adları, modele girdi olarak kullanılır. Bunun nasıl faydalı olduğuna dair bir örnek için glue ve ner'e bakın.

## DefaultDataCollator[[transformers.DefaultDataCollator]]

#### transformers.DefaultDataCollator[[transformers.DefaultDataCollator]]

```python
transformers.DefaultDataCollator(return_tensors: str = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L95)

**Parametreler:**

return_tensors (`str`, *isteğe bağlı*, varsayılan `"pt"`) : Dönülecek Tensor türü. Kabul edilen değerler "np" veya "pt" şeklindedir.

Diz benzeri nesnelerin partilerini bir araya getiren ve potansiyel olarak şu adlara sahip anahtarlar için özel işleme uygulayan çok basit bir veri toplayıcı:

- `label`: nesne başına tek bir değer (int veya float) işler
- `label_ids`: nesne başına bir değer listesini işler

Ek bir ön işleme yapmaz: girdi nesnesinin özellik adları, modele girdi olarak kullanılır. Bunun nasıl faydalı olduğuna dair bir örnek için glue ve ner'e bakın.

Bu, default_data_collator gibi saf bir işlev değil, diğer veri toplayıcıları gibi bir nesnedir. Başlatma sırasında bir return_tensors değeri ayarlamanız gerekiyorsa bu işe yarayabilir.

## DataCollatorWithPadding[[transformers.DataCollatorWithPadding]]

#### transformers.DataCollatorWithPadding[[transformers.DataCollatorWithPadding]]

```python
transformers.DataCollatorWithPadding(tokenizer: PreTrainedTokenizerBase, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, return_tensors: str = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L191)

**Parametreler:**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) veya [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend)) : Verileri kodlamak için kullanılan tokenizer.

padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/v5.23.0/tr/internal/file_utils#transformers.utils.PaddingStrategy), *opsiyonel*, varsayılan `True`) : Dönen dizilerin dolgusunu (modelin dolgu yönüne ve dolgu indeksine göre) aşağıdakilerden birini seçerek belirleyin: - `True` veya `'longest'` (varsayılan): Batch'teki en uzun diziye kadar dolgu yapın (yalnızca tek bir dizi sağlanırsa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kadar dolgu yapın. - `False` veya `'do_not_pad'`: Dolgu yok (yani, farklı uzunluklarda dizilere sahip bir batch çıktı olarak verilebilir).

max_length (`int`, *isteğe bağlı*) : Dönen listenin maksimum uzunluğu ve isteğe bağlı dolgu uzunluğu (bkz. yukarıda).

pad_to_multiple_of (`int`, *isteğe bağlı*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği >= 7.0 (Volta) olan NVIDIA donanımlarında Tensor Core kullanımını etkinleştirmek için özellikle faydalıdır.

return_tensors (`str`, *isteğe bağlı*, varsayılan `"pt"`) : Dönülecek Tensor türü. Kabul edilen değerler "np" veya "pt" şeklindedir.

Alınan girdileri dinamik olarak dolduracak veri toplayıcı.

## DataCollatorForTokenClassification[[transformers.DataCollatorForTokenClassification]]

#### transformers.DataCollatorForTokenClassification[[transformers.DataCollatorForTokenClassification]]

```python
transformers.DataCollatorForTokenClassification(tokenizer: PreTrainedTokenizerBase, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, label_pad_token_id: int = -100, return_tensors: str = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L243)

**Parametreler:**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) veya [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend)) : Verileri kodlamak için kullanılan tokenizer.

padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/v5.23.0/tr/internal/file_utils#transformers.utils.PaddingStrategy), *opsiyonel*, varsayılan `True`) : Dönen dizilerin dolgusunu (modelin dolgu yönüne ve dolgu indeksine göre) aşağıdakilerden birini seçerek belirleyin: - `True` veya `'longest'` (varsayılan): Batch'teki en uzun diziye kadar dolgu yapın (yalnızca tek bir dizi sağlanırsa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kadar dolgu yapın. - `False` veya `'do_not_pad'`: Dolgu yok (yani, farklı uzunluklarda dizilere sahip bir batch çıktı olarak verilebilir).

max_length (`int`, *isteğe bağlı*) : Dönen listenin maksimum uzunluğu ve isteğe bağlı dolgu uzunluğu (bkz. yukarıda).

pad_to_multiple_of (`int`, *isteğe bağlı*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği >= 7.0 (Volta) olan NVIDIA donanımlarında Tensor Core kullanımını etkinleştirmek için özellikle faydalıdır.

label_pad_token_id (`int`, *isteğe bağlı*, varsayılan -100) : Etiketleri doldururken kullanılacak kimlik (PyTorch kayıp fonksiyonları -100 değerini otomatik olarak yoksayar).

return_tensors (`str`, *isteğe bağlı*, varsayılan `"pt"`) : Dönülecek Tensor türü. Kabul edilen değerler "np" veya "pt" şeklindedir.

Alınan girdileri ve etiketleri dinamik olarak dolduracak (pad) veri toplayıcı (data collator).

## DataCollatorForSeq2Seq[[transformers.DataCollatorForSeq2Seq]]

#### transformers.DataCollatorForSeq2Seq[[transformers.DataCollatorForSeq2Seq]]

```python
transformers.DataCollatorForSeq2Seq(tokenizer: PreTrainedTokenizerBase, model: typing.Any | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, label_pad_token_id: int = -100, return_tensors: str = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L491)

**Parametreler:**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) veya [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend)) : Verileri kodlamak için kullanılan tokenizer.

model ([PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel), *opsiyonel*) : Eğitilen model. Ayarlanmışsa ve *prepare_decoder_input_ids_from_labels* içeriyorsa, *decoder_input_ids* hazırlamak için kullanılır. Bu, *label_smoothing* kullanılırken kaybın iki kez hesaplanmasını önlemek için faydalıdır.

padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/v5.23.0/tr/internal/file_utils#transformers.utils.PaddingStrategy), *opsiyonel*, varsayılan `True`) : Dönen dizilerin dolgusunu (modelin dolgu yönüne ve dolgu indeksine göre) aşağıdakilerden birini seçerek belirleyin: - `True` veya `'longest'` (varsayılan): Batch'teki en uzun diziye kadar dolgu yapın (yalnızca tek bir dizi sağlanırsa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kadar dolgu yapın. - `False` veya `'do_not_pad'`: Dolgu yok (yani, farklı uzunluklarda dizilere sahip bir batch çıktı olarak verilebilir).

max_length (`int`, *isteğe bağlı*) : Dönen listenin maksimum uzunluğu ve isteğe bağlı dolgu uzunluğu (bkz. yukarıda).

pad_to_multiple_of (`int`, *isteğe bağlı*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği >= 7.0 (Volta) olan NVIDIA donanımlarında Tensor Core kullanımını etkinleştirmek için özellikle faydalıdır.

label_pad_token_id (`int`, *opsiyonel*, varsayılan -100) : Etiketleri doldururken kullanılacak kimlik (PyTorch kayıp fonksiyonları -100 değerini otomatik olarak yok sayar).

return_tensors (`str`, *isteğe bağlı*, varsayılan `"pt"`) : Dönülecek Tensor türü. Kabul edilen değerler "np" veya "pt" şeklindedir.

Alınan girdileri ve etiketleri dinamik olarak dolduracak (pad) veri toplayıcı (data collator).

## DataCollatorForLanguageModeling[[transformers.DataCollatorForLanguageModeling]]

#### transformers.DataCollatorForLanguageModeling[[transformers.DataCollatorForLanguageModeling]]

```python
transformers.DataCollatorForLanguageModeling(tokenizer: PreTrainedTokenizerBase, mlm: bool = True, whole_word_mask: bool = False, mlm_probability: float | None = 0.15, mask_replace_prob: float = 0.8, random_replace_prob: float = 0.1, pad_to_multiple_of: int | None = None, return_tensors: str = 'pt', seed: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L623)

**Parametreler:**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) veya [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend)) : Verileri kodlamak için kullanılan tokenizer.

mlm (`bool`, *isteğe bağlı*, varsayılan `True`) : Maskeli dil modellemesi kullanılıp kullanılmayacağını belirtir. `False` olarak ayarlanırsa, etiketler dolgu token'ları yok sayılarak (bunlar -100 olarak ayarlanarak) girdilerle aynı olur. Aksi halde, etiketler maskelenmemiş token'lar için -100, maskelenmiş token için ise tahmin edilecek değerdir.

whole_word_mask (`bool`, *isteğe bağlı*, varsayılan `False`) : Bireysel token'lar yerine tüm kelimelerin maskelenip maskelenmeyeceğini belirtir.

mlm_probability (`float`, *opsiyonel*, varsayılan 0.15) : `mlm` `True` olarak ayarlandığında, girdideki token'ları (rastgele) maskelemek için kullanılan olasılık.

mask_replace_prob (`float`, *isteğe bağlı*, varsayılan 0.8) : Maskelenmiş tokenların, tokenizer'ın mask token'ı (ör. `[MASK]`) ile değiştirilme olasılığı. Varsayılan değeri 0.8'dir; bu, maskelenmiş tokenların %80'inin `[MASK]` ile değiştirileceği anlamına gelir. Yalnızca `mlm` `True` olarak ayarlandığında çalışır.

random_replace_prob (`float`, *opsiyonel*, varsayılan 0.1) : Maskelenmiş tokenların, tokenizer sözlüğündeki rastgele tokenlarla değiştirilme olasılığı. Varsayılan değeri 0.1'dir; bu, maskelenmiş tokenların %10'unun rastgele tokenlarla değiştirileceği anlamına gelir. Kalan maskelenmiş tokenlar (1 - mask_replace_prob - random_replace_prob) değiştirilmeden bırakılır. Yalnızca `mlm` `True` olarak ayarlandığında çalışır.

pad_to_multiple_of (`int`, *isteğe bağlı*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur.

return_tensors (`str`) : Dönülecek Tensor türü. Kabul edilen değerler "np" veya "pt" şeklindedir.

seed (`int`, *opsiyonel*) : Maskeleme için rastgele sayı üretecinde kullanılacak tohum. Verilmezse, küresel RNG kullanılır.

Dil modelleme için kullanılan veri toplayıcı (data collator). Girdiler, hepsi aynı uzunlukta değilse, dinamik olarak bir partinin (batch) maksimum uzunluğuna kadar dolgu (padding) ile tamamlanır.

En iyi performans için, bu veri toplayıcısının, [PreTrainedTokenizer](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) veya `return_special_tokens_mask=True` argümanıyla bir [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend) tarafından döndürüldüğü gibi, `"special_tokens_mask"` anahtarına sahip sözlükler veya BatchEncoding öğelerine sahip bir veri setiyle kullanılması önerilir.

1. Varsayılan Davranış:
   - `mask_replace_prob=0.8`, `random_replace_prob=0.1`.
   - Maskelenmiş token'ların %80'inin `[MASK]` ile değiştirilmesini, %10'unun rastgele token'larla değiştirilmesini ve %10'unun değiştirilmemesini bekleyin.

2. `[MASK]` ile değiştirilen tüm maskelenmiş jetonlar:
   - `mask_replace_prob=1.0`, `random_replace_prob=0.0`.
   - Tüm maskelenmiş tokenların `[MASK]` ile değiştirilmesini bekleyin. Hiçbir token değiştirilmeden bırakılmaz veya rastgele tokenlarla değiştirilmez.

3. `[MASK]` ikamesi yok, yalnızca rastgele jetonlar:
   - `mask_replace_prob=0.0`, `random_replace_prob=1.0`.
   - Tüm maskelenmiş tokenların rastgele tokenlarla değiştirilmesini bekleyin. `[MASK]` yer değiştirmeleri veya değiştirilmemiş tokenlar yoktur.

4. Dengeli değiştirme:
   - `mask_replace_prob=0.5`, `random_replace_prob=0.4`.
   - Maskelenmiş token'ların %50'sinin `[MASK]` ile değiştirilmesini, %40'ının rastgele token'larla değiştirilmesini ve %10'unun değiştirilmemesini bekleyin.

Not: `mask_replace_prob` ile `random_replace_prob` değerlerinin toplamı 1'i aşmamalıdır. Toplam 1'den küçükse, kalan oran değiştirilmemiş maskelenmiş tokenlardan oluşur.

#### numpy_mask_tokens[[transformers.DataCollatorForLanguageModeling.numpy_mask_tokens]]

```python
numpy_mask_tokens(inputs: Any, special_tokens_mask: typing.Any | None = None, offset_mapping: typing.Any | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L894)

Maskeli dil modellemesi için maskeli jeton girdilerini/etiketlerini hazırlar.

#### torch_mask_tokens[[transformers.DataCollatorForLanguageModeling.torch_mask_tokens]]

```python
torch_mask_tokens(inputs: Any, special_tokens_mask: typing.Any | None = None, offset_mapping: typing.Any | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L800)

Maskeli dil modellemesi için maskeli jeton girdilerini/etiketlerini hazırlar.

## DataCollatorForPermutationLanguageModeling[[transformers.DataCollatorForPermutationLanguageModeling]]

#### transformers.DataCollatorForPermutationLanguageModeling[[transformers.DataCollatorForPermutationLanguageModeling]]

```python
transformers.DataCollatorForPermutationLanguageModeling(tokenizer: PreTrainedTokenizerBase, plm_probability: float = 0.16666666666666666, max_span_length: int = 5, return_tensors: str = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1032)

Permutasyon dil modellemesi için kullanılan veri toplayıcı.

- tensör gruplarını bir araya getirir, tokenizörün pad_token değerine saygı gösterir
- XLNet'e özgü prosedürlerle permütasyon dil modellemesi için partileri ön işler

#### numpy_mask_tokens[[transformers.DataCollatorForPermutationLanguageModeling.numpy_mask_tokens]]

```python
numpy_mask_tokens(inputs: Any)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1158)

Belirli bir dizi için tahmin edilecek maskelenmiş jetonlar aşağıdaki algoritma tarafından belirlenir:

0. Dizinin başlangıcından başlayın; `cur_len = 0` (şu ana kadar işlenen jeton sayısı) olarak ayarlayın.
1. `span_length` değerini `[1, max_span_length]` aralığından örnekleyin (maskelenecek token dizisinin uzunluğu)
2. Maskelenecek span'ı çevrelemek için `context_length = span_length / plm_probability` uzunluğunda bir bağlam ayırın
3. `start_index` başlangıç noktasını `[cur_len, cur_len + context_length - span_length]` aralığından örnekleyin ve `start_index:start_index + span_length` jetonlarını maskeleyin
4. `cur_len = cur_len + context_length` olarak ayarlayın. `cur_len < max_len` ise (yani işlenecek dizide kalan tokenlar varsa), 1. adımdan tekrarlayın.

#### torch_mask_tokens[[transformers.DataCollatorForPermutationLanguageModeling.torch_mask_tokens]]

```python
torch_mask_tokens(inputs: Any)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1059)

Belirli bir dizi için tahmin edilecek maskelenmiş jetonlar aşağıdaki algoritma tarafından belirlenir:

0. Dizinin başlangıcından başlayın; `cur_len = 0` (şu ana kadar işlenen jeton sayısı) olarak ayarlayın.
1. `span_length` değerini `[1, max_span_length]` aralığından örnekleyin (maskelenecek token dizisinin uzunluğu)
2. Maskelenecek span'ı çevrelemek için `context_length = span_length / plm_probability` uzunluğunda bir bağlam ayırın
3. `start_index` başlangıç noktasını `[cur_len, cur_len + context_length - span_length]` aralığından örnekleyin ve `start_index:start_index + span_length` jetonlarını maskeleyin
4. `cur_len = cur_len + context_length` olarak ayarlayın. `cur_len < max_len` ise (yani işlenecek dizide kalan tokenlar varsa), 1. adımdan tekrarlayın.

## DataCollatorWithFlattening[[transformers.DataCollatorWithFlattening]]

#### transformers.DataCollatorWithFlattening[[transformers.DataCollatorWithFlattening]]

```python
transformers.DataCollatorWithFlattening(*args, return_position_ids = True, separator_id = -100, return_flash_attn_kwargs = False, return_seq_idx = False, position_ids_start = 0, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1257)

**Parametreler:**

return_position_ids (`bool`, *isteğe bağlı*, varsayılan `True`) : Her düzleştirilmiş dizi için `position_ids_start` değerinden yeniden başlayan `position_ids` değerlerinin döndürülüp döndürülmeyeceğini belirtir.

separator_id (`int`, *opsiyonel*, varsayılan -100) : Birleştirilmiş `labels` içindeki dizileri ayırmak için kullanılan değer.

return_flash_attn_kwargs (`bool`, *isteğe bağlı*, varsayılan `False`) : FlashAttention tarafından kullanılan dizi sınırı kwargs'larını (`cu_seq_lens_q`, `cu_seq_lens_k`, `max_length_q` ve `max_length_k`) döndürüp döndürmeyeceğini belirtir.

return_seq_idx (`bool`, *isteğe bağlı*, varsayılan `False`) : Her token'ın ait olduğu diziyi gösteren `seq_idx`'in döndürülüp döndürülmeyeceğini belirtir.

position_ids_start (`int`, *opsiyonel*, varsayılan 0) : Her dizinin ilk token'ına verilen konum kimliği.

Doluksuz (padding free) yaklaşım için kullanılan veri toplayıcı (data collator). Şunları yapar:

- mini batch'in tamamını [1, total_tokens] biçiminde tek bir uzun diziye birleştirir
- `separator_id`, birleştirilmiş `labels` içindeki dizileri ayırmak için kullanılır; varsayılan değeri -100'dür
- dolgu eklenmez, varsayılan olarak `input_ids`, `labels` ve `position_ids` döndürülür
- FlashAttentionKwargs içindeki kwargs'yı isteğe bağlı olarak döndürür
- her bir token'ın hangi dizeye ait olduğunu gösteren seq_idx değerini isteğe bağlı olarak döndürür

`DataCollatorWithFlattening` kullanıldığında, tüm mini batch tek bir uzun diziye düzleştirilir. Dikkat (attention) hesabınızın bunu işleyebildiğinden emin olun!

Her model, position id'lerini kendisi hesapladığında konumları 0'dan numaralandırmaz. RoBERTa benzeri mimariler (mutlak konum gömme kullanan `roberta`, `xlm_roberta`, `camembert`, `mpnet` ve `esm` dahil) genellikle 2 olan `padding_idx + 1` değerinden başlar. Bu modellere varsayılan 0 tabanlı `position_ids` geçirildiğinde konum gömme kleri sessizce kayar ve çıktıları bozulur; bu nedenle bu modeller için `position_ids_start` değerini buna göre ayarlayın.

## DataCollatorForMultipleChoice[[transformers.DataCollatorForMultipleChoice]]

#### transformers.DataCollatorForMultipleChoice[[transformers.DataCollatorForMultipleChoice]]

```python
transformers.DataCollatorForMultipleChoice(tokenizer: PreTrainedTokenizerBase, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, return_tensors: str = 'pt')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L422)

**Parametreler:**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) veya [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/tr/main_classes/tokenizer#transformers.TokenizersBackend)) : Verileri kodlamak için kullanılan tokenizer.

padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/v5.23.0/tr/internal/file_utils#transformers.utils.PaddingStrategy), *isteğe bağlı*, varsayılan `True`) : Modelin dolgusu tarafına ve dolgu indeksine göre döndürülen dizileri doldurmak için bir strateji seçin:  - `True` veya `'longest'`: Batch'teki en uzun diziye kadar doldurun (yalnızca tek bir dizi sağlanırsa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa model için kabul edilebilir maksimum giriş uzunluğuna kadar doldurun. - `False` veya `'do_not_pad'` (varsayılan): Dolgu yok (yani, farklı uzunluklarda dizilere sahip bir batch döndürülebilir).

max_length (`int`, *isteğe bağlı*) : Dönen listenin maksimum uzunluğu ve isteğe bağlı dolgu uzunluğu (bkz. yukarıda).

pad_to_multiple_of (`int`, *isteğe bağlı*) : Diziyi, verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği >= 7.5 (Volta) olan NVIDIA donanımlarında Tensor Core kullanımını etkinleştirmek için özellikle faydalıdır.

return_tensors (`str`, *isteğe bağlı*, varsayılan `"pt"`) : Dönülecek Tensor türü. Kabul edilen değerler "np" veya "pt" şeklindedir.

Çoktan seçmeli sorular için iç içe geçmiş örneklerden oluşan bir partiyi dinamik olarak dolduran, böylece tüm örneklerin tüm seçeneklerinin aynı uzunlukta olmasını sağlayan veri toplayıcı (data collator).

