# Dataset ve IterableDataset arasındaki farklar

İki tür veri seti nesnesi vardır: [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) ve [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset). Kullanmayı veya oluşturmayı seçeceğiniz veri seti türü, veri setinin boyutuna bağlıdır. Genel olarak, [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset), tembel davranışı ve hız avantajları sayesinde büyük veri setleri (yüzlerce GB düşünün!) için idealdir; [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) ise her şey için harikadır. Bu sayfa, size uygun veri seti nesnesini seçmenize yardımcı olmak için [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) ile [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset) arasındaki farkları karşılaştıracaktır.

## İndirme ve akış

Düzenli bir [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) olduğunda, `my_dataset[0]` kullanarak erişebilirsiniz. Bu, satırlara rastgele erişim sağlar. Bu tür veri setlerine "map-style" veri setleri de denir. Örneğin, ImageNet-1k'yi şu şekilde indirip herhangi bir satıra erişebilirsiniz:

```python
from datasets import load_dataset

imagenet = load_dataset("timm/imagenet-1k-wds", split="train")  # downloads the full dataset
print(imagenet[0])
```

Ancak bir uyarı olarak, tüm veri setinin diskinizde veya bellekte saklanması gerekir; bu da diskten büyük veri setlerine erişmenizi engeller. Büyük veri setleri için bu durum pratik olmaktan çıkabildiğinden, [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset) adında başka bir veri seti türü mevcuttur. Bir `IterableDataset` kullandığınızda, veri seti üzerinde gezinirken verileri kademeli olarak yüklemek için bir `for` döngüsüyle erişebilirsiniz. Bu sayede belleğe yalnızca örneklerin küçük bir kısmı yüklenir ve diske hiçbir şey yazılmaz.

Örneğin, ImageNet-1k veri setini diske indirmeden akış olarak kullanabilirsiniz:

```python
from datasets import load_dataset

imagenet = load_dataset("timm/imagenet-1k-wds", split="train", streaming=True)  # will start loading the data when iterated over
for example in imagenet:
    print(example)
    break
```

Streaming, diske herhangi bir dosya yazmadan çevrimiçi verileri okuyabilir. Örneğin, [C4](https://huggingface.co/datasets/c4) veya [LAION-2B](https://huggingface.co/datasets/laion/laion2B-en) gibi her biri yüzlerce gigabayt olan birden fazla shard'tan oluşan veri setlerini stream edebilirsiniz. Bir veri setini nasıl stream edeceğinizi öğrenmek için [Dataset Streaming Guide](./stream)'a göz atın.

Ancak bu tek fark değildir; çünkü `IterableDataset`'in "tembel" davranışı, veri seti oluşturma ve işleme süreçlerinde de mevcuttur.

## Harita tarzı veri kümeleri ve yinelebilir veri kümeleri oluşturma

Listeler veya sözlükler kullanarak bir [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) oluşturabilirsiniz ve veri tamamen Arrow'a dönüştürüldüğü için herhangi bir satıra kolayca erişebilirsiniz:
```python
my_dataset = Dataset.from_dict({"col_1": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
print(my_dataset[0])
```

Öte yandan bir `IterableDataset` oluşturmak için verileri yüklemenin "tembel" (lazy) bir yolunu sağlamalısınız. Python'da bunun için genellikle jeneratör fonksiyonları kullanılır. Bu fonksiyonlar `yield` ile her seferinde bir örnek üretir; bu da bir `Dataset`'te olduğu gibi dilimleme (slicing) yoluyla bir satıra erişemeyeceğiniz anlamına gelir:
```python
def my_generator(n):
    for i in range(n):
        yield {"col_1": i}

my_iterable_dataset = IterableDataset.from_generator(my_generator, gen_kwargs={"n": 10})
for example in my_iterable_dataset:
    print(example)
    break
```

## Yerel dosyaların tamamen ve kademeli olarak yüklenmesi

Yerel veya uzaktaki veri dosyalarını [load_dataset()](/docs/datasets/v5.2.0/tr/package_reference/loading_methods#datasets.load_dataset) kullanarak Arrow [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset)'e dönüştürmek mümkündür:
```python
data_files = {"train": ["path/to/data.csv"]}
my_dataset = load_dataset("csv", data_files=data_files, split="train")
print(my_dataset[0])
```

Ancak bu, veri setiniz büyükse zaman ve disk alanı gerektiren CSV'den Arrow biçimine bir dönüştürme adımını zorunlu kılar.

Disk alanı tasarrufu sağlamak ve dönüştürme adımını atlamak için, yerel dosyalardan doğrudan akış yaparak bir `IterableDataset` tanımlayabilirsiniz. Bu şekilde, veri seti üzerinde gezinirken veriler yerel dosyalardan kademeli olarak okunur:

```python
data_files = {"train": ["path/to/data.csv"]}
my_iterable_dataset = load_dataset("csv", data_files=data_files, split="train", streaming=True)
for example in my_iterable_dataset:  # this reads the CSV file progressively as you iterate over the dataset
    print(example)
    break
```

CSV, JSONL ve Parquet gibi birçok dosya biçimi ile görüntü ve ses dosyaları desteklenir. [tablolar](./tabular_load), [metin](./nlp_load), [görüntü](./image_load) ve [ses](./audio_load]) veri kümelerini yükleme konusundaki ilgili kılavuzlarda daha fazla bilgi bulabilirsiniz.

## Eager veri işleme ve lazy veri işleme

Bir [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) nesnesini [Dataset.map()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset.map) ile işlediğinizde, tüm veri seti derhal işlenir ve döndürülür. Bu, örneğin `pandas`'ın çalışma şekline benzer.

```python
my_dataset = my_dataset.map(process_fn)  # process_fn is applied on all the examples of the dataset
print(my_dataset[0])
```

Öte yandan, `IterableDataset`'in "tembel" doğası gereği, [IterableDataset.map()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.map) çağrısı `map` fonksiyonunuzu tüm veri setine uygulamaz. Bunun yerine, `map` fonksiyonunuz anlık olarak uygulanır.

Bu nedenle, birden fazla işleme adımını zincirleyebilir ve veri kümesi üzerinde yinelemeye başladığınızda hepsi aynı anda çalışır:

```python
my_iterable_dataset = my_iterable_dataset.map(process_fn_1)
my_iterable_dataset = my_iterable_dataset.filter(filter_fn)
my_iterable_dataset = my_iterable_dataset.map(process_fn_2)

# process_fn_1, filter_fn and process_fn_2 are applied on-the-fly when iterating over the dataset
for example in my_iterable_dataset:  
    print(example)
    break
```

## Kesin ve hızlı yaklaşık karıştırma

Bir [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset)'i [Dataset.shuffle()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset.shuffle) ile karıştırdığınızda, veri setinin tam olarak karıştırılmasını uygularsınız. Bu, `[0, 1, 2, ... len(my_dataset) - 1]` dizin listesini alıp bu listeyi karıştırarak çalışır. Ardından, `my_dataset[0]`'e erişildiğinde, karıştırılmış dizin eşlemesinin ilk öğesi tarafından tanımlanan satır ve dizin döndürülür:
```python
my_dataset = my_dataset.shuffle(seed=42)
print(my_dataset[0])
```

`IterableDataset` durumunda satırlara rastgele erişim olmadığından, karıştırılmış bir indeks listesi kullanıp satıra keyfi bir konumdan erişemeyiz. Bu, kesin karıştırmanın kullanılmasını engeller. Bunun yerine, [IterableDataset.shuffle()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.shuffle) içinde hızlı bir yaklaşık karıştırma kullanılır. Bu yöntem, veri setinden örnekleri yinelemeli olarak rastgele örneklemek için bir karıştırma tamponu kullanır. Veri seti yinelemeli olarak okunduğu için mükemmel bir hız performansı sağlar:
```python
my_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100)
for example in my_iterable_dataset:
    print(example)
    break
```

Ancak bir karıştırma tamponu kullanmak, makine öğrenimi modeli eğitimi için tatmin edici bir karıştırma sağlamak için yeterli değildir. Bu nedenle [IterableDataset.shuffle()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.shuffle), veri setiniz birden fazla dosya veya kaynaktan oluşuyorsa veri seti parçalarını da karıştırır. Ayrıca, tamponu bir seferde en fazla `max_buffer_input_shards` parça kullanarak doldurur (varsayılan 10'dur) ve bu, karıştırma kalitesini büyük ölçüde artırır:

```python
# Stream from the internet
my_iterable_dataset = load_dataset("deepmind/code_contests", split="train", streaming=True)
my_iterable_dataset.num_shards  # 39

# Stream from local files
data_files = {"train": [f"path/to/data_{i}.csv" for i in range(1024)]}
my_iterable_dataset = load_dataset("csv", data_files=data_files, split="train", streaming=True)
my_iterable_dataset.num_shards  # 1024

# From a generator function
def my_generator(n, sources):
    for source in sources:
        for example_id_for_current_source in range(n):
            yield {"example_id": f"{source}_{example_id_for_current_source}"}

gen_kwargs = {"n": 10, "sources": [f"path/to/data_{i}" for i in range(1024)]}
my_iterable_dataset = IterableDataset.from_generator(my_generator, gen_kwargs=gen_kwargs)
my_iterable_dataset.num_shards  # 1024
```

> [!TIP]
>
> Veri setiniz az sayıda dosya içeriyorsa, karıştırma kalitesini artırmak için karıştırma işleminden önce [reshard()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.reshard) çağrısını yapabilirsiniz. Örneğin, Parquet veri setleri için bu işlem, her shard için tek dosya yerine satır gruplarını kullanarak yeniden shard'lar oluşturur ve karıştırma için çok daha fazla shard sağlar.

## Hız farkları

Düzenli [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) nesneleri, satırlara hızlı rastgele erişim sağlayan Arrow üzerine kuruludur. Bellek eşlemesi ve Arrow'un bellek içi bir format olması sayesinde, diskten veri okumak pahalı sistem çağrıları ve serileştirmeyi çözme işlemleri gerektirmez. `for` döngüsü kullanılarak devredildiğinde, ardışık Arrow kayıt toplulukları üzerinde gezinerek veri yükleme işlemini daha da hızlandırır.

Ancak [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) bir indeks eşlemesine sahip olduğunda (örneğin [Dataset.shuffle()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset.shuffle) ile), hız 10 kat yavaşlayabilir. Bunun nedeni, indeks eşlemesini kullanarak okunacak satır indeksini almak için ek bir adımın olması ve en önemlisi, artık ardışık veri bloklarını okumuyor olmanızdır. Hızı geri kazanmak için, indeks eşlemesini kaldıran [Dataset.flatten_indices()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset.flatten_indices) kullanarak tüm veri setini diskinize yeniden yazmanız gerekir. Ancak veri setinizin boyutuna bağlı olarak bu işlem çok zaman alabilir:

```python
my_dataset[0]  # fast
my_dataset = my_dataset.shuffle(seed=42)
my_dataset[0]  # up to 10x slower
my_dataset = my_dataset.flatten_indices()  # rewrite the shuffled dataset on disk as contiguous chunks of data
my_dataset[0]  # fast again
```

Bu durumda, [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset)'e geçmenizi ve hızlı yaklaşık karıştırma yöntemi olan [IterableDataset.shuffle()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.shuffle)'i kullanmanızı öneririz. Bu yöntem yalnızca shard sırasını karıştırır ve veri setinize bir karıştırma tamponu ekler; bu sayede veri setinizin hızı optimal kalır. Veri setini kolayca yeniden karıştırabilirsiniz:

```python
for example in enumerate(my_iterable_dataset):  # fast
    pass

shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100)

for example in enumerate(shuffled_iterable_dataset):  # as fast as before
    pass

shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=1337, buffer_size=100)  # reshuffling using another seed is instantaneous

for example in enumerate(shuffled_iterable_dataset):  # still as fast as before
    pass
```

Veri setinizi birden çok epoch üzerinde kullanıyorsanız, shuffle buffer içinde shard sırasını karıştırmak için kullanılan etkin tohum `seed + epoch`'tur. Bu, veri setinin epoch'lar arasında yeniden karıştırılmasını kolaylaştırır:
```python
for epoch in range(n_epochs):
    my_iterable_dataset.set_epoch(epoch)
    for example in my_iterable_dataset:  # fast + reshuffled at each epoch using `effective_seed = seed + epoch`
        pass
```

Harita tarzı bir veri setinin yinelemesini yeniden başlatmak için, ilk örnekleri atlayabilirsiniz:

```python
my_dataset = my_dataset.select(range(start_index, len(dataset)))
```

Ancak `DataLoader` kullanırken bir `Sampler` kullanıyorsanız, bunun yerine örnekleme biriminizin durumunu kaydetmelisiniz (devam etmeye izin veren özel bir örnekleme birimi yazmış olabilirsiniz).

Öte yandan, iterable veri kümeleri, kaldığı yerden devam etmek için belirli bir örnek dizinine rastgele erişim sağlamaz. Bunun yerine, modeller ve optimizörler için yapabildiğiniz gibi, bir kontrol noktasından devam etmek için [IterableDataset.state_dict()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.state_dict) ve [IterableDataset.load_state_dict()](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset.load_state_dict) kullanabilirsiniz:

```python
>>> iterable_dataset = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3)
>>> # save in the middle of training
>>> state_dict = iterable_dataset.state_dict()
>>> # and resume later
>>> iterable_dataset.load_state_dict(state_dict)
```

Arka planda, yinelebilir veri seti, okunan mevcut shard'i ve mevcut shard içindeki örnek dizinini takip eder ve bu bilgiyi `state_dict` içinde saklar.

Kontrol noktasından devam etmek için veri seti, önceki okunan tüm parçaları atlayarak mevcut parçadan yeniden başlar. Ardından parçayı okur ve kontrol noktasındaki tam örneğe ulaşana kadar örnekleri atlar.

Dolayısıyla bir veri setinin yeniden başlatılması oldukça hızlıdır, çünkü zaten üzerinde gezinilmiş olan parçaları yeniden okumaz. Yine de, bir veri setinin devam ettirilmesi genellikle anlık değildir; çünkü mevcut parçanın başından okumayı yeniden başlatıp, kontrol noktası konumuna ulaşana kadar örnekleri atlaması gerekir.

Bu, `torchdata` içindeki `StatefulDataLoader` ile kullanılabilir, bkz. [PyTorch DataLoader ile akış](./use_with_pytorch#stream-data).

## Harita stilinden yinelebilir stiline geçiş

Bir [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset)'in "tembel" davranışından veya hız avantajlarından yararlanmak istiyorsanız, map-stili [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset)'inizi bir [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset)'e dönüştürebilirsiniz:
```python
my_iterable_dataset = my_dataset.to_iterable_dataset()
```

Veri setinizi karıştırmak veya [PyTorch DataLoader ile kullanmak](./use_with_pytorch#stream-data) istiyorsanız, parçalı bir [IterableDataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.IterableDataset) oluşturmanızı öneririz:
```python
my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=1024)
my_iterable_dataset.num_shards  # 1024
```