# JAX ile kullanma

Bu belge, `datasets` kütüphanesinin JAX ile kullanımına hızlı bir giriş niteliğindedir; odak noktası, veri setlerimizden `jax.Array` nesnelerini nasıl elde edeceğimiz ve bunları JAX modellerini eğitmek için nasıl kullanacağımızdır.

> [!TIP]
> Yukarıdaki kodu yeniden oluşturmak için `jax` ve `jaxlib` gereklidir, bu nedenle bunları `pip install datasets[jax]` olarak yüklediğinizden emin olun.

## Veri seti biçimi

Varsayılan olarak veri kümeleri, JAX yalnızca sayıları desteklediğinden ve dizge ile ikili nesneler değiştirilmeden bırakıldığından, düz Python nesneleri döndürür: tamsayılar, kayan noktalı sayılar, dizgeler, listeler vb.

Bunun yerine JAX dizilerini (numpy benzeri) almak için veri setinin biçimini `jax` olarak ayarlayabilirsiniz:

```py
>>> from datasets import Dataset
>>> data = [[1, 2], [3, 4]]
>>> ds = Dataset.from_dict({"data": data})
>>> ds = ds.with_format("jax")
>>> ds[0]
{'data': DeviceArray([1, 2], dtype=int32)}
>>> ds[:2]
{'data': DeviceArray([
    [1, 2],
    [3, 4]], dtype=int32)}
```

> [!TIP]
> Bir [Dataset](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Dataset) nesnesi, Arrow tablosunun bir sarmalayıcısıdır ve veri setindeki dizilerden JAX dizilerine hızlı okumalara olanak tanır.

Aynı prosedürün `DatasetDict` nesneleri için de geçerli olduğunu unutmayın; bu nedenle bir `DatasetDict`'in biçimi `jax` olarak ayarlandığında, içindeki tüm `Dataset`ler `jax` olarak biçimlendirilir:

```py
>>> from datasets import DatasetDict
>>> data = {"train": {"data": [[1, 2], [3, 4]]}, "test": {"data": [[5, 6], [7, 8]]}}
>>> dds = DatasetDict.from_dict(data)
>>> dds = dds.with_format("jax")
>>> dds["train"][:2]
{'data': DeviceArray([
    [1, 2],
    [3, 4]], dtype=int32)}
```

Dikkate almanız gereken bir diğer husus, biçimlendirmenin verileri gerçekten eriştiğinizde uygulanmasıdır. Dolayısıyla bir veri setinden bir JAX dizisi almak istiyorsanız, önce verilere erişmeniz gerekir; aksi takdirde biçim aynı kalır.

Son olarak, verileri tercih ettiğiniz cihaza yüklemek için `device` argümanını belirleyebilirsiniz; ancak `jaxlib.xla_extension.Device`, ne `pickle` ne de `dill` ile serileştirilebildiği için desteklenmez, bu nedenle bunun yerine dizge tanımlayıcısını kullanmanız gerekir:

```py
>>> import jax
>>> from datasets import Dataset
>>> data = [[1, 2], [3, 4]]
>>> ds = Dataset.from_dict({"data": data})
>>> device = str(jax.devices()[0])  # Not casting to `str` before passing it to `with_format` will raise a `ValueError`
>>> ds = ds.with_format("jax", device=device)
>>> ds[0]
{'data': DeviceArray([1, 2], dtype=int32)}
>>> ds[0]["data"].device()
TFRT_CPU_0
>>> assert ds[0]["data"].device() == jax.devices()[0]
True
```

`device` argümanı `with_format` işlevine sağlanmazsa, varsayılan olan `jax.devices()[0]` cihazının kullanılacağını unutmayın.

### N boyutlu diziler

Veri setiniz N boyutlu dizilerden oluşuyorsa, şekil sabit olduğunda varsayılan olarak bunların aynı tensör olarak ele alındığını göreceksiniz:

```py
>>> from datasets import Dataset
>>> data = [[[1, 2],[3, 4]], [[5, 6],[7, 8]]]  # fixed shape
>>> ds = Dataset.from_dict({"data": data})
>>> ds = ds.with_format("jax")
>>> ds[0]
{'data': Array([[1, 2],
        [3, 4]], dtype=int32)}
```

```py
>>> from datasets import Dataset
>>> data = [[[1, 2],[3]], [[4, 5, 6],[7, 8]]]  # varying shape
>>> ds = Dataset.from_dict({"data": data})
>>> ds = ds.with_format("jax")
>>> ds[0]
{'data': [Array([1, 2], dtype=int32), Array([3], dtype=int32)]}
```

Ancak bu mantık genellikle yavaş şekil karşılaştırmaları ve veri kopyalamaları gerektirir. Bunu önlemek için `Array` özellik türünü açıkça kullanmalı ve tensörlerinizin şeklini belirtmelisiniz:

```py
>>> from datasets import Dataset, Features, Array2D
>>> data = [[[1, 2],[3, 4]],[[5, 6],[7, 8]]]
>>> features = Features({"data": Array2D(shape=(2, 2), dtype='int32')})
>>> ds = Dataset.from_dict({"data": data}, features=features)
>>> ds = ds.with_format("jax")
>>> ds[0]
{'data': Array([[1, 2],
        [3, 4]], dtype=int32)}
>>> ds[:2]
{'data': Array([[[1, 2],
         [3, 4]],
 
        [[5, 6],
         [7, 8]]], dtype=int32)}
```

### Diğer özellik türleri

[ClassLabel](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.ClassLabel) verileri düzgün şekilde dizilere dönüştürülür:

```py
>>> from datasets import Dataset, Features, ClassLabel
>>> labels = [0, 0, 1]
>>> features = Features({"label": ClassLabel(names=["negative", "positive"])})
>>> ds = Dataset.from_dict({"label": labels}, features=features)
>>> ds = ds.with_format("jax")
>>> ds[:3]
{'label': DeviceArray([0, 0, 1], dtype=int32)}
```

JAX yalnızca sayıları desteklediği için string ve ikili nesneler değiştirilmez.

[Image](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Image) ve [Audio](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Audio) özellik türleri de desteklenir.

> [!TIP]
> [Image](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Image) özellik türünü kullanmak için `vision` ek paketini `pip install datasets[vision]` olarak yüklemeniz gerekir.

```py
>>> from datasets import Dataset, Features, Image
>>> images = ["path/to/image.png"] * 10
>>> features = Features({"image": Image()})
>>> ds = Dataset.from_dict({"image": images}, features=features)
>>> ds = ds.with_format("jax")
>>> ds[0]["image"].shape
(512, 512, 3)
>>> ds[0]
{'image': DeviceArray([[[ 255, 255, 255],
              [ 255, 255, 255],
              ...,
              [ 255, 255, 255],
              [ 255, 255, 255]]], dtype=uint8)}
>>> ds[:2]["image"].shape
(2, 512, 512, 3)
>>> ds[:2]
{'image': DeviceArray([[[[ 255, 255, 255],
              [ 255, 255, 255],
              ...,
              [ 255, 255, 255],
              [ 255, 255, 255]]]], dtype=uint8)}
```

> [!TIP]
> [Audio](/docs/datasets/v5.2.0/tr/package_reference/main_classes#datasets.Audio) özellik türünü kullanmak için `audio` ek paketini `pip install datasets[audio]` olarak yüklemeniz gerekir.

```py
>>> from datasets import Dataset, Features, Audio
>>> audio = ["path/to/audio.wav"] * 10
>>> features = Features({"audio": Audio()})
>>> ds = Dataset.from_dict({"audio": audio}, features=features)
>>> ds = ds.with_format("jax")
>>> ds[0]["audio"]["array"]
DeviceArray([-0.059021  , -0.03894043, -0.00735474, ...,  0.0133667 ,
              0.01809692,  0.00268555], dtype=float32)
>>> ds[0]["audio"]["sampling_rate"]
DeviceArray(44100, dtype=int32, weak_type=True)
```

## Veri yükleme

JAX yerleşik veri yükleme özelliklerine sahip değildir, bu nedenle verilerinizi [PyTorch](https://pytorch.org/) ile bir `DataLoader` veya [TensorFlow](https://www.tensorflow.org/) ile bir `tf.data.Dataset` kullanarak yüklemeniz gerekir. Bu konudaki [JAX dokümantasyonu](https://jax.readthedocs.io/en/latest/notebooks/Neural_Network_and_Data_Loading.html#data-loading-with-pytorch) şu ifadeleri kullanıyor: "JAX, program dönüşümlerine ve hızlandırıcı destekli NumPy'ye odaklanmıştır, bu nedenle JAX kütüphanesinde veri yükleme veya işleme bulunmaz. Zaten harika veri yükleyiciler mevcut, bu yüzden her şeyi yeniden icat etmek yerine onları kullanalım. PyTorch'un veri yükleyicisini alacağız ve NumPy dizileriyle çalışması için küçük bir shim oluşturacağız."

Bu nedenle `datasets` içindeki JAX biçimlendirme çok faydalıdır; çünkü veri yükleme kısmıyla uğraşmadan HuggingFace Hub'daki herhangi bir modeli JAX ile kullanmanızı sağlar.

### `with_format('jax')` kullanımı

Bir veri setinden JAX dizilerini çıkarmak için en kolay yol `with_format('jax')` yöntemini kullanmaktır. HuggingFace Hub'da https://huggingface.co/datasets/ylecun/mnist adresinde bulunan [MNIST veri seti](http://yann.lecun.com/exdb/mnist/) üzerinde bir sinir ağı eğitmek istediğimizi varsayalım.

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("ylecun/mnist")
>>> ds = ds.with_format("jax")
>>> ds["train"][0]
{'image': DeviceArray([[  0,   0,   0, ...],
                       [  0,   0,   0, ...],
                       ...,
                       [  0,   0,   0, ...],
                       [  0,   0,   0, ...]], dtype=uint8),
 'label': DeviceArray(5, dtype=int32)}
```

Biçim ayarlandıktan sonra, veri setini `Dataset.iter()` yöntemini kullanarak JAX modeline partiler halinde verebiliriz:

```py
>>> for epoch in range(epochs):
...     for batch in ds["train"].iter(batch_size=32):
...         x, y = batch["image"], batch["label"]
...         ...
```

