# Kelas utama

## DatasetInfo[[datasets.DatasetInfo]]

#### datasets.DatasetInfo[[datasets.DatasetInfo]]

```python
datasets.DatasetInfo(description: str = <factory>, citation: str = <factory>, homepage: str = <factory>, license: str = <factory>, features: typing.Optional[datasets.features.features.Features] = None, post_processed: typing.Optional[datasets.info.PostProcessedInfo] = None, supervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = None, builder_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, version: typing.Union[str, datasets.utils.version.Version, NoneType] = None, splits: typing.Optional[datasets.splits.SplitDict] = None, download_checksums: typing.Optional[dict] = None, download_size: typing.Optional[int] = None, post_processing_size: typing.Optional[int] = None, dataset_size: typing.Optional[int] = None, size_in_bytes: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L92)

**Parameter:**

description (`str`) : Deskripsi dari dataset.

citation (`str`) : Kutipan BibTeX dari dataset.

homepage (`str`) : URL ke halaman utama resmi untuk dataset.

license (`str`) : Lisensi dataset. Bisa berupa nama lisensi atau paragraf yang berisi ketentuan lisensi.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur yang digunakan untuk menentukan tipe kolom dataset.

post_processed (`PostProcessedInfo`, *opsional*) : Tidak didukung lagi. Informasi mengenai sumber daya untuk pascapemrosesan dataset yang mungkin. Misalnya, dapat berisi informasi tentang indeks.

supervised_keys (`SupervisedKeysData`, *opsional*) : Menentukan fitur input dan label untuk pembelajaran terawasi jika berlaku untuk dataset (legacy dari TFDS).

builder_name (`str`, *opsional*) : Nama dari subclass `GeneratorBasedBuilder` yang digunakan untuk membuat dataset. Ini juga merupakan versi snake_case dari nama kelas pembangun dataset.

config_name (`str`, *opsional*) : Nama konfigurasi yang diturunkan dari [BuilderConfig](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.BuilderConfig).

version (`str` atau [Version](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.Version), *opsional*) : Versi dari dataset.

splits (`dict`, *opsional*) : Pemetaan antara nama split dan metadata.

download_checksums (`dict`, *opsional*) : Pemetaan antara URL untuk mengunduh checksum dataset dan metadata yang sesuai.

download_size (`int`, *opsional*) : Ukuran file yang akan diunduh untuk menghasilkan dataset, dalam byte.

post_processing_size (`int`, *opsional*) : Tidak didukung lagi. Ukuran dataset dalam byte setelah pascapemrosesan, jika ada.

dataset_size (`int`, *opsional*) : Ukuran gabungan dalam byte dari tabel Arrow untuk semua split.

size_in_bytes (`int`, *opsional*) : Ukuran gabungan dalam byte dari semua file yang terkait dengan dataset (file yang diunduh + file Arrow).

- ****config_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke [BuilderConfig](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.BuilderConfig) dan digunakan dalam [DatasetBuilder](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.DatasetBuilder).

Informasi tentang dataset.

`DatasetInfo` mendokumentasikan dataset, termasuk nama, versi, dan fiturnya. Lihat argumen konstruktor dan properti untuk daftar lengkap.

Tidak semua field diketahui saat konstruksi dan dapat diperbarui kemudian.

#### from_directory[[datasets.DatasetInfo.from_directory]]

```python
from_directory(dataset_info_dir: str, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L247)

**Parameter:**

dataset_info_dir (`str`) : Direktori yang berisi file metadata. Ini harus menjadi direktori root dari versi dataset tertentu.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

Buat [DatasetInfo](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetInfo) dari file JSON di `dataset_info_dir`.

Fungsi ini memperbarui semua field yang dihasilkan secara dinamis (num_examples, hash, waktu pembuatan,...) dari [DatasetInfo](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetInfo).

Hal ini akan menimpa semua metadata sebelumnya.

Contoh:

```py
>>> from datasets import DatasetInfo
>>> ds_info = DatasetInfo.from_directory("/path/to/directory/")
```

#### write_to_directory[[datasets.DatasetInfo.write_to_directory]]

```python
write_to_directory(dataset_info_dir, pretty_print = False, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L186)

**Parameter:**

dataset_info_dir (`str`) : Direktori tujuan.

pretty_print (`bool`, defaultnya `False`) : Jika `True`, JSON akan dicetak dengan rapi pada tingkat indentasi 4.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

Tulis `DatasetInfo` dan lisensi (jika ada) sebagai file JSON ke `dataset_info_dir`.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.info.write_to_directory("/path/to/directory/")
```

## Dataset[[datasets.Dataset]]

Kelas dasar [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) mengimplementasikan Dataset yang didukung oleh tabel Apache Arrow.

#### datasets.Dataset[[datasets.Dataset]]

```python
datasets.Dataset(arrow_table: Table, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_table: typing.Optional[datasets.table.Table] = None, fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L709)

Dataset yang didukung oleh tabel Arrow.

#### add_column[[datasets.Dataset.add_column]]

```python
add_column(name: str, column: typing.Union[list, numpy.ndarray], new_fingerprint: typing.Optional[str] = None, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure, NoneType] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6284)

**Parameter:**

name (`str`) : Nama kolom.

column (`list` atau `np.array`) : Data kolom yang akan ditambahkan.

feature (`FeatureType` atau `None`, defaultnya `None`) : Tipe data kolom.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Tambahkan kolom ke Dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> more_text = ds["text"]
>>> ds = ds.add_column(name="text_2", column=more_text)
>>> ds
Dataset({
    features: ['text', 'label', 'text_2'],
    num_rows: 1066
})
```

#### add_item[[datasets.Dataset.add_item]]

```python
add_item(item: dict, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6546)

**Parameter:**

item (`dict`) : Item data yang akan ditambahkan.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Tambahkan item ke Dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> new_review = {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'}
>>> ds = ds.add_item(new_review)
>>> ds[-1]
{'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'}
```

#### from_file[[datasets.Dataset.from_file]]

```python
from_file(filename: str, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_filename: typing.Optional[str] = None, in_memory: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L792)

**Parameter:**

filename (`str`) : Nama file dataset.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

indices_filename (`str`, *opsional*) : Nama file dari indeks.

in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Instansiasi Dataset yang didukung oleh tabel Arrow di filename.

#### from_buffer[[datasets.Dataset.from_buffer]]

```python
from_buffer(buffer: Buffer, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_buffer: typing.Optional[pyarrow.lib.Buffer] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L832)

**Parameter:**

buffer (`pyarrow.Buffer`) : buffer Arrow.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

indices_buffer (`pyarrow.Buffer`, *opsional*) : Indeks buffer Arrow.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Instansiasi Dataset yang didukung oleh buffer Arrow.

#### from_pandas[[datasets.Dataset.from_pandas]]

```python
from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L864)

**Parameter:**

df (`pandas.DataFrame`) : Dataframe yang berisi dataset.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

preserve_index (`bool`, *opsional*) : Apakah menyimpan indeks sebagai kolom tambahan dalam Dataset yang dihasilkan. Nilai default `None` akan menyimpan indeks sebagai kolom, kecuali untuk `RangeIndex` yang hanya disimpan sebagai metadata. Gunakan `preserve_index=True` untuk memaksa indeks disimpan sebagai kolom.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Konversi `pandas.DataFrame` menjadi `pyarrow.Table` untuk membuat [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset).

Tipe kolom dalam Arrow Table yang dihasilkan disimpulkan dari dtype dari `pandas.Series` dalam DataFrame. Untuk Series non-object, dtype NumPy diterjemahkan ke padanan Arrow-nya. Untuk `object`, kita perlu menebak tipe data dengan melihat objek Python dalam Series ini.

Perhatikan bahwa Series dengan dtype `object` tidak membawa informasi yang cukup untuk selalu menghasilkan tipe Arrow yang bermakna. Dalam kasus di mana tipe tidak dapat disimpulkan, misalnya karena DataFrame memiliki panjang 0 atau Series hanya berisi objek `None/nan`, tipe akan diatur ke `null`. Perilaku ini dapat dihindari dengan membuat fitur secara eksplisit dan meneruskannya ke fungsi ini.

Penting: dataset yang dibuat dengan from_pandas() berada di memori dan karenanya tidak memiliki direktori cache yang terkait. Hal ini mungkin berubah di masa depan, tetapi sementara itu, jika Anda ingin mengurangi penggunaan memori, Anda sebaiknya menuliskannya kembali ke disk dan memuatnya ulang menggunakan, misalnya, save_to_disk / load_from_disk.

Contoh:

```py
>>> ds = Dataset.from_pandas(df)
```

#### from_dict[[datasets.Dataset.from_dict]]

```python
from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L982)

**Parameter:**

mapping (`Mapping`) : Pemetaan string ke Array atau daftar Python.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

on_mixed_types (`Literal["use_json"]`, *opsional*, defaultnya `None`) : Jika "use_json", gunakan tipe Json() untuk field bertipe campuran, yaitu field tidak terstruktur yang berisi data tanpa skema yang didefinisikan sebelumnya. Dalam kasus ini, field dengan tipe campuran diatur ke Json(). Hal ini memungkinkan pemuatan daftar dengan campuran string/integer/float, misalnya, atau kamus dengan tipe nilai yang sewenang-wenang.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Konversi `dict` menjadi `pyarrow.Table` untuk membuat [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset).

Penting: dataset yang dibuat dengan from_dict() berada di memori dan karenanya tidak memiliki direktori cache yang terkait. Hal ini mungkin berubah di masa depan, tetapi sementara itu, jika Anda ingin mengurangi penggunaan memori, Anda sebaiknya menuliskannya kembali ke disk dan memuatnya ulang menggunakan, misalnya, save_to_disk / load_from_disk.

Contoh:

Dapatkan Dataset dari kamus yang berisi satu daftar per kolom:

```py
>>> ds = Dataset.from_dict({"text": ["hello there !", "general kenobi !"]})
```

Lewatkan fitur untuk mengatur tipe kolom, misalnya untuk dataset gambar:

```py
>>> features = Features({"image": Image()})
>>> ds = Dataset.from_dict({"image": ["path/to/image.png"]}, features=features)
```

Datasets didasarkan pada Arrow, yaitu format kolom, sehingga setiap contoh diharapkan memiliki tipe dan sub-tipe yang sama, serta kamus harus memiliki kunci dan tipe nilai yang sama. Memuat dataset akan menghasilkan error jika ada field dengan tipe yang tidak cocok, dan mengisi field yang hilang dalam kamus dengan None sehingga semua kamus memiliki kunci dan tipe nilai yang sama.

Untuk menghindari hal ini dan memungkinkan tipe campuran tanpa error, Anda dapat menggunakan `on_mixed_types="use_json"` atau menentukan `features=` dengan tipe [Json](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.Json):

```py
>>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]})
Traceback (most recent call last):
  ...
  File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status
pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64

>>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, on_mixed_types="use_json")
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]

>>> features = Features({"a": Json()})
>>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, features=features)
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]
```

Hal ini juga berguna untuk daftar kamus dengan kunci dan nilai yang sembarang, untuk menghindari pengisian bidang yang hilang dengan None:

```py
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]})
>>> ds.features
{'a': List({'b': Value('int64'), 'c': Value('int64')})}
>>> list(ds["a"])
[[{'b': 0, 'c': None}, {'b': None, 'c': 0}]]  # missing fields are filled with None

>>> features = Features({"a": List(Json())})
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features)
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK

>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json")
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK
```

Contoh lain dengan data pemanggilan alat:

```py
>>> messages = [
...     {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."},
...     {"role": "assistant", "tool_calls": [
...         {"type": "function", "function": {
...             "name": "control_light",
...             "arguments": {"room": "living room", "state": "on"}
...         }},
...         {"type": "function", "function": {
...             "name": "play_music",
...             "arguments": {"playlist": "electronic"}  # mixed-type here since keys ["playlist"] and ["room", "state"] are different
...         }}]
...     },
...     {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."},
...     {"role": "tool", "name": "play_music", "content": "The music is now playing."},
...     {"role": "assistant", "content": "Done!"}
... ]
>>> ds = Dataset.from_dict({"messages": [messages]}, on_mixed_types="use_json")
>>> ds.features
{'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})}
>>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"]
{"room": "living room", "state": "on"}
```

#### from_list[[datasets.Dataset.from_list]]

```python
from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1148)

**Parameter:**

mapping (`List[dict]`) : Daftar pemetaan string ke nilai baris.

features (`Features`, opsional) : Fitur dataset.

info (`DatasetInfo`, opsional) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, opsional) : Nama dari split dataset.

on_mixed_types (`Literal["use_json"]`, *opsional*, defaultnya `None`) : Jika "use_json", gunakan tipe Json() untuk field bertipe campuran, yaitu field tidak terstruktur yang berisi data tanpa skema yang didefinisikan sebelumnya. Dalam kasus ini, field dengan tipe campuran diatur ke Json(). Hal ini memungkinkan pemuatan daftar dengan campuran string/integer/float, misalnya, atau kamus dengan tipe nilai yang sewenang-wenang.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Konversi daftar dict menjadi `pyarrow.Table` untuk membuat [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)`

Perhatikan bahwa kunci dari entri pertama akan digunakan untuk menentukan kolom dataset, terlepas dari apa yang diteruskan ke features.

Penting: dataset yang dibuat dengan from_list() berada di memori dan karenanya tidak memiliki direktori cache yang terkait. Hal ini mungkin berubah di masa depan, tetapi sementara itu, jika Anda ingin mengurangi penggunaan memori, Anda sebaiknya menuliskannya kembali ke disk dan memuat ulang menggunakan, misalnya, save_to_disk / load_from_disk.

Contoh:

Dapatkan Dataset dari daftar yang berisi contoh:

```py
>>> ds = Dataset.from_list([{"text": "hello there !"}, {"text": "general kenobi !"}]})
```

Lewatkan fitur untuk mengatur tipe kolom, misalnya untuk dataset gambar:

```py
>>> features = Features({"image": Image()})
>>> ds = Dataset.from_list([{"image": "path/to/image.png"}], features=features)
```

Datasets didasarkan pada Arrow, yaitu format kolom, sehingga setiap contoh diharapkan memiliki tipe dan sub-tipe yang sama, serta kamus harus memiliki kunci dan tipe nilai yang sama. Memuat dataset akan menghasilkan error jika ada field dengan tipe yang tidak cocok, dan mengisi field yang hilang dalam kamus dengan None sehingga semua kamus memiliki kunci dan tipe nilai yang sama.

Untuk menghindari hal ini dan memungkinkan tipe campuran tanpa error, Anda dapat menggunakan `on_mixed_types="use_json"` atau menentukan `features=` dengan tipe [Json](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.Json):

```py
>>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}])
Traceback (most recent call last):
  ...
  File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status
pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64

>>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], on_mixed_types="use_json")
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]

>>> features = Features({"a": Json()})
>>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], features=features)
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]
```

Hal ini juga berguna untuk daftar kamus dengan kunci dan nilai yang sembarang, untuk menghindari pengisian bidang yang hilang dengan None:

```py
>>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}])
>>> ds.features
{'a': List({'b': Value('int64'), 'c': Value('int64')})}
>>> list(ds["a"])
[[{'b': 0, 'c': None}, {'b': None, 'c': 0}]]  # missing fields are filled with None

>>> features = Features({"a": List(Json())})
>>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], features=features)
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK

>>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], on_mixed_types="use_json")
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK
```

Contoh lain dengan data pemanggilan alat:

```py
>>> messages = [
...     {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."},
...     {"role": "assistant", "tool_calls": [
...         {"type": "function", "function": {
...             "name": "control_light",
...             "arguments": {"room": "living room", "state": "on"}
...         }},
...         {"type": "function", "function": {
...             "name": "play_music",
...             "arguments": {"playlist": "electronic"}  # mixed-type here since keys ["playlist"] and ["room", "state"] are different
...         }}]
...     },
...     {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."},
...     {"role": "tool", "name": "play_music", "content": "The music is now playing."},
...     {"role": "assistant", "content": "Done!"}
... ]
>>> ds = Dataset.from_list([{"messages": messages}], on_mixed_types="use_json")
>>> ds.features
{'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})}
>>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"]
{"room": "living room", "state": "on"}
```

#### from_generator[[datasets.Dataset.from_generator]]

```python
from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, gen_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, split: NamedSplit = NamedSplit('train'), fingerprint: typing.Optional[str] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1337)

**Parameter:**

generator ( --`Callable`): Fungsi generator yang `yields` contoh.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

gen_kwargs(`dict`, *opsional*) : Argumen kata kunci yang akan diteruskan ke callable `generator`. Anda dapat mendefinisikan dataset yang dipartisi dengan meneruskan daftar shard di `gen_kwargs` dan mengatur `num_proc` lebih besar dari 1.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Ini berguna jika dataset terdiri dari beberapa file. Multiprocessing dinonaktifkan secara default. Jika `num_proc` lebih besar dari satu, maka semua nilai list di `gen_kwargs` harus memiliki panjang yang sama. Nilai-nilai ini akan dipecah di antara panggilan ke generator. Jumlah shard akan menjadi nilai minimum dari list terpendek di `gen_kwargs` dan `num_proc`.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), defaultnya `Split.TRAIN`) : Nama split yang akan ditugaskan ke dataset.

fingerprint (`str`, *opsional*) : Sidik jari yang akan digunakan untuk menghasilkan ID dataset. Secara default, `fingerprint` dihasilkan dengan melakukan hashing pada fungsi generator dan semua argumen, yang dapat menjadi lambat jika menggunakan objek besar seperti model AI.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke :`GeneratorConfig`.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Buat Dataset dari generator.

Muat data dari generator, simpan data dalam format Arrow di disk, dan kembalikan Dataset dari data Arrow yang dipetakan ke memori di disk.

Contoh:

```py
>>> def gen():
...     yield {"text": "Good", "label": 0}
...     yield {"text": "Bad", "label": 1}
...
>>> ds = Dataset.from_generator(gen)
```

```py
>>> def gen(shards):
...     for shard in shards:
...         with open(shard) as f:
...             for line in f:
...                 yield {"line": line}
...
>>> shards = [f"data{i}.txt" for i in range(32)]
>>> ds = Dataset.from_generator(gen, gen_kwargs={"shards": shards})
```

#### data[[datasets.Dataset.data]]

```python
data()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2110)

Tabel Apache Arrow yang mendasari dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.data
MemoryMappedTable
text: string
label: int64
----
text: [["compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .","the soundtrack alone is worth the price of admission .","rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .","beneath the film's obvious determination to shock at any cost lies considerable skill and determination , backed by sheer nerve .","bielinsky is a filmmaker of impressive talent .","so beautifully acted and directed , it's clear that washington most certainly has a new career ahead of him if he so chooses .","a visual spectacle full of stunning images and effects .","a gentle and engrossing character study .","it's enough to watch huppert scheming , with her small , intelligent eyes as steady as any noir villain , and to enjoy the perfectly pitched web of tension that chabrol spins .","an engrossing portrait of uncompromising artists trying to create something original against the backdrop of a corporate music industry that only seems to care about the bottom line .",...,"ultimately , jane learns her place as a girl , softens up and loses some of the intensity that made her an interesting character to begin with .","ah-nuld's action hero days might be over .","it's clear why deuces wild , which was shot two years ago , has been gathering dust on mgm's shelf .","feels like nothing quite so much as a middle-aged moviemaker's attempt to surround himself with beautiful , half-naked women .","when the precise nature of matthew's predicament finally comes into sharp focus , the revelation fails to justify the build-up .","this picture is murder by numbers , and as easy to be bored by as your abc's , despite a few whopping shootouts .","hilarious musical comedy though stymied by accents thick as mud .","if you are into splatter movies , then you will probably have a reasonably good time with the salton sea .","a dull , simple-minded and stereotypical tale of drugs , death and mind-numbing indifference on the inner-city streets .","the feature-length stretch . . . strains the show's concept ."]]
label: [[1,1,1,1,1,1,1,1,1,1,...,0,0,0,0,0,0,0,0,0,0]]
```

#### cache_files[[datasets.Dataset.cache_files]]

```python
cache_files()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2130)

Berkas cache yang berisi tabel Apache Arrow yang mendasari dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.cache_files
[{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]
```

#### num_columns[[datasets.Dataset.num_columns]]

```python
num_columns()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2148)

Jumlah kolom dalam dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.num_columns
2
```

#### num_rows[[datasets.Dataset.num_rows]]

```python
num_rows()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2163)

Jumlah baris dalam dataset (sama dengan [Dataset.__len__()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.__len__)).

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.num_rows
1066
```

#### column_names[[datasets.Dataset.column_names]]

```python
column_names()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2180)

Nama kolom dalam dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.column_names
['text', 'label']
```

#### shape[[datasets.Dataset.shape]]

```python
shape()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2195)

Bentuk dataset (jumlah kolom, jumlah baris).

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.shape
(1066, 2)
```

#### unik[[datasets.Dataset.unique]]

```python
unique(column: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2212)

**Parameter:**

column (`str`) : Nama kolom (daftar semua nama kolom dengan [column_names](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.column_names)).

**Mengembalikan:** `list`

Daftar elemen unik di kolom yang diberikan.

Kembalikan daftar elemen unik dalam kolom.

Hal ini diimplementasikan di backend tingkat rendah dan karenanya, sangat cepat.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.unique('label')
[1, 0]
```

#### flatten[[datasets.Dataset.flatten]]

```python
flatten(new_fingerprint: typing.Optional[str] = None, max_depth = 16)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2318)

**Parameter:**

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Salinan dataset dengan kolom yang diratakan.

Ratakan tabel. Setiap kolom dengan tipe struct diratakan menjadi satu kolom per field struct. Kolom lainnya tidak diubah.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("rajpurkar/squad", split="train")
>>> ds.features
{'id': Value('string'),
 'title': Value('string'),
 'context': Value('string'),
 'question': Value('string'),
 'answers': {'text': List(Value('string')),
 'answer_start': List(Value('int32'))}}
>>> ds = ds.flatten()
>>> ds
Dataset({
    features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'],
    num_rows: 87599
})
```

#### cast[[datasets.Dataset.cast]]

```python
cast(features: Features, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, num_proc: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2365)

**Parameter:**

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features)) : Fitur baru untuk mengubah tipe dataset. Nama kolom dalam fitur harus sesuai dengan nama kolom saat ini. Tipe data juga harus dapat dikonversi dari satu tipe ke tipe lainnya. Untuk konversi yang tidak sederhana, misalnya `str` <-> `ClassLabel`, gunakan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.map) untuk memperbarui Dataset.

batch_size (`int`, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke cast. Jika `batch_size <= 0` atau `batch_size == None`, maka berikan seluruh dataset sebagai satu batch tunggal ke cast.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

load_from_cache_file (`bool`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan komputasi saat ini dari `function` dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

cache_file_name (`str`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan hasil komputasi alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.map).

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses untuk multiprocessing. Secara default, multiprocessing tidak digunakan.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Salinan dataset dengan fitur yang telah di-cast.

Cast dataset ke set fitur baru.

Contoh:

```py
>>> from datasets import load_dataset, ClassLabel, Value
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds.features.copy()
>>> new_features['label'] = ClassLabel(names=['bad', 'good'])
>>> new_features['text'] = Value('large_string')
>>> ds = ds.cast(new_features)
>>> ds.features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### cast_column[[datasets.Dataset.cast_column]]

```python
cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure], new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2449)

**Parameter:**

column (`str`) : Nama kolom.

feature (`FeatureType`) : Fitur target.

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Cast kolom ke fitur untuk decoding.

Contoh:

```py
>>> from datasets import load_dataset, ClassLabel
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good']))
>>> ds.features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('string')}
```

#### remove_columns[[datasets.Dataset.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2492)

**Parameter:**

column_names (`Union[str, List[str]]`) : Nama kolom yang akan dihapus.

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Salinan objek dataset tanpa kolom yang akan dihapus.

Hapus satu atau beberapa kolom dalam dataset beserta fitur yang terkait dengannya.

Anda juga dapat menghapus kolom menggunakan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.map) dengan `remove_columns`, tetapi metode yang ada tidak menyalin data dari kolom yang tersisa sehingga lebih cepat.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.remove_columns('label')
Dataset({
    features: ['text'],
    num_rows: 1066
})
>>> ds = ds.remove_columns(column_names=ds.column_names) # Removing all the columns returns an empty dataset with the `num_rows` property set to 0
Dataset({
    features: [],
    num_rows: 0
})
```

#### rename_column[[datasets.Dataset.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2547)

**Parameter:**

original_column_name (`str`) : Nama kolom yang akan diganti namanya.

new_column_name (`str`) : Nama baru untuk kolom.

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Salinan dataset dengan kolom yang namanya diubah.

Ganti nama kolom dalam dataset, dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.rename_column('label', 'label_new')
Dataset({
    features: ['text', 'label_new'],
    num_rows: 1066
})
```

#### rename_columns[[datasets.Dataset.rename_columns]]

```python
rename_columns(column_mapping: dict, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2613)

**Parameter:**

column_mapping (`Dict[str, str]`) : Pemetaan kolom untuk diubah namanya menjadi nama baru

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Salinan dataset dengan kolom yang namanya diubah

Ganti nama beberapa kolom dalam dataset, dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.rename_columns({'text': 'text_new', 'label': 'label_new'})
Dataset({
    features: ['text_new', 'label_new'],
    num_rows: 1066
})
```

#### select_columns[[datasets.Dataset.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2680)

**Parameter:**

column_names (`Union[str, List[str]]`) : Nama kolom yang akan dipertahankan.

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Salinan objek dataset yang hanya terdiri dari kolom-kolom yang dipilih.

Pilih satu atau beberapa kolom dalam dataset dan fitur yang terkait dengannya.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.select_columns(['text'])
>>> ds
Dataset({
    features: ['text'],
    num_rows: 1066
})
```

#### class_encode_column[[datasets.Dataset.class_encode_column]]

```python
class_encode_column(column: str, include_nulls: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2243)

**Parameter:**

column (`str`) : Nama kolom yang akan di-cast (daftar semua nama kolom dengan [column_names](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.column_names))

include_nulls (`bool`, defaultnya `False`) : Apakah akan menyertakan nilai null dalam label kelas. Jika `True`, nilai null akan dikodekan sebagai label kelas `"None"`.

Mencast kolom yang diberikan sebagai [ClassLabel](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.ClassLabel) dan memperbarui tabel.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("google/boolq", split="validation")
>>> ds.features
{'answer': Value('bool'),
 'passage': Value('string'),
 'question': Value('string')}
>>> ds = ds.class_encode_column('answer')
>>> ds.features
{'answer': ClassLabel(num_classes=2, names=['False', 'True']),
 'passage': Value('string'),
 'question': Value('string')}
```

#### __len__[[datasets.Dataset.__len__]]

```python
__len__()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2736)

Jumlah baris dalam dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.__len__
<bound method Dataset.__len__ of Dataset({
    features: ['text', 'label'],
    num_rows: 1066
})>
```

#### __iter__[[datasets.Dataset.__iter__]]

```python
__iter__()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2753)

Iterasi melalui contoh-contoh.

Jika format diatur dengan [Dataset.set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format), baris akan dikembalikan dengan format yang dipilih.

#### iter[[datasets.Dataset.iter]]

```python
iter(batch_size: int, drop_last_batch: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2782)

**Parameter:**

batch_size (`int`) : ukuran setiap batch yang dihasilkan.

drop_last_batch (`bool`, default *False*) : Apakah batch terakhir yang lebih kecil dari batch_size harus dibuang

Iterasi melalui batch berukuran *batch_size*.

Jika format diatur dengan [*~datasets.Dataset.set_format*], baris akan dikembalikan dengan format yang dipilih.

#### formatted_as[[datasets.Dataset.formatted_as]]

```python
formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2826)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti `__getitem__`` mengembalikan objek python (default).

columns (`List[str]`, *opsional*) : Kolom yang akan diformat dalam output. `None` berarti `__getitem__` mengembalikan semua kolom (default).

output_all_columns (`bool`, defaultnya `False`) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python).

- ****format_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang diteruskan ke fungsi konversi seperti `np.array`, `torch.tensor` atau `tensorflow.ragged.constant`.

Digunakan dalam pernyataan `with`. Atur format pengembalian `__getitem__` (tipe dan kolom).

#### set_format[[datasets.Dataset.set_format]]

```python
set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2858)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti `__getitem__` mengembalikan objek python (default).

columns (`List[str]`, *opsional*) : Kolom yang akan diformat dalam output. `None` berarti `__getitem__` mengembalikan semua kolom (default).

output_all_columns (`bool`, defaultnya `False`) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python).

- ****format_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang diteruskan ke fungsi konversi seperti `np.array`, `torch.tensor` atau `tensorflow.ragged.constant`.

Set format pengembalian `__getitem__` (tipe dan kolom). Pemformatan data diterapkan secara on-the-fly. Format `type` (misalnya "numpy") digunakan untuk memformat batch saat menggunakan `__getitem__`. Anda juga dapat menggunakan transform kustom untuk pemformatan dengan [set_transform()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_transform).

Memang memungkinkan untuk memanggil [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.map) setelah memanggil `set_format`. Karena `map` dapat menambahkan kolom baru, maka daftar kolom yang diformat

akan diperbarui. Dalam kasus ini, jika Anda menerapkan `map` pada dataset untuk menambahkan kolom baru, maka kolom ini akan diformat sebagai:

```
new formatted columns = (all columns - previously unformatted columns)
```

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds.set_format(type='numpy', columns=['text', 'label'])
>>> ds.format
{'type': 'numpy',
'format_kwargs': {},
'columns': ['text', 'label'],
'output_all_columns': False}
```

#### set_transform[[datasets.Dataset.set_transform]]

```python
set_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2966)

**Parameter:**

transform (`Callable`, *opsional*) : Transformasi format yang didefinisikan pengguna, menggantikan format yang didefinisikan oleh [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format). Fungsi format adalah callable yang menerima batch (sebagai `dict`) sebagai input dan mengembalikan batch. Fungsi ini diterapkan tepat sebelum mengembalikan objek di `__getitem__`.

columns (`List[str]`, *opsional*) : Kolom yang akan diformat dalam output. Jika ditentukan, maka batch input dari transform hanya berisi kolom-kolom tersebut.

output_all_columns (`bool`, defaultnya `False`) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python). Jika diatur ke True, maka kolom-kolom lain yang tidak diformat akan disimpan bersama output dari transform.

Set format pengembalian `__getitem__` menggunakan transform ini. Transform diterapkan secara on-the-fly pada batch saat `__getitem__` dipanggil. Seperti [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format), ini dapat direset menggunakan [reset_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.reset_format).

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
>>> def encode(batch):
...     return tokenizer(batch['text'], padding=True, truncation=True, return_tensors='pt')
>>> ds.set_transform(encode)
>>> ds[0]
{'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1]),
 'input_ids': tensor([  101, 29353,  2135, 15102,  1996,  9428, 20868,  2890,  8663,  6895,
         20470,  2571,  3663,  2090,  4603,  3017,  3008,  1998,  2037, 24211,
         5637,  1998, 11690,  2336,  1012,   102]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0])}
```

#### reset_format[[datasets.Dataset.reset_format]]

```python
reset_format()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2937)

Reset format pengembalian `__getitem__` ke objek python dan semua kolom.

Sama seperti `self.set_format()`

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds.set_format(type='numpy', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'])
>>> ds.format
{'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'numpy'}
>>> ds.reset_format()
>>> ds.format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': None}
```

#### with_format[[datasets.Dataset.with_format]]

```python
with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3009)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti `__getitem__` mengembalikan objek python (default).

columns (`List[str]`, *opsional*) : Kolom yang akan diformat dalam output. `None` berarti `__getitem__` mengembalikan semua kolom (default).

output_all_columns (`bool`, defaultnya `False`) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python).

- ****format_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang diteruskan ke fungsi konversi seperti `np.array`, `torch.tensor` atau `tensorflow.ragged.constant`.

Set format pengembalian `__getitem__` (tipe dan kolom). Pemformatan data diterapkan secara langsung. Format `type` (misalnya "numpy") digunakan untuk memformat batch saat menggunakan `__getitem__`.

Anda juga dapat menggunakan transform kustom untuk format menggunakan [with_transform()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.with_transform).

Berbeda dengan [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format), `with_format` mengembalikan objek [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds.format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': None}
>>> ds = ds.with_format("torch")
>>> ds.format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'torch'}
>>> ds[0]
{'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'label': tensor(1),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
        1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
        1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### with_transform[[datasets.Dataset.with_transform]]

```python
with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3080)

**Parameter:**

transform (`Callable`, `optional`) : Transformasi format yang didefinisikan pengguna, menggantikan format yang didefinisikan oleh [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format). Fungsi format adalah callable yang menerima batch (sebagai `dict`) sebagai input dan mengembalikan batch. Fungsi ini diterapkan tepat sebelum mengembalikan objek di `__getitem__`.

columns (`List[str]`, `optional`) : Kolom yang akan diformat dalam output. Jika ditentukan, maka batch input dari transform hanya berisi kolom-kolom tersebut.

output_all_columns (`bool`, defaultnya `False`) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python). Jika diatur ke `True`, maka kolom lain yang tidak diformat akan disimpan bersama output dari transform.

Set format return `__getitem__` menggunakan transform ini. Transform diterapkan secara on-the-fly pada batch saat `__getitem__` dipanggil.

Seperti [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format), ini dapat direset menggunakan [reset_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.reset_format).

Berbeda dengan [set_transform()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_transform), `with_transform` mengembalikan objek [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> def encode(example):
...     return tokenizer(example["text"], padding=True, truncation=True, return_tensors='pt')
>>> ds = ds.with_transform(encode)
>>> ds[0]
{'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1]),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
         1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
         1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0])}
```

#### __getitem__[[datasets.Dataset.__getitem__]]

```python
__getitem__(key)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3156)

Dapat digunakan untuk mengindeks kolom (dengan nama string) atau baris (dengan indeks integer atau iterable dari indeks atau bool).

#### cleanup_cache_files[[datasets.Dataset.cleanup_cache_files]]

```python
cleanup_cache_files()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3169)

**Mengembalikan:** `int`

Jumlah file yang dihapus.

Bersihkan semua file cache di direktori cache dataset, kecuali file cache yang sedang digunakan jika ada.

Hati-hati saat menjalankan perintah ini agar tidak ada proses lain yang sedang menggunakan file cache lainnya.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.cleanup_cache_files()
10
```

#### map[[datasets.Dataset.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json')
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3216)

**Parameter:**

function (`Callable`) : Fungsi dengan salah satu dari tanda tangan berikut: - `function(example: Dict[str, Any]) -> Dict[str, Any]` jika `batched=False` dan `with_indices=False` dan `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` jika `batched=False` dan `with_indices=True` dan/atau `with_rank=True` (satu argumen tambahan untuk masing-masing) - `function(batch: Dict[str, List]) -> Dict[str, List]` jika `batched=True` dan `with_indices=False` dan `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` jika `batched=True` dan `with_indices=True` dan/atau `with_rank=True` (satu argumen tambahan untuk masing-masing) Untuk penggunaan lanjutan, fungsi juga dapat mengembalikan `pyarrow.Table`. Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel. Selain itu, jika fungsi Anda tidak mengembalikan apa pun (`None`), maka `map` akan menjalankan fungsi Anda dan mengembalikan dataset tanpa perubahan. Jika tidak ada fungsi yang disediakan, gunakan fungsi identitas sebagai default: `lambda x: x`.

with_indices (`bool`, defaultnya `False`) : Menyediakan indeks contoh untuk `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx[, rank]): ...`.

with_rank (`bool`, defaultnya `False`) : Menyediakan peringkat proses ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example[, idx], rank): ...`.

input_columns (`Optional[Union[str, List[str]]]`, defaultnya `None`) : Kolom-kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, sebuah `dict` yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True`. Jika `batch_size <= 0` atau `batch_size == None`, berikan seluruh dataset sebagai satu batch ke `function`.

drop_last_batch (`bool`, defaultnya `False`) : Apakah batch terakhir yang lebih kecil dari batch_size harus dibuang alih-alih diproses oleh fungsi.

remove_columns (`Optional[Union[str, List[str]]]`, defaultnya `None`) : Menghapus pilihan kolom saat melakukan pemetaan. Kolom akan dihapus sebelum memperbarui contoh dengan output dari `function`, yaitu jika `function` menambahkan kolom dengan nama yang ada di `remove_columns`, kolom-kolom ini akan tetap dipertahankan.

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan komputasi saat ini dari `function` dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

cache_file_name (`str`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan hasil komputasi alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

features (`Optional[datasets.Features]`, defaultnya `None`) : Gunakan Features tertentu untuk menyimpan file cache alih-alih yang dihasilkan secara otomatis.

disable_nullable (`bool`, defaultnya `False`) : Larang nilai null dalam tabel.

fn_kwargs (`Dict`, *opsional*, defaultnya `None`) : Argumen kata kunci yang akan diteruskan ke `function`.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses yang digunakan untuk multiprocessing. - Jika `None` atau `0`, multiprocessing tidak digunakan dan operasi dijalankan di proses utama. - Jika lebih besar dari `1`, satu atau beberapa proses worker digunakan untuk memproses data secara paralel. Catatan: Fungsi yang diteruskan ke `map()` harus dapat di-pickle agar multiprocessing berfungsi dengan benar (yaitu, lebih baik gunakan fungsi yang didefinisikan di tingkat atas modul, bukan di dalam fungsi atau kelas lain). suffix_template (`str`): Jika `cache_file_name` ditentukan, maka sufiks ini akan ditambahkan di akhir nama dasar dari masing-masing. Defaultnya adalah `"_{rank:05d}_of_{num_proc:05d}"`. Misalnya, jika `cache_file_name` adalah "processed.arrow", maka untuk `rank=1` dan `num_proc=4`, file yang dihasilkan akan menjadi `"processed_00001_of_00004.arrow"` untuk sufiks default.

new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

desc (`str`, *opsional*, defaultnya `None`) : Deskripsi bermakna yang akan ditampilkan berdampingan dengan bilah progres saat memetakan contoh.

try_original_type (`Optional[bool]`, defaultnya `True`) : Berusaha mempertahankan tipe kolom asli (mis. int32 -> int32). Atur ke False jika Anda ingin selalu menyimpulkan tipe baru.

on_mixed_types (`Literal["use_json"]`, *opsional*, defaultnya `None`) : Jika "use_json", gunakan tipe Json() untuk field bertipe campuran, yaitu field tidak terstruktur yang berisi data tanpa skema yang didefinisikan sebelumnya. Dalam kasus ini, field dengan tipe campuran diatur ke Json(). Hal ini memungkinkan pemuatan daftar dengan campuran string/integer/float, misalnya, atau kamus dengan tipe nilai yang sewenang-wenang.

Terapkan fungsi ke semua contoh dalam tabel (secara individual atau dalam batch) dan perbarui tabel. Jika fungsi Anda mengembalikan kolom yang sudah ada, maka kolom tersebut akan ditimpa.

Anda dapat menentukan apakah fungsi harus di-batch atau tidak dengan parameter `batched`:

- Jika `False`, fungsi menerima 1 contoh dan harus mengembalikan 1 contoh. Contoh adalah kamus, misalnya `{"text": "Hello there !"}`.
- Jika `True` dan `batch_size` adalah 1, maka fungsi mengambil batch berisi 1 contoh sebagai input dan dapat mengembalikan batch berisi 1 atau lebih contoh. Batch adalah kamus, misalnya batch berisi 1 contoh adalah `{"text": ["Hello there !"]}`.
- Jika `True` dan `batch_size` adalah `n > 1`, maka fungsi tersebut mengambil batch berisi `n` contoh sebagai input dan dapat mengembalikan batch berisi `n` contoh, atau dengan jumlah contoh yang sembarang. Perhatikan bahwa batch terakhir mungkin memiliki kurang dari `n` contoh. Batch adalah kamus, misalnya batch berisi `n` contoh adalah `{"text": ["Hello there !"] * n}`.

Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel, dengan hingga seribu panggilan simultan. Disarankan untuk menggunakan `asyncio.Semaphore` di dalam fungsi Anda jika Anda ingin menetapkan jumlah maksimum operasi yang dapat berjalan pada saat yang sama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> def add_prefix(example):
...     example["text"] = "Review: " + example["text"]
...     return example
>>> ds = ds.map(add_prefix)
>>> ds[0:3]["text"]
['Review: compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'Review: the soundtrack alone is worth the price of admission .',
 'Review: rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .']

# process a batch of examples
>>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True)
# set number of processors
>>> ds = ds.map(add_prefix, num_proc=4)
```

#### filter[[datasets.Dataset.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4149)

**Parameter:**

function (`Callable`) : Callable dengan salah satu dari tanda tangan berikut: - `function(example: Dict[str, Any]) -> bool` jika `batched=False` dan `with_indices=False` dan `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` jika `batched=False` dan `with_indices=True` dan/atau `with_rank=True` (satu argumen tambahan untuk masing-masing) - `function(batch: Dict[str, List]) -> List[bool]` jika `batched=True` dan `with_indices=False` dan `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> List[bool]` jika `batched=True` dan `with_indices=True` dan/atau `with_rank=True` (satu argumen tambahan untuk masing-masing) Jika fungsi bersifat asinkron, maka `filter` akan menjalankan fungsi Anda secara paralel. Jika tidak ada fungsi yang diberikan, secara default menggunakan fungsi yang selalu `True`: `lambda x: True`.

with_indices (`bool`, defaultnya `False`) : Menyediakan indeks contoh untuk `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx[, rank]): ...`.

with_rank (`bool`, defaultnya `False`) : Menyediakan peringkat proses ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example[, idx], rank): ...`.

input_columns (`str` atau `List[str]`, *opsional*) : Kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, sebuah `dict` yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched = True`. Jika `batched = False`, satu contoh per batch diteruskan ke `function`. Jika `batch_size <= 0` atau `batch_size == None`, seluruh dataset diberikan sebagai satu batch ke `function`.

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan komputasi saat ini dari `function` dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

cache_file_name (`str`, *opsional*) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan hasil komputasi alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

fn_kwargs (`dict`, *opsional*) : Argumen kata kunci yang akan diteruskan ke `function`.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses yang digunakan untuk multiprocessing. - Jika `None` atau `0`, multiprocessing tidak digunakan dan operasi dijalankan di proses utama. - Jika lebih besar dari `1`, satu atau beberapa proses worker digunakan untuk memproses data secara paralel. Catatan: Fungsi yang diteruskan ke `map()` harus dapat di-pickle agar multiprocessing dapat bekerja dengan benar (yaitu, lebih disukai fungsi yang didefinisikan di tingkat atas modul, bukan di dalam fungsi atau kelas lain).

suffix_template (`str`) : Jika `cache_file_name` ditentukan, maka sufiks ini akan ditambahkan di akhir nama dasar dari masing-masing. Misalnya, jika `cache_file_name` adalah `"processed.arrow"`, maka untuk `rank = 1` dan `num_proc = 4`, file yang dihasilkan akan menjadi `"processed_00001_of_00004.arrow"` untuk sufiks default (default `_{rank:05d}_of_{num_proc:05d}`).

new_fingerprint (`str`, *opsional*) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

desc (`str`, *opsional*, defaultnya `None`) : Deskripsi bermakna yang akan ditampilkan berdampingan dengan bilah kemajuan saat memfilter contoh.

Terapkan fungsi filter pada semua elemen dalam tabel secara batch dan perbarui tabel sehingga dataset hanya mencakup contoh sesuai dengan fungsi filter.

Jika fungsi bersifat asinkron, maka `filter` akan menjalankan fungsi Anda secara paralel, dengan hingga seribu panggilan simultan (dapat dikonfigurasi). Disarankan untuk menggunakan `asyncio.Semaphore` di dalam fungsi Anda jika Anda ingin menetapkan jumlah maksimum operasi yang dapat berjalan pada saat yang sama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.filter(lambda x: x["label"] == 1)
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 533
})
```

#### pilih[[datasets.Dataset.select]]

```python
select(indices: Iterable, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4376)

**Parameter:**

indices (`range`, `list`, `iterable`, `ndarray` atau `Series`) : Rentang, daftar, atau array 1D berisi indeks integer untuk indexing. Jika indeks tersebut membentuk rentang yang berurutan, tabel Arrow cukup di-slice. Namun, jika Anda meneruskan daftar indeks yang tidak berurutan, maka akan dibuat pemetaan indeks, yang jauh kurang efisien, tetapi tetap lebih cepat daripada membuat ulang tabel Arrow yang terdiri dari baris yang diminta.

keep_in_memory (`bool`, defaultnya `False`) : Simpan pemetaan indeks di memori alih-alih menuliskannya ke file cache.

indices_cache_file_name (`str`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan pemetaan indeks alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

Buat dataset baru dengan baris yang dipilih mengikuti daftar/array indeks.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.select(range(4))
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 4
})
```

#### sort[[datasets.Dataset.sort]]

```python
sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4717)

**Parameter:**

column_names (`Union[str, Sequence[str]]`) : Nama kolom untuk diurutkan.

reverse (`Union[bool, Sequence[bool]]`, defaultnya `False`) : Jika `True`, urutkan berdasarkan urutan menurun, bukan menaik. Jika satu bool diberikan, nilai tersebut diterapkan pada pengurutan semua nama kolom. Sebaliknya, daftar bool dengan panjang dan urutan yang sama dengan column_names harus diberikan.

null_placement (`str`, defaultnya `at_end`) : Letakkan nilai `None` di awal jika `at_start` atau `first` atau di akhir jika `at_end` atau `last`

keep_in_memory (`bool`, defaultnya `False`) : Simpan indeks yang telah diurutkan di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan indeks terurut dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

indices_cache_file_name (`str`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan indeks yang telah diurutkan alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai yang lebih tinggi menghasilkan file cache yang lebih kecil, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit.

new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi

Buat dataset baru yang diurutkan berdasarkan satu atau beberapa kolom.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes', split='validation')
>>> ds['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> sorted_ds = ds.sort('label')
>>> sorted_ds['label'][:10]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False])
>>> another_sorted_ds['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```

#### shuffle[[datasets.Dataset.shuffle]]

```python
shuffle(seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4845)

**Parameter:**

seed (`int`, *opsional*) : Benih untuk menginisialisasi BitGenerator default jika `generator=None`. Jika `None`, maka entropi baru yang tidak dapat diprediksi akan diambil dari OS. Jika `int` atau `array_like[ints]` diberikan, maka nilai tersebut akan diteruskan ke SeedSequence untuk menurunkan keadaan awal BitGenerator.

generator (`numpy.random.Generator`, *opsional*) : Generator acak Numpy yang digunakan untuk menghitung permutasi baris dataset. Jika `generator=None` (default), menggunakan `np.random.default_rng` (BitGenerator default (PCG64) dari NumPy).

keep_in_memory (`bool`, default `False`) : Simpan indeks yang diacak di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan indeks acak dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

indices_cache_file_name (`str`, *opsional*) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan indeks yang diacak alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi.

Buat Dataset baru di mana barisnya diacak.

Saat ini, shuffling menggunakan generator acak numpy. Anda dapat menyediakan NumPy BitGenerator untuk digunakan, atau seed untuk menginisiasi generator acak default NumPy (PCG64).

Shuffling mengambil daftar indeks `[0:len(my_dataset)]` dan mengacaknya untuk membuat pemetaan indeks. Namun, begitu [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) Anda memiliki pemetaan indeks, kecepatannya bisa menjadi 10 kali lebih lambat. Hal ini terjadi karena ada langkah tambahan untuk mendapatkan indeks baris yang akan dibaca menggunakan pemetaan indeks, dan yang paling penting, Anda tidak lagi membaca potongan data yang berurutan. Untuk memulihkan kecepatan, Anda perlu menulis ulang seluruh dataset ke disk Anda menggunakan [Dataset.flatten_indices()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.flatten_indices), yang menghapus pemetaan indeks tersebut.

Namun, ini mungkin membutuhkan waktu yang lama tergantung pada ukuran dataset Anda:

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

Dalam kasus ini, kami merekomendasikan untuk beralih ke [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset) dan memanfaatkan metode pengacakan aproksimasi cepatnya [IterableDataset.shuffle()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.shuffle).

Fungsinya hanya mengacak urutan shard dan menambahkan buffer pengacakan ke dataset Anda, yang menjaga kecepatan dataset Anda tetap optimal:

```python
my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128)
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
```

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

# set a seed
>>> shuffled_ds = ds.shuffle(seed=42)
>>> shuffled_ds['label'][:10]
[1, 0, 1, 1, 0, 0, 0, 0, 0, 0]
```

#### lewati[[datasets.Dataset.skip]]

```python
skip(n: int)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4629)

**Parameter:**

n (`int`) : Jumlah elemen yang akan dilewati.

Buat [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru yang melewati `n` elemen pertama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> list(ds.take(3))
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'}]
>>> ds = ds.skip(1)
>>> list(ds.take(3))
[{'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'},
 {'label': 1,
 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}]
```

#### ambil[[datasets.Dataset.take]]

```python
take(n: int)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4691)

**Parameter:**

n (`int`) : Jumlah elemen yang diambil.

Buat [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru dengan hanya elemen pertama `n`.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> small_ds = ds.take(2)
>>> list(small_ds)
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}]
```

#### train_test_split[[datasets.Dataset.train_test_split]]

```python
train_test_split(test_size: typing.Union[float, int, NoneType] = None, train_size: typing.Union[float, int, NoneType] = None, shuffle: bool = True, stratify_by_column: typing.Optional[str] = None, seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, train_indices_cache_file_name: typing.Optional[str] = None, test_indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, train_new_fingerprint: typing.Optional[str] = None, test_new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4982)

**Parameter:**

test_size (`Union[float, int, None]`, *opsional*) : Ukuran split pengujian Jika `float`, harus berada di antara `0.0` dan `1.0` dan mewakili proporsi dataset yang akan dimasukkan ke dalam split pengujian. Jika `int`, mewakili jumlah absolut sampel pengujian. Jika `None`, nilainya diatur menjadi komplemen dari ukuran train. Jika `train_size` juga `None`, nilainya akan diatur ke `0.25`.

train_size (`Union[float, int, None]`, *opsional*) : Ukuran split latih. Jika `float`, nilainya harus berada di antara `0.0` dan `1.0` dan mewakili proporsi dataset yang akan dimasukkan ke dalam split latih. Jika `int`, mewakili jumlah absolut sampel latih. Jika `None`, nilai secara otomatis disetel menjadi komplemen dari ukuran test.

shuffle (`bool`, *opsional*, defaultnya `True`) : Apakah data akan diacak sebelum dipecah.

stratify_by_column (`str`, *opsional*, defaultnya `None`) : Nama kolom label yang akan digunakan untuk melakukan pemisahan stratifikasi data.

seed (`int`, *opsional*) : Benih untuk menginisialisasi BitGenerator default jika `generator=None`. Jika `None`, maka entropi baru yang tidak dapat diprediksi akan diambil dari OS. Jika `int` atau `array_like[ints]` diberikan, maka nilai tersebut akan diteruskan ke SeedSequence untuk menurunkan keadaan awal BitGenerator.

generator (`numpy.random.Generator`, *opsional*) : Generator acak Numpy yang digunakan untuk menghitung permutasi baris dataset. Jika `generator=None` (default), menggunakan `np.random.default_rng` (BitGenerator default (PCG64) dari NumPy).

keep_in_memory (`bool`, defaultnya `False`) : Simpan indeks split di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan indeks split dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

train_cache_file_name (`str`, *opsional*) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan indeks split train alih-alih nama file cache yang dihasilkan secara otomatis.

test_cache_file_name (`str`, *opsional*) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan indeks split pengujian alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

train_new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari set pelatihan setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi

test_new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari set pengujian setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi

Kembalikan sebuah kamus ([datasets.DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)) dengan dua subset acak untuk latih dan uji (`train` dan `test` `Dataset` splits). Splits dibuat dari dataset sesuai dengan `test_size`, `train_size` dan `shuffle`.

Metode ini mirip dengan `train_test_split` dari scikit-learn.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.train_test_split(test_size=0.2, shuffle=True)
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 852
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 214
    })
})

# set a seed
>>> ds = ds.train_test_split(test_size=0.2, seed=42)

# stratified split
>>> ds = load_dataset("stanfordnlp/imdb",split="train")
Dataset({
    features: ['text', 'label'],
    num_rows: 25000
})
>>> ds = ds.train_test_split(test_size=0.2, stratify_by_column="label")
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 20000
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 5000
    })
})
```

#### shard[[datasets.Dataset.shard]]

```python
shard(num_shards: int, index: int, contiguous: bool = True, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5265)

**Parameter:**

num_shards (`int`) : Berapa banyak shard untuk membagi dataset.

index (`int`) : Shard mana yang akan dipilih dan dikembalikan.

contiguous : (`bool`, defaultnya `True`): Apakah akan memilih blok indeks yang berurutan untuk shard.

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

indices_cache_file_name (`str`, *opsional*) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan indeks dari setiap shard alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Ini hanya menyangkut pemetaan indeks. Jumlah indeks per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

Kembalikan shard ke-`index` dari dataset yang dipecah menjadi `num_shards` bagian.

Ini melakukan pengacakan secara deterministik. `dataset.shard(n, i)` membagi dataset menjadi potongan-potongan yang berurutan, sehingga dapat dengan mudah digabungkan kembali setelah diproses. Jika `len(dataset) % n == l`, maka `l` dataset pertama masing-masing memiliki panjang `(len(dataset) // n) + 1`, dan dataset sisanya memiliki panjang `(len(dataset) // n)`. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` mengembalikan dataset dengan urutan yang sama seperti aslinya.

Catatan: n harus kurang dari atau sama dengan jumlah elemen dalam dataset `len(dataset)`.

Di sisi lain, `dataset.shard(n, i, contiguous=False)` berisi semua elemen dataset yang indeksnya mod `n = i`.

Pastikan untuk melakukan sharding sebelum menggunakan operator acak (seperti `shuffle`). Sebaiknya operator sharding digunakan di awal pipeline dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 1066
})
>>> ds = ds.shard(num_shards=2, index=0)
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 533
})
```

#### repeat[[datasets.Dataset.repeat]]

```python
repeat(num_times: int)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4659)

**Parameter:**

num_times (`int`) : Jumlah pengulangan dataset.

Buat [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru yang mengulang dataset dasar sebanyak `num_times` kali.

Seperti itertools.repeat, mengulang satu kali hanya mengembalikan dataset penuh.

Contoh:
```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> ds = ds.take(2).repeat(2)
>>> list(ds)
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'},
 {'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'}]
```

#### to_tf_dataset[[datasets.Dataset.to_tf_dataset]]

```python
to_tf_dataset(batch_size: typing.Optional[int] = None, columns: typing.Union[str, list[str], NoneType] = None, shuffle: bool = False, collate_fn: typing.Optional[typing.Callable] = None, drop_remainder: bool = False, collate_fn_args: typing.Optional[dict[str, typing.Any]] = None, label_cols: typing.Union[str, list[str], NoneType] = None, prefetch: bool = True, num_workers: int = 0, num_test_batches: int = 20)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L336)

**Parameter:**

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat dari dataset. Nilainya secara default adalah `None`, yang berarti dataset tidak akan di-batch, tetapi dataset yang dikembalikan dapat di-batch kemudian dengan `tf_dataset.batch(batch_size)`.

columns (`List[str]` atau `str`, *opsional*) : Kolom dataset yang akan dimuat ke dalam `tf.data.Dataset`. Nama kolom yang dibuat oleh `collate_fn` dan tidak ada di dataset asli dapat digunakan.

shuffle(`bool`, defaultnya `False`) : Mengacak urutan dataset saat dimuat. Disarankan `True` untuk pelatihan, `False` untuk validasi/evaluasi.

drop_remainder(`bool`, defaultnya `False`) : Buang batch terakhir yang tidak lengkap saat memuat. Memastikan bahwa semua batch yang dihasilkan oleh dataset memiliki panjang yang sama pada dimensi batch.

collate_fn(`Callable`, *opsional*) : Fungsi atau objek callable (seperti `DataCollator`) yang akan menggabungkan daftar sampel menjadi satu batch.

collate_fn_args (`Dict`, *opsional*) : Sebuah `dict` opsional berisi argumen kata kunci yang akan diteruskan ke `collate_fn`.

label_cols (`List[str]` atau `str`, defaultnya `None`) : Kolom dataset yang akan dimuat sebagai label. Perhatikan bahwa banyak model menghitung loss secara internal alih-alih membiarkan Keras melakukannya, sehingga dalam kasus tersebut, meneruskan label di sini bersifat opsional, selama label tersebut ada di `columns` input.

prefetch (`bool`, defaultnya `True`) : Apakah akan menjalankan dataloader di thread terpisah dan mempertahankan buffer kecil berisi batch untuk pelatihan. Meningkatkan kinerja dengan memungkinkan data dimuat di latar belakang saat model sedang dilatih.

num_workers (`int`, defaultnya `0`) : Jumlah worker yang digunakan untuk memuat dataset.

num_test_batches (`int`, defaultnya `20`) : Jumlah batch yang digunakan untuk menyimpulkan tanda tangan (signature) output dari dataset. Semakin tinggi angka ini, semakin akurat tanda tangannya, tetapi semakin lama waktu yang dibutuhkan untuk membuat dataset.

**Mengembalikan:**

`tf.data.Dataset`

Buat `tf.data.Dataset` dari Dataset yang mendasarinya. `tf.data.Dataset` ini akan memuat dan mengolasi batch dari Dataset, dan cocok untuk diteruskan ke metode seperti `model.fit()` atau `model.predict()`. Dataset akan menghasilkan `dicts` untuk input dan label, kecuali jika `dict` hanya berisi satu kunci, di mana sebuah `tf.Tensor` mentah akan dihasilkan sebagai gantinya.

Contoh:

```py
>>> ds_train = ds["train"].to_tf_dataset(
...    columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'],
...    shuffle=True,
...    batch_size=16,
...    collate_fn=data_collator,
... )
```

#### push_to_hub[[datasets.Dataset.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6092)

**Parameter:**

repo_id (`str`) : ID repositori tujuan push dalam format berikut: `<user>/<dataset_name>` atau `<org>/<dataset_name>`. Juga menerima `<dataset_name>`, yang secara default akan menggunakan namespace pengguna yang sedang login. Bisa juga berupa lokasi di dalam bucket, misalnya `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`, defaultnya "default") : Nama konfigurasi (atau subset) dari dataset. Defaultnya "default".

set_default (`bool`, *opsional*) : Apakah akan mengatur konfigurasi ini sebagai konfigurasi default. Jika tidak, konfigurasi default adalah yang bernama "default".

split (`str`, *opsional*) : Nama split yang akan diberikan ke dataset tersebut. Defaultnya adalah `self.split`.

data_dir (`str`, *opsional*) : Nama direktori yang akan berisi file data yang diunggah. Bawaan adalah `config_name` jika berbeda dari "default", jika tidak "data".

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan default ke `"Upload dataset"`.

commit_description (`str`, *opsional*) : Deskripsi dari commit yang akan dibuat. Selain itu, deskripsi dari PR jika PR dibuat (`create_pr` adalah True).

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat. Jika `None` (default), repo akan menjadi publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada.

token (`str`, *opsional*) : Token autentikasi opsional untuk Hugging Face Hub. Jika tidak ada token yang diteruskan, akan menggunakan token yang disimpan secara lokal saat login dengan `hf auth login`. Akan memicu error jika tidak ada token yang diteruskan dan pengguna tidak dalam keadaan login.

revision (`str`, *opsional*) : Cabang untuk mendorong file yang diunggah. Bawaan ke cabang `"main"`.

create_pr (`bool`, *opsional*, defaultnya `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit.

max_shard_size (`int` atau `str`, *opsional*, defaultnya `"500MB"`) : Ukuran maksimum shard dataset yang akan diunggah ke hub. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"5MB"`).

num_shards (`int`, *opsional*) : Jumlah shard yang akan ditulis. Secara default, jumlah shard bergantung pada `max_shard_size`.

embed_external_files (`bool`, defaultnya `True`) : Apakah akan menyematkan byte file ke dalam shard. Secara khusus, ini akan melakukan hal berikut sebelum push untuk field bertipe: - [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) dan [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image): menghapus informasi path lokal dan menyematkan konten file ke dalam file Parquet.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat menyiapkan dan mengunggah dataset. Ini berguna jika dataset terdiri dari banyak sampel atau file media untuk di-embed. I menggunakan konteks "spawn" untuk bekerja dengan hf_xet, klien rust untuk unggahan cepat ke HF. Multiprocessing dinonaktifkan secara default.

**Mengembalikan:**

huggingface_hub.CommitInfo

Mendorong dataset ke hub sebagai dataset Parquet. Dataset didorong menggunakan permintaan HTTP dan tidak memerlukan instalasi git atau git-lfs.

File Parquet yang dihasilkan bersifat mandiri secara bawaan. Jika dataset Anda berisi data [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) atau [Video](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Video), file Parquet akan menyimpan byte dari file gambar atau audio Anda. Anda dapat menonaktifkan ini dengan mengatur `embed_external_files` ke `False`.

Contoh:

```python
>>> dataset.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)
```

Jika dataset Anda memiliki beberapa split (misalnya train/validation/test):

```python
>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train")
>>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation")
>>> # later
>>> dataset = load_dataset("<organization>/<dataset_id>")
>>> train_dataset = dataset["train"]
>>> val_dataset = dataset["validation"]
```

Jika Anda ingin menambahkan konfigurasi baru (atau subset) ke dataset (misalnya jika dataset memiliki beberapa tugas/versi/bahasa):

```python
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")
```

#### save_to_disk[[datasets.Dataset.save_to_disk]]

```python
save_to_disk(dataset_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1781)

**Parameter:**

dataset_path (`path-like`) : Path (misalnya `dataset/train`) atau URI jarak jauh (misalnya `s3://my-bucket/dataset/train`) dari direktori dataset tempat dataset akan disimpan.

max_shard_size (`int` atau `str`, *opsional*, defaultnya `"500MB"`) : Ukuran maksimum dari shard dataset yang akan disimpan ke filesystem. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"50MB"`).

num_shards (`int`, *opsional*) : Jumlah shard yang akan ditulis. Secara default, jumlah shard bergantung pada `max_shard_size` dan `num_proc`.

num_proc (`int`, *opsional*) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Multiprocessing dinonaktifkan secara default.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

Menyimpan dataset ke direktori dataset, atau ke sistem file menggunakan implementasi apa pun dari `fsspec.spec.AbstractFileSystem`.

Untuk data [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) dan [Video](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Video):

Semua data Image(), Audio() dan Video() disimpan dalam file arrow. Jika Anda ingin menyimpan path atau url, silakan gunakan tipe Value("string").

Contoh:

```py
>>> ds.save_to_disk("path/to/dataset/directory")
>>> ds.save_to_disk("path/to/dataset/directory", max_shard_size="1GB")
>>> ds.save_to_disk("path/to/dataset/directory", num_shards=1024)
```

#### load_from_disk[[datasets.Dataset.load_from_disk]]

```python
load_from_disk(dataset_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1989)

**Parameter:**

dataset_path (`path-like`) : Path (misalnya `"dataset/train"`) atau URI jarak jauh (misalnya `"s3//my-bucket/dataset/train"`) dari direktori dataset tempat dataset akan dimuat.

keep_in_memory (`bool`, defaultnya `None`) : Apakah dataset akan disalin ke memori. Jika `None`, dataset tidak akan disalin ke memori kecuali secara eksplisit diaktifkan dengan mengatur `datasets.config.IN_MEMORY_MAX_SIZE` ke nilai bukan nol. Lihat detail lebih lanjut di bagian [improve performance](../cache#improve-performance).

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) atau [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

- Jika `dataset_path` adalah path dari direktori dataset, dataset yang diminta.
- Jika `dataset_path` adalah path dari direktori dataset dict, sebuah `datasets.DatasetDict` dengan setiap split.

Memuat dataset yang sebelumnya disimpan menggunakan `save_to_disk` dari direktori dataset, atau dari sistem file menggunakan implementasi apa pun dari `fsspec.spec.AbstractFileSystem`.

Contoh:

```py
>>> ds = load_from_disk("path/to/dataset/directory")
```

#### flatten_indices[[datasets.Dataset.flatten_indices]]

```python
flatten_indices(keep_in_memory: bool = False, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, num_proc: typing.Optional[int] = None, new_fingerprint: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4297)

**Parameter:**

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

cache_file_name (`str`, *opsional*, default `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan hasil komputasi alih-alih nama file cache yang dihasilkan secara otomatis.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

features (`Optional[datasets.Features]`, defaultnya `None`) : Gunakan [Features](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features) tertentu untuk menyimpan file cache alih-alih yang dihasilkan secara otomatis.

disable_nullable (`bool`, defaultnya `False`) : Mengizinkan nilai null dalam tabel.

num_proc (`int`, opsional, default `None`) : Jumlah maksimum proses saat menghasilkan cache. Shard yang sudah di-cache dimuat secara berurutan

new_fingerprint (`str`, *opsional*, defaultnya `None`) : Sidik jari baru dari dataset setelah transformasi. Jika `None`, sidik jari baru dihitung menggunakan hash dari sidik jari sebelumnya, dan argumen transformasi

Buat dan simpan Dataset baru dengan meratakan pemetaan indeks.

#### to_csv[[datasets.Dataset.to_csv]]

```python
to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5342)

**Parameter:**

path_or_buf (`PathLike` atau `FileOrBuffer`) : Baik berupa path ke file (mis. `file.csv`), URI jarak jauh (mis. `hf://datasets/username/my_dataset_name/data.csv`), atau BinaryIO, tempat dataset akan disimpan dalam format yang ditentukan.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

num_proc (`int`, *opsional*) : Jumlah proses untuk multiprocessing. Secara default, multiprocessing tidak digunakan. `batch_size` dalam kasus ini secara default adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`, tetapi silakan ubah menjadi 5x atau 10x dari nilai default jika Anda memiliki daya komputasi yang memadai.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

- ****to_csv_kwargs** (argumen kata kunci tambahan) : Parameter untuk diteruskan ke [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) dari pandas. Sekarang, `index` secara default menjadi `False` jika tidak ditentukan. Jika Anda ingin menulis indeks, teruskan `index=True` dan juga atur nama untuk kolom indeks dengan meneruskan `index_label`.

**Mengembalikan:** `int`

Jumlah karakter atau byte yang ditulis.

Mengekspor dataset ke csv

Contoh:

```py
>>> ds.to_csv("path/to/dataset/directory")
```

#### to_pandas[[datasets.Dataset.to_pandas]]

```python
to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5541)

**Parameter:**

batch_size (`int`, *opsional*) : Ukuran (jumlah baris) dari batch jika `batched` adalah `True`. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

batched (`bool`) : Setel ke `True` untuk mengembalikan generator yang menghasilkan dataset sebagai batch berisi `batch_size` baris. Defaultnya adalah `False` (mengembalikan seluruh dataset sekali).

**Mengembalikan:**

`pandas.DataFrame` atau `Iterator[pandas.DataFrame]`

Mengembalikan dataset sebagai `pandas.DataFrame`. Dapat juga mengembalikan generator untuk dataset besar.

Contoh:

```py
>>> ds.to_pandas()
```

#### to_dict[[datasets.Dataset.to_dict]]

```python
to_dict(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5401)

**Parameter:**

batch_size (`int`, *opsional*) : Ukuran (jumlah baris) dari batch jika `batched` adalah `True`. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

batched (`bool`) : Setel ke `True` untuk mengembalikan generator yang menghasilkan dataset sebagai batch berisi `batch_size` baris. Defaultnya adalah `False` (mengembalikan seluruh dataset sekali).

**Mengembalikan:**

`dict` atau `Iterator[dict]`

Mengembalikan dataset sebagai dict Python. Dapat juga mengembalikan generator untuk dataset besar.

Contoh:

```py
>>> ds.to_dict()
```

#### to_json[[datasets.Dataset.to_json]]

```python
to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5466)

**Parameter:**

path_or_buf (`PathLike` atau `FileOrBuffer`) : Baik berupa path ke file (mis. `file.json`), URI jarak jauh (mis. `hf://datasets/username/my_dataset_name/data.json`), atau BinaryIO, tempat dataset akan disimpan dalam format yang ditentukan.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

num_proc (`int`, *opsional*) : Jumlah proses untuk multiprocessing. Secara default, tidak menggunakan multiprocessing. `batch_size` dalam kasus ini secara default adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE` tetapi silakan ubah menjadi 5x atau 10x dari nilai default jika Anda memiliki daya komputasi yang memadai.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

- ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records".  <Changed version="2.11.0">  The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`.  If you would like to write the index, pass `index=True`.  

**Mengembalikan:** `int`

Jumlah karakter atau byte yang ditulis.

Ekspor dataset ke JSON Lines atau JSON.

Format output default adalah [JSON Lines](https://jsonlines.org/). Untuk mengekspor ke [JSON](https://www.json.org), berikan argumen `lines=False` dan `orient` yang diinginkan.

Contoh:

```py
>>> ds.to_json("path/to/dataset/directory/filename.jsonl")
```

#### to_parquet[[datasets.Dataset.to_parquet]]

```python
to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5643)

**Parameter:**

path_or_buf (`PathLike` atau `FileOrBuffer`) : Baik berupa path ke file (mis. `file.parquet`), URI remote (mis. `hf://datasets/username/my_dataset_name/data.parquet`), atau BinaryIO, tempat dataset akan disimpan dalam format yang ditentukan.

batch_size (`int`, *opsional*) : Ukuran batch yang dimuat ke memori dan ditulis sekaligus. Secara default, tujuannya adalah grup baris dengan ukuran byte tidak terkompresi maksimum "100MB", yang didefinisikan oleh `datasets.config.MAX_ROW_GROUP_SIZE`.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

- ****parquet_writer_kwargs** (argumen kata kunci tambahan) : Parameter untuk diteruskan ke `pyarrow.parquet.ParquetWriter` dari PyArrow.

**Mengembalikan:** `int`

Jumlah karakter atau byte yang ditulis.

Mengekspor dataset ke parquet

Contoh:

```py
>>> ds.to_parquet("path/to/dataset/directory")
```

#### to_sql[[datasets.Dataset.to_sql]]

```python
to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, **sql_writer_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5683)

**Parameter:**

name (`str`) : Nama tabel SQL.

con (`str` atau `sqlite3.Connection` atau `sqlalchemy.engine.Connection` atau `sqlalchemy.engine.Connection`) : String [URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) atau objek koneksi SQLite3/SQLAlchemy yang digunakan untuk menulis ke database.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

num_proc (`int`, *opsional*) : Jumlah proses untuk multiprocessing. Secara default, tidak menggunakan multiprocessing. `batch_size` dalam kasus ini secara default adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE` tetapi silakan ubah menjadi 5x atau 10x dari nilai default jika Anda memiliki daya komputasi yang memadai.

- ****sql_writer_kwargs** (argumen kata kunci tambahan) : Parameter untuk diteruskan ke [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) dari pandas.    Sekarang, `index` secara default menjadi `False` jika tidak ditentukan.  Jika Anda ingin menulis indeks, teruskan `index=True` dan juga atur nama untuk kolom indeks dengan meneruskan `index_label`.

**Mengembalikan:** `int`

Jumlah rekaman yang ditulis.

Mengekspor dataset ke basis data SQL.

Contoh:

```py
>>> # con provided as a connection URI string
>>> ds.to_sql("data", "sqlite:///my_own_db.sql")
>>> # con provided as a sqlite3 connection object
>>> import sqlite3
>>> con = sqlite3.connect("my_own_db.sql")
>>> with con:
...     ds.to_sql("data", con)
```

#### to_iterable_dataset[[datasets.Dataset.to_iterable_dataset]]

```python
to_iterable_dataset(num_shards: typing.Optional[int] = 1)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5781)

**Parameter:**

num_shards (`int`, default ke `1`) : Jumlah shard yang didefinisikan saat menginstansiasi dataset iterable. Ini sangat berguna untuk dataset besar agar shuffle dapat dilakukan dengan benar, dan juga untuk memungkinkan pemuatan paralel yang cepat menggunakan PyTorch DataLoader atau dalam setup terdistribusi, misalnya. Shard didefinisikan menggunakan [datasets.Dataset.shard()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.shard): ini hanya memotong data tanpa menulis apa pun ke disk.

**Mengembalikan:**

[datasets.IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Dapatkan [datasets.IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset) dari [datasets.Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) bergaya peta. Ini setara dengan memuat dataset dalam mode streaming dengan [datasets.load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset), tetapi jauh lebih cepat karena data dialirkan dari file lokal.

Berbeda dengan dataset bergaya peta, dataset iterable bersifat malas (lazy) dan hanya dapat diiterasi (misalnya menggunakan perulangan for). Karena dibaca secara berurutan dalam perulangan pelatihan, dataset iterable jauh lebih cepat daripada dataset bergaya peta. Semua transformasi yang diterapkan pada dataset iterable, seperti penyaringan atau pemrosesan, dilakukan secara langsung (on-the-fly) saat Anda mulai mengiterasi dataset tersebut.

Meskipun demikian, masih dimungkinkan untuk mengacak dataset iterable menggunakan [datasets.IterableDataset.shuffle()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.shuffle). Ini adalah pengacakan aproksimasi yang cepat dan bekerja paling baik jika Anda memiliki beberapa shard dan jika Anda menentukan ukuran buffer yang cukup besar.

Untuk mendapatkan performa kecepatan terbaik, pastikan dataset Anda tidak memiliki pemetaan indeks. Jika memang demikian, data tidak dibaca secara berurutan, yang terkadang dapat memperlambat proses. Anda dapat menggunakan `ds = ds.flatten_indices()` untuk menulis dataset Anda dalam potongan data yang berurutan dan memiliki kecepatan optimal sebelum beralih ke dataset iterable.

Contoh:

Penggunaan dasar:
```python
>>> ids = ds.to_iterable_dataset()
>>> for example in ids:
...     pass
```

Dengan penyaringan dan pemrosesan yang malas:
```python
>>> ids = ds.to_iterable_dataset()
>>> ids = ids.filter(filter_fn).map(process_fn)  # will filter and process on-the-fly when you start iterating over the iterable dataset
>>> for example in ids:
...     pass
```

Dengan sharding untuk memungkinkan pengacakan (shuffling) yang efisien:
```python
>>> ids = ds.to_iterable_dataset(num_shards=64)  # the dataset is split into 64 shards to be iterated over
>>> ids = ids.shuffle(buffer_size=10_000)  # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating
>>> for example in ids:
...     pass
```

Dengan PyTorch DataLoader:
```python
>>> import torch
>>> ids = ds.to_iterable_dataset(num_shards=64)
>>> ids = ids.filter(filter_fn).map(process_fn)
>>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4)  # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating
>>> for example in ids:
...     pass
```

Dengan PyTorch DataLoader dan pengacakan:
```python
>>> import torch
>>> ids = ds.to_iterable_dataset(num_shards=64)
>>> ids = ids.shuffle(buffer_size=10_000)  # will shuffle the shards order and use a shuffle buffer when you start iterating
>>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4)  # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating
>>> for example in ids:
...     pass
```

Dalam setup terdistribusi seperti PyTorch DDP dengan PyTorch DataLoader dan pengacakan

```python
>>> from datasets.distributed import split_dataset_by_node
>>> ids = ds.to_iterable_dataset(num_shards=512)
>>> ids = ids.shuffle(buffer_size=10_000, seed=42)  # will shuffle the shards order and use a shuffle buffer when you start iterating
>>> ids = split_dataset_by_node(ds, world_size=8, rank=0)  # will keep only 512 / 8 = 64 shards from the shuffled lists of shards when you start iterating
>>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4)  # will assign 64 / 4 = 16 shards from this node's list of shards to each worker when you start iterating
>>> for example in ids:
...     pass
```

Dengan pengacakan dan beberapa epoch:
```python
>>> ids = ds.to_iterable_dataset(num_shards=64)
>>> ids = ids.shuffle(buffer_size=10_000, seed=42)  # will shuffle the shards order and use a shuffle buffer when you start iterating
>>> for epoch in range(n_epochs):
...     ids.set_epoch(epoch)  # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating
...     for example in ids:
...         pass
```

Silakan juga gunakan `IterableDataset.set_epoch()` saat menggunakan PyTorch DataLoader atau dalam setup terdistribusi.

#### add_faiss_index[[datasets.Dataset.add_faiss_index]]

```python
add_faiss_index(column: str, index_name: typing.Optional[str] = None, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = <class 'numpy.float32'>)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6339)

**Parameter:**

column (`str`) : Kolom dari vektor yang akan ditambahkan ke indeks.

index_name (`str`, *opsional*) : `index_name`/pengenal dari indeks. Ini adalah `index_name` yang digunakan untuk memanggil [get_nearest_examples()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.get_nearest_examples) atau [search()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.search). Secara default, ini sesuai dengan `column`.

device (`Union[int, List[int]]`, *opsional*) : Jika bilangan bulat positif, ini adalah indeks GPU yang akan digunakan. Jika bilangan bulat negatif, gunakan semua GPU. Jika daftar bilangan bulat positif diberikan, jalankan hanya pada GPU tersebut. Secara default, menggunakan CPU.

string_factory (`str`, *opsional*) : Ini diteruskan ke pabrik indeks Faiss untuk membuat indeks. Kelas indeks default adalah `IndexFlat`.

metric_type (`int`, *opsional*) : Jenis metrik. Contoh: `faiss.METRIC_INNER_PRODUCT` atau `faiss.METRIC_L2`.

custom_index (`faiss.Index`, *opsional*) : Indeks Faiss kustom yang sudah Anda instansiasi dan konfigurasikan sesuai kebutuhan Anda.

batch_size (`int`) : Ukuran batch yang digunakan saat menambahkan vektor ke `FaissIndex`. Nilai default adalah `1000`.

train_size (`int`, *opsional*) : Jika indeks memerlukan langkah pelatihan, menentukan berapa banyak vektor yang akan digunakan untuk melatih indeks.

faiss_verbose (`bool`, defaultnya `False`) : Mengaktifkan tingkat detail (verbosity) dari indeks Faiss.

dtype (`data-type`) : dtype dari array numpy yang diindeks. Default adalah `np.float32`.

Tambahkan indeks padat menggunakan Faiss untuk pengambilan data yang cepat. Secara default, indeks dibuat berdasarkan vektor dari kolom yang ditentukan. Anda dapat menentukan `device` jika ingin menjalankannya di GPU (`device` harus berupa indeks GPU). Anda dapat menemukan informasi lebih lanjut tentang Faiss di sini:

- Untuk [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory)

Contoh:

```python
>>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train')
>>> ds_with_embeddings = ds.map(lambda example: {'embeddings': embed(example['line']}))
>>> ds_with_embeddings.add_faiss_index(column='embeddings')
>>> # query
>>> scores, retrieved_examples = ds_with_embeddings.get_nearest_examples('embeddings', embed('my new query'), k=10)
>>> # save index
>>> ds_with_embeddings.save_faiss_index('embeddings', 'my_index.faiss')

>>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train')
>>> # load index
>>> ds.load_faiss_index('embeddings', 'my_index.faiss')
>>> # query
>>> scores, retrieved_examples = ds.get_nearest_examples('embeddings', embed('my new query'), k=10)
```

#### add_faiss_index_from_external_arrays[[datasets.Dataset.add_faiss_index_from_external_arrays]]

```python
add_faiss_index_from_external_arrays(external_arrays: array, index_name: str, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = <class 'numpy.float32'>)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6419)

**Parameter:**

external_arrays (`np.array`) : Jika Anda ingin menggunakan array dari luar lib untuk indeks, Anda dapat mengatur `external_arrays`. Ini akan menggunakan `external_arrays` untuk membuat indeks Faiss alih-alih array di `column` yang diberikan.

index_name (`str`) : `index_name`/pengenal dari indeks. Ini adalah `index_name` yang digunakan untuk memanggil [get_nearest_examples()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.get_nearest_examples) atau [search()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.search).

device (Optional `Union[int, List[int]]`, *opsional*) : Jika bilangan bulat positif, ini adalah indeks GPU yang akan digunakan. Jika bilangan bulat negatif, gunakan semua GPU. Jika daftar bilangan bulat positif diberikan, jalankan hanya pada GPU tersebut. Secara default, menggunakan CPU.

string_factory (`str`, *opsional*) : Ini diteruskan ke pabrik indeks Faiss untuk membuat indeks. Kelas indeks default adalah `IndexFlat`.

metric_type (`int`, *opsional*) : Jenis metrik. Contoh: `faiss.faiss.METRIC_INNER_PRODUCT` atau `faiss.METRIC_L2`.

custom_index (`faiss.Index`, *opsional*) : Indeks Faiss kustom yang sudah Anda instansiasi dan konfigurasikan sesuai kebutuhan Anda.

batch_size (`int`, *opsional*) : Ukuran batch yang digunakan saat menambahkan vektor ke FaissIndex. Nilai default adalah 1000.

train_size (`int`, *opsional*) : Jika indeks memerlukan langkah pelatihan, menentukan berapa banyak vektor yang akan digunakan untuk melatih indeks.

faiss_verbose (`bool`, defaultnya False) : Mengaktifkan tingkat detail (verbosity) dari indeks Faiss.

dtype (`numpy.dtype`) : dtype dari array numpy yang diindeks. Default adalah np.float32.

Tambahkan indeks padat menggunakan Faiss untuk pengambilan data yang cepat. Indeks dibuat menggunakan vektor dari `external_arrays`. Anda dapat menentukan `device` jika ingin menjalankannya di GPU (`device` harus berupa indeks GPU). Anda dapat menemukan informasi lebih lanjut tentang Faiss di sini:

- Untuk [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory)

#### save_faiss_index[[datasets.Dataset.save_faiss_index]]

```python
save_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L535)

**Parameter:**

index_name (`str`) : index_name/identifier dari indeks. Ini adalah index_name yang digunakan untuk memanggil `.get_nearest` atau `.search`.

file (`str`) : Path ke indeks faiss yang telah diserialisasi di disk atau URI remote (mis. `"s3://my-bucket/index.faiss"`).

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

Simpan FaissIndex di disk.

#### load_faiss_index[[datasets.Dataset.load_faiss_index]]

```python
load_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], device: typing.Union[int, list[int], NoneType] = None, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L553)

**Parameter:**

index_name (`str`) : index_name/identifier dari indeks. Ini adalah index_name yang digunakan untuk memanggil `.get_nearest` atau `.search`.

file (`str`) : Path ke indeks faiss yang telah diserialisasi di disk atau URI remote (mis. `"s3://my-bucket/index.faiss"`).

device (Optional `Union[int, List[int]]`) : Jika bilangan bulat positif, ini adalah indeks GPU yang akan digunakan. Jika bilangan bulat negatif, gunakan semua GPU. Jika daftar bilangan bulat positif diberikan, jalankan hanya pada GPU tersebut. Secara default, menggunakan CPU.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

Muat FaissIndex dari disk.

Jika Anda ingin melakukan konfigurasi tambahan, Anda dapat mengakses objek indeks faiss dengan melakukan `.get_index(index_name).faiss_index` agar sesuai dengan kebutuhan Anda.

#### add_elasticsearch_index[[datasets.Dataset.add_elasticsearch_index]]

```python
add_elasticsearch_index(column: str, index_name: typing.Optional[str] = None, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = None, es_index_name: typing.Optional[str] = None, es_index_config: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6478)

**Parameter:**

column (`str`) : Kolom dari dokumen yang akan ditambahkan ke indeks.

index_name (`str`, *opsional*) : `index_name`/pengenal dari indeks. Ini adalah nama indeks yang digunakan untuk memanggil [get_nearest_examples()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.get_nearest_examples) atau [search()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.search). Secara default, ini sesuai dengan `column`.

host (`str`, *opsional*, defaultnya `localhost`) : Host tempat ElasticSearch berjalan.

port (`str`, *opsional*, defaultnya `9200`) : Port tempat ElasticSearch berjalan.

es_client (`elasticsearch.Elasticsearch`, *opsional*) : Klien elasticsearch yang digunakan untuk membuat indeks jika host dan port adalah `None`.

es_index_name (`str`, *opsional*) : Nama indeks elasticsearch yang digunakan untuk membuat indeks.

es_index_config (`dict`, *opsional*) : Konfigurasi dari indeks elasticsearch. Konfigurasi default adalah: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ```

Tambahkan indeks teks menggunakan ElasticSearch untuk pengambilan data yang cepat. Hal ini dilakukan secara in-place.

Contoh:

```python
>>> es_client = elasticsearch.Elasticsearch()
>>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train')
>>> ds.add_elasticsearch_index(column='line', es_client=es_client, es_index_name="my_es_index")
>>> scores, retrieved_examples = ds.get_nearest_examples('line', 'my new query', k=10)
```

#### load_elasticsearch_index[[datasets.Dataset.load_elasticsearch_index]]

```python
load_elasticsearch_index(index_name: str, es_index_name: str, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('Elasticsearch')] = None, es_index_config: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L637)

**Parameter:**

index_name (`str`) : `index_name`/pengenal dari indeks. Ini adalah nama indeks yang digunakan untuk memanggil `get_nearest` atau `search`.

es_index_name (`str`) : Nama indeks elasticsearch yang akan dimuat.

host (`str`, *opsional*, defaultnya `localhost`) : Host tempat ElasticSearch berjalan.

port (`str`, *opsional*, defaultnya `9200`) : Port tempat ElasticSearch berjalan.

es_client (`elasticsearch.Elasticsearch`, *opsional*) : Klien elasticsearch yang digunakan untuk membuat indeks jika host dan port adalah `None`.

es_index_config (`dict`, *opsional*) : Konfigurasi dari indeks elasticsearch. Konfigurasi default adalah: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ```

Muat indeks teks yang sudah ada menggunakan ElasticSearch untuk pengambilan data yang cepat.

#### list_indexes[[datasets.Dataset.list_indexes]]

```python
list_indexes()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L438)

Daftarkan `colindex_nameumns`/identitas dari semua indeks yang terlampir.

#### get_index[[datasets.Dataset.get_index]]

```python
get_index(index_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L442)

**Parameter:**

index_name (`str`) : Nama indeks.

**Mengembalikan:**

`BaseIndex`

Daftarkan `index_name`/identitas dari semua indeks yang terlampir.

#### drop_index[[datasets.Dataset.drop_index]]

```python
drop_index(index_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L684)

**Parameter:**

index_name (`str`) : `index_name`/pengenal dari indeks.

Hapus indeks dengan kolom yang ditentukan.

#### cari[[datasets.Dataset.search]]

```python
search(index_name: str, query: typing.Union[str, <built-in function array>], k: int = 10, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L693)

**Parameter:**

index_name (`str`) : Nama/identitas dari indeks.

query (`Union[str, np.ndarray]`) : Kueri sebagai string jika `index_name` adalah indeks teks atau sebagai array numpy jika `index_name` adalah indeks vektor.

k (`int`) : Jumlah contoh yang akan diambil.

**Mengembalikan:** `(scores, indices)`

Tuple dari `(scores, indices)` di mana:
- **scores** (`List[List[float]`): skor pengambilan dari FAISS (`IndexFlatL2` secara default) atau ElasticSearch untuk contoh yang diambil
- **indices** (`List[List[int]]`): indeks dari contoh yang diambil

Temukan indeks contoh terdekat dalam dataset terhadap kueri.

#### search_batch[[datasets.Dataset.search_batch]]

```python
search_batch(index_name: str, queries: typing.Union[list[str], <built-in function array>], k: int = 10, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L713)

**Parameter:**

index_name (`str`) : `index_name`/pengenal dari indeks.

queries (`Union[List[str], np.ndarray]`) : Kueri sebagai daftar string jika `index_name` adalah indeks teks atau sebagai array numpy jika `index_name` adalah indeks vektor.

k (`int`) : Jumlah contoh yang akan diambil per kueri.

**Mengembalikan:** `(total_scores, total_indices)`

Tuple dari `(total_scores, total_indices)` di mana:
- **total_scores** (`List[List[float]`): skor pengambilan dari FAISS (`IndexFlatL2` secara default) atau ElasticSearch untuk setiap contoh yang diambil per kueri
- **total_indices** (`List[List[int]]`): indeks dari contoh yang diambil per kueri

Temukan indeks contoh terdekat dalam dataset terhadap kueri.

#### get_nearest_examples[[datasets.Dataset.get_nearest_examples]]

```python
get_nearest_examples(index_name: str, query: typing.Union[str, <built-in function array>], k: int = 10, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L735)

**Parameter:**

index_name (`str`) : index_name/identifier dari indeks.

query (`Union[str, np.ndarray]`) : Kueri sebagai string jika `index_name` adalah indeks teks atau sebagai array numpy jika `index_name` adalah indeks vektor.

k (`int`) : Jumlah contoh yang akan diambil.

**Mengembalikan:** `(scores, examples)`

Tuple dari `(scores, examples)` di mana:
- **scores** (`List[float]`): skor pengambilan dari FAISS (`IndexFlatL2` secara default) atau ElasticSearch untuk contoh yang diambil
- **contoh** (`dict`): contoh yang diambil

Temukan contoh terdekat dalam dataset terhadap query.

#### get_nearest_examples_batch[[datasets.Dataset.get_nearest_examples_batch]]

```python
get_nearest_examples_batch(index_name: str, queries: typing.Union[list[str], <built-in function array>], k: int = 10, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L759)

**Parameter:**

index_name (`str`) : `index_name`/pengenal dari indeks.

queries (`Union[List[str], np.ndarray]`) : Kueri sebagai daftar string jika `index_name` adalah indeks teks atau sebagai array numpy jika `index_name` adalah indeks vektor.

k (`int`) : Jumlah contoh yang akan diambil per kueri.

**Mengembalikan:** `(total_scores, total_examples)`

Tuple dari `(total_scores, total_examples)` di mana:
- **total_scores** (`List[List[float]`): skor pengambilan dari FAISS (`IndexFlatL2` secara default) atau ElasticSearch untuk setiap contoh yang diambil per kueri
- **total_examples** (`List[dict]`): contoh yang diambil per kueri

Temukan contoh terdekat dalam dataset terhadap query.

#### info[[datasets.Dataset.info]]

```python
info()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172)

objek [DatasetInfo](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetInfo) yang berisi semua metadata dalam dataset.

#### split[[datasets.Dataset.split]]

```python
split()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177)

objek [NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit) yang sesuai dengan split dataset bernama.

#### builder_name[[datasets.Dataset.builder_name]]

```python
builder_name()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182)

#### sitasi[[datasets.Dataset.citation]]

```python
citation()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186)

#### config_name[[datasets.Dataset.config_name]]

```python
config_name()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190)

#### dataset_size[[datasets.Dataset.dataset_size]]

```python
dataset_size()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194)

#### deskripsi[[datasets.Dataset.description]]

```python
description()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198)

#### download_checksums[[datasets.Dataset.download_checksums]]

```python
download_checksums()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202)

#### download_size[[datasets.Dataset.download_size]]

```python
download_size()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206)

#### fitur[[datasets.Dataset.features]]

```python
features()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L785)

#### beranda[[datasets.Dataset.homepage]]

```python
homepage()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214)

#### lisensi[[datasets.Dataset.license]]

```python
license()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218)

#### size_in_bytes[[datasets.Dataset.size_in_bytes]]

```python
size_in_bytes()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222)

#### supervised_keys[[datasets.Dataset.supervised_keys]]

```python
supervised_keys()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226)

#### versi[[datasets.Dataset.version]]

```python
version()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230)

#### from_csv[[datasets.Dataset.from_csv]]

```python
from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1282)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Path dari file CSV.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), *opsional*) : Nama split yang akan ditugaskan ke dataset.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Ini berguna jika dataset terdiri dari beberapa file. Multiprocessing dinonaktifkan secara default.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `pandas.read_csv`.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Buat Dataset dari file CSV.

Baca file CSV, simpan data dalam format Arrow di disk, dan kembalikan Dataset dari data Arrow yang dipetakan ke memori di disk.

Contoh:

```py
>>> ds = Dataset.from_csv('path/to/dataset.csv')
```

#### from_json[[datasets.Dataset.from_json]]

```python
from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, num_proc: typing.Optional[int] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1422)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file JSON atau JSON Lines.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), *opsional*) : Nama split yang akan ditugaskan ke dataset.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

field (`str`, *opsional*) : Nama field dari file JSON tempat dataset tersebut berada.

num_proc (`int`, *opsional* defaultnya `None`) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Ini berguna jika dataset terdiri dari beberapa file. Multiprocessing dinonaktifkan secara default.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `JsonConfig`.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Buat Dataset dari file JSON atau JSON Lines.

Baca file JSON, simpan data dalam format Arrow di disk, dan kembalikan Dataset dari data Arrow yang dipetakan ke memori di disk.

Contoh:

```py
>>> ds = Dataset.from_json('path/to/dataset.json')
```

#### from_parquet[[datasets.Dataset.from_parquet]]

```python
from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, num_proc: typing.Optional[int] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1481)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file Parquet.

split (`NamedSplit`, *opsional*) : Nama split yang akan ditugaskan ke dataset.

features (`Features`, *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

columns (`List[str]`, *opsional*) : Jika bukan `None`, hanya kolom-kolom ini yang akan dibaca dari file. Nama kolom dapat berupa prefiks dari field bersarang, misalnya 'a' akan memilih 'a.b', 'a.c', dan 'a.d.e'.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Ini berguna jika dataset terdiri dari beberapa file. Multiprocessing dinonaktifkan secara default.

filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *opsional*) : Kembalikan hanya baris yang cocok dengan filter. Jika memungkinkan, predikat akan didorong ke bawah untuk memanfaatkan informasi partisi atau metadata internal yang ditemukan di sumber data, misalnya statistik Parquet. Jika tidak, filterkan RecordBatches yang dimuat sebelum menghasilkannya.

fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *opsional*) : Opsi khusus pemindaian untuk fragmen Parquet. Ini sangat berguna untuk mengatur buffering dan caching.

on_bad_files (`Literal["error", "warn", "skip"]`, *opsional*, defaultnya "error") : Tentukan tindakan yang dilakukan saat menemukan file yang rusak (file yang tidak dapat dibaca). Nilai yang diizinkan adalah : * 'error', lempar Exception saat menemukan file yang rusak. * 'warn', lempar peringatan saat menemukan file yang rusak dan lewati file tersebut. * 'skip', lewati file yang rusak tanpa lempar atau peringatan saat ditemukan.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `ParquetConfig`.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Buat Dataset dari file Parquet.

Baca file Parquet, simpan data dalam format Arrow di disk sebagai cache, dan kembalikan Dataset dari data Arrow yang dipetakan ke memori di disk.

Contoh:

```py
>>> ds = Dataset.from_parquet('path/to/dataset.parquet')
```

Muat subset kolom:

```python
>>> ds = Dataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"])
```

Saring data secara efisien, dengan kemungkinan melewati seluruh file atau grup baris:

```python
>>> filters = [("col_0", "==", 0)]
>>> ds = Dataset.from_parquet(parquet_files_list, filters=filters)
```

#### from_text[[datasets.Dataset.from_text]]

```python
from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1578)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file teks.

split (`NamedSplit`, *opsional*) : Nama split yang akan ditugaskan ke dataset.

features (`Features`, *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Ini berguna jika dataset terdiri dari beberapa file. Multiprocessing dinonaktifkan secara default.

keep_linebreaks : (`bool`, defaultnya False): Apakah akan mempertahankan baris baru.

sample_by (`Literal["line", "paragraph", "document"]`, defaultnya "line") : Apakah memuat data per baris, paragraf, atau dokumen. Secara default, satu baris dalam dataset = satu baris.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `TextConfig`.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Buat Dataset dari file teks.

Baca file teks, simpan data dalam format Arrow di disk, dan kembalikan Dataset dari data Arrow yang dipetakan ke memori di disk.

Contoh:

```py
>>> ds = Dataset.from_text('path/to/dataset.txt')
```

#### from_sql[[datasets.Dataset.from_sql]]

```python
from_sql(sql: typing.Union[str, ForwardRef('sqlalchemy.sql.Selectable')], con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1706)

**Parameter:**

sql (`str` atau `sqlalchemy.sql.Selectable`) : kueri SQL yang akan dieksekusi atau nama tabel.

con (`str` atau `sqlite3.Connection` atau `sqlalchemy.engine.Connection` atau `sqlalchemy.engine.Connection`) : [string URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) yang digunakan untuk membuat instans koneksi database atau objek koneksi SQLite3/SQLAlchemy.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `SqlConfig`.

**Mengembalikan:**

[Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset)

Buat Dataset dari kueri SQL atau tabel database.

Kueri basis data SQL, simpan data dalam format Arrow di disk, dan kembalikan Dataset dari data Arrow yang dipetakan ke memori di disk.

Contoh:

```py
>>> # Fetch a database table
>>> ds = Dataset.from_sql("test_data", "postgres:///db_name")
>>> # Execute a SQL query on the table
>>> ds = Dataset.from_sql("SELECT sentence FROM test_data", "postgres:///db_name")
>>> # Use a Selectable object to specify the query
>>> from sqlalchemy import select, text
>>> stmt = select([text("sentence")]).select_from(text("test_data"))
>>> ds = Dataset.from_sql(stmt, "postgres:///db_name")
```

> [!TIP]
> Dataset yang dikembalikan hanya dapat di-cache jika `con` ditentukan sebagai string URI.

#### align_labels_with_mapping[[datasets.Dataset.align_labels_with_mapping]]

```python
align_labels_with_mapping(label2id: dict, label_column: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6600)

**Parameter:**

label2id (`dict`) : Pemetaan nama label ke ID untuk menyelaraskan dataset.

label_column (`str`) : Nama kolom label yang akan diselaraskan.

Selaraskan pemetaan ID label dan nama label dataset agar sesuai dengan pemetaan `label2id` input. Ini berguna ketika Anda ingin memastikan bahwa label prediksi model selaras dengan dataset. Penyelarasan dilakukan menggunakan nama label huruf kecil.

Contoh:

```python
>>> # dataset with mapping {'entailment': 0, 'neutral': 1, 'contradiction': 2}
>>> ds = load_dataset("nyu-mll/glue", "mnli", split="train")
>>> # mapping to align with
>>> label2id = {'CONTRADICTION': 0, 'NEUTRAL': 1, 'ENTAILMENT': 2}
>>> ds_aligned = ds.align_labels_with_mapping(label2id, "label")
```

#### datasets.concatenate_datasets[[datasets.concatenate_datasets]]

```python
datasets.concatenate_datasets(dsets: list, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, axis: int = 0)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L168)

**Parameter:**

dsets (`List[datasets.Dataset]` atau `List[datasets.IterableDataset]`) : Daftar Dataset untuk digabungkan.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

axis (`{0, 1}`, defaultnya `0`) : Sumbu untuk penggabungan, di mana `0` berarti pada baris (vertikal) dan `1` berarti pada kolom (horizontal).

Gabungkan beberapa dataset (sumber) menjadi satu dataset.

Gunakan axis=0 untuk menggabungkan secara vertikal (default), atau axis=1 untuk menggabungkan secara horizontal.

Catatan untuk dataset iterable:

* if axis=0, `num_shards` dari dataset yang dihasilkan adalah jumlah dari `num_shards` masing-masing dataset.
* jika axis=1, dataset yang dihasilkan memiliki satu (1) shard agar data tidak menjadi tidak selaras.
* jika dataset dipecah dengan [datasets.distributed.split_dataset_by_node()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.distributed.split_dataset_by_node), semuanya harus dipecah dengan cara yang sama, dan dataset yang dihasilkan mempertahankan pembagian tersebut.

Contoh:

```py
>>> ds3 = concatenate_datasets([ds1, ds2])
```

#### datasets.interleave_datasets[[datasets.interleave_datasets]]

```python
datasets.interleave_datasets(datasets: list, probabilities: typing.Optional[list[float]] = None, seed: typing.Optional[int] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, stopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted')
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L18)

**Parameter:**

datasets (`List[Dataset]` atau `List[IterableDataset]`) : Daftar dataset untuk diinterleaving.

probabilities (`List[float]`, *opsional*, defaultnya `None`) : Jika ditentukan, dataset baru dibangun dengan mengambil sampel contoh dari satu sumber pada satu waktu sesuai dengan probabilitas ini.

seed (`int`, *opsional*, defaultnya `None`) : Benang acak yang digunakan untuk memilih sumber untuk setiap contoh.

info ([DatasetInfo](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetInfo), *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), *opsional*) : Nama dari split dataset.

stopping_strategy (`str`, defaultnya `first_exhausted`) : Saat ini diusulkan tiga strategi, yaitu `first_exhausted`, `all_exhausted`, dan `all_exhausted_without_replacement`. Secara default, `first_exhausted` adalah strategi undersampling, yaitu konstruksi dataset dihentikan begitu satu dataset kehabisan sampel. Jika strateginya adalah `all_exhausted`, kita menggunakan strategi oversampling, yaitu konstruksi dataset dihentikan begitu setiap sampel dari setiap dataset telah ditambahkan setidaknya sekali. Ketika strateginya adalah `all_exhausted_without_replacement`, kita memastikan bahwa setiap sampel di setiap dataset hanya diambil sekali. Perhatikan bahwa jika strateginya adalah `all_exhausted`, ukuran dataset yang diinterleaved bisa menjadi sangat besar: - tanpa probabilitas, dataset yang dihasilkan akan memiliki `max_length_datasets*nb_dataset` sampel. - dengan probabilitas yang diberikan, dataset yang dihasilkan akan memiliki lebih banyak sampel jika beberapa dataset memiliki probabilitas kunjungan yang sangat rendah.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) atau [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Tipe pengembalian bergantung pada parameter `datasets` yang dimasukkan. `Dataset` jika input berupa daftar `Dataset`, `IterableDataset` jika input berupa daftar `IterableDataset`.

Interleaving beberapa dataset (sumber) menjadi satu dataset. Dataset baru dibangun dengan cara bergantian mengambil contoh dari masing-masing sumber.

Anda dapat menggunakan fungsi ini pada daftar objek [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset), atau pada daftar objek [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset).

- Jika `probabilities` adalah `None` (default), dataset baru dibangun dengan bergantian mengambil contoh dari setiap sumber.
- Jika `probabilities` bukan `None`, dataset baru dibangun dengan mengambil contoh dari sumber acak satu per satu sesuai dengan probabilitas yang diberikan.

Dataset yang dihasilkan berakhir ketika salah satu dataset sumber kehabisan contoh, kecuali jika `oversampling` adalah `True`, di mana dataset yang dihasilkan berakhir ketika semua dataset telah kehabisan contoh setidaknya satu kali.

Catatan untuk dataset iterable:

* `num_shards` dari dataset yang dihasilkan adalah nilai minimum dari `num_shards` masing-masing dataset untuk memastikan paralelisme yang baik. Jika beberapa dataset Anda memiliki jumlah shard yang sangat rendah, Anda dapat menggunakan [IterableDataset.reshard()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.reshard).
* Dalam setup terdistribusi atau di worker PyTorch DataLoader, strategi penghentian diterapkan per proses. Oleh karena itu, strategi "first_exhausted" pada dataset iterable yang di-shard dapat menghasilkan total sampel yang lebih sedikit (hingga 1 sampel hilang per subdataset per worker).

Contoh:

Untuk dataset reguler (gaya peta):

```python
>>> from datasets import Dataset, interleave_datasets
>>> d1 = Dataset.from_dict({"a": [0, 1, 2]})
>>> d2 = Dataset.from_dict({"a": [10, 11, 12]})
>>> d3 = Dataset.from_dict({"a": [20, 21, 22]})
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted")
>>> dataset["a"]
[10, 0, 11, 1, 2, 20, 12, 10, 0, 1, 2, 21, 0, 11, 1, 2, 0, 1, 12, 2, 10, 0, 22]
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42)
>>> dataset["a"]
[10, 0, 11, 1, 2]
>>> dataset = interleave_datasets([d1, d2, d3])
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22]
>>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted")
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22]
>>> d1 = Dataset.from_dict({"a": [0, 1, 2]})
>>> d2 = Dataset.from_dict({"a": [10, 11, 12, 13]})
>>> d3 = Dataset.from_dict({"a": [20, 21, 22, 23, 24]})
>>> dataset = interleave_datasets([d1, d2, d3])
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22]
>>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted")
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22, 0, 13, 23, 1, 10, 24]
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42)
>>> dataset["a"]
[10, 0, 11, 1, 2]
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted")
>>> dataset["a"]
[10, 0, 11, 1, 2, 20, 12, 13, ..., 0, 1, 2, 0, 24]
For datasets in streaming mode (iterable):

>>> from datasets import interleave_datasets
>>> d1 = load_dataset('allenai/c4', 'es', split='train', streaming=True)
>>> d2 = load_dataset('allenai/c4', 'fr', split='train', streaming=True)
>>> dataset = interleave_datasets([d1, d2])
>>> iterator = iter(dataset)
>>> next(iterator)
{'text': 'Comprar Zapatillas para niña en chancla con goma por...'}
>>> next(iterator)
{'text': 'Le sacre de philippe ier, 23 mai 1059 - Compte Rendu...'
```

#### datasets.distributed.split_dataset_by_node[[datasets.distributed.split_dataset_by_node]]

```python
datasets.distributed.split_dataset_by_node(dataset: ~DatasetType, rank: int, world_size: int, strategy: typing.Literal['auto', 'shards', 'examples'] = 'auto')
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/distributed.py#L10)

**Parameter:**

dataset ([Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) atau [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)) : Dataset yang akan dipecah per node.

rank (`int`) : Rank dari node saat ini.

world_size (`int`) : Jumlah total node.

strategy (`str`, defaultnya `"auto"`) : Cara membagi dataset iterable. Harus salah satu dari `"auto"`, `"shards"`, atau `"examples"`. Dataset gaya map hanya mendukung `"auto"`.

**Mengembalikan:** [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) atau [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Dataset yang akan digunakan pada node di rank `rank`.

Bagikan dataset untuk node pada peringkat `rank` dalam kumpulan node berukuran `world_size`.

Untuk dataset bergaya peta:

Setiap node diberi alokasi sepotong data, misalnya rank 0 diberikan sepotong pertama dari dataset. Untuk memaksimalkan throughput pemuatan data, sepotong-sepotong tersebut dibuat dari data yang berurutan di disk jika memungkinkan.

Untuk dataset yang dapat diiterasi:

Strategi `strategy` pemecahan dapat berupa `"auto"`, `"shards"`, atau `"examples"`:

* `"shards"`: shards didistribusikan secara merata di antara node
* `"examples"`: setiap node menyimpan 1 contoh dari `world_size`, melewati contoh lainnya
* `"auto"` (default): menggunakan `"shards"` jika dataset memiliki jumlah shard yang merupakan faktor dari `world_size`
(yaitu jika `dataset.num_shards % world_size == 0`), yang merupakan yang paling dioptimalkan. Jika tidak, gunakan `"examples"`.

> [!WARNING]
> Jika Anda mengacak dataset iterable dalam setup terdistribusi, pastikan untuk mengatur `seed` yang tetap di [IterableDataset.shuffle()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.shuffle)
sehingga daftar shard yang diacak yang sama digunakan di setiap node untuk mengetahui shard mana yang harus dilewati oleh node tersebut.

#### datasets.enable_caching[[datasets.enable_caching]]

```python
datasets.enable_caching()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L120)

Saat menerapkan transform pada dataset, data disimpan dalam file cache. Mekanisme cache memungkinkan pemuatan ulang file cache yang sudah ada jika file tersebut sudah dihitung sebelumnya.

Memuat ulang dataset dimungkinkan karena file cache diberi nama menggunakan sidik jari dataset, yang diperbarui setelah setiap transformasi.

Jika dinonaktifkan, pustaka tidak akan lagi memuat ulang file dataset yang di-cache saat menerapkan transformasi ke dataset. Lebih tepatnya, jika caching dinonaktifkan:
- file cache selalu dibuat ulang
- file cache ditulis ke direktori sementara yang dihapus saat sesi ditutup
- file cache diberi nama menggunakan hash acak alih-alih sidik jari dataset
- gunakan [save_to_disk()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.save_to_disk) untuk menyimpan dataset yang telah ditransformasi atau dataset tersebut akan dihapus saat sesi ditutup
- caching tidak memengaruhi [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset). Jika Anda ingin membuat ulang dataset dari awal, Anda harus menggunakan
parameter `download_mode` di [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset).

#### datasets.disable_caching[[datasets.disable_caching]]

```python
datasets.disable_caching()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L141)

Saat menerapkan transform pada dataset, data disimpan dalam file cache. Mekanisme cache memungkinkan pemuatan ulang file cache yang sudah ada jika file tersebut sudah dihitung sebelumnya.

Memuat ulang dataset dimungkinkan karena file cache diberi nama menggunakan sidik jari dataset, yang diperbarui setelah setiap transformasi.

Jika dinonaktifkan, pustaka tidak akan lagi memuat ulang file dataset yang di-cache saat menerapkan transformasi ke dataset. Lebih tepatnya, jika caching dinonaktifkan:
- file cache selalu dibuat ulang
- file cache ditulis ke direktori sementara yang dihapus saat sesi ditutup
- file cache diberi nama menggunakan hash acak alih-alih sidik jari dataset
- gunakan [save_to_disk()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.save_to_disk) untuk menyimpan dataset yang telah ditransformasi atau dataset tersebut akan dihapus saat sesi ditutup
- caching tidak memengaruhi [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset). Jika Anda ingin membuat ulang dataset dari awal, Anda harus menggunakan
parameter `download_mode` di [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset).

#### datasets.is_caching_enabled[[datasets.is_caching_enabled]]

```python
datasets.is_caching_enabled()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L162)

Saat menerapkan transform pada dataset, data disimpan dalam file cache. Mekanisme cache memungkinkan pemuatan ulang file cache yang sudah ada jika file tersebut sudah dihitung sebelumnya.

Memuat ulang dataset dimungkinkan karena file cache diberi nama menggunakan sidik jari dataset, yang diperbarui setelah setiap transformasi.

Jika dinonaktifkan, pustaka tidak akan lagi memuat ulang file dataset yang di-cache saat menerapkan transformasi ke dataset. Lebih tepatnya, jika caching dinonaktifkan:
- file cache selalu dibuat ulang
- file cache ditulis ke direktori sementara yang dihapus saat sesi ditutup
- file cache diberi nama menggunakan hash acak alih-alih sidik jari dataset
- gunakan [save_to_disk()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.save_to_disk)] untuk menyimpan dataset yang telah ditransformasi atau dataset tersebut akan dihapus saat sesi ditutup
- caching tidak memengaruhi [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset). Jika Anda ingin membuat ulang dataset dari awal, Anda harus menggunakan
parameter `download_mode` di [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset).

#### datasets.Column[[datasets.Column]]

```python
datasets.Column(source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')], column_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L638)

Iterable untuk kolom tertentu dari [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset).

Contoh:

Iterasi pada teks di kolom "text" dari dataset:

```python
for text in dataset["text"]:
    ...
```

Ini juga berfungsi dengan kolom bersarang:

```python
for source in dataset["metadata"]["source"]:
    ...
```

## DatasetDict[[datasets.DatasetDict]]

Kamus dengan nama split sebagai kunci (misalnya 'train', 'test'), dan objek `Dataset` sebagai nilai. Ia juga memiliki metode transformasi dataset seperti map atau filter, untuk memproses semua split sekaligus.

#### datasets.DatasetDict[[datasets.DatasetDict]]

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L53)

Kamus (dict of str: datasets.Dataset) dengan metode transformasi dataset (map, filter, dll.)

#### data[[datasets.DatasetDict.data]]

```python
data()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L94)

Tabel Apache Arrow yang mendasari setiap split.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.data
```

#### cache_files[[datasets.DatasetDict.cache_files]]

```python
cache_files()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L109)

File cache yang berisi tabel Apache Arrow yang mendukung setiap split.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.cache_files
{'test': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-test.arrow'}],
 'train': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-train.arrow'}],
 'validation': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]}
```

#### num_columns[[datasets.DatasetDict.num_columns]]

```python
num_columns()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L127)

Jumlah kolom di setiap split dari dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.num_columns
{'test': 2, 'train': 2, 'validation': 2}
```

#### num_rows[[datasets.DatasetDict.num_rows]]

```python
num_rows()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L143)

Jumlah baris di setiap split dari dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.num_rows
{'test': 1066, 'train': 8530, 'validation': 1066}
```

#### column_names[[datasets.DatasetDict.column_names]]

```python
column_names()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L159)

Nama kolom di setiap split dari dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.column_names
{'test': ['text', 'label'],
 'train': ['text', 'label'],
 'validation': ['text', 'label']}
```

#### shape[[datasets.DatasetDict.shape]]

```python
shape()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L177)

Bentuk setiap split dari dataset (jumlah baris, jumlah kolom).

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.shape
{'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)}
```

#### unik[[datasets.DatasetDict.unique]]

```python
unique(column: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L226)

**Parameter:**

column (`str`) : nama kolom (daftar semua nama kolom dengan [column_names](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict.column_names))

**Mengembalikan:** Dict[`str`, `list`]

Kamus elemen unik di kolom yang diberikan.

Kembalikan daftar elemen unik dalam kolom untuk setiap split.

Hal ini diimplementasikan di backend tingkat rendah dan karenanya, sangat cepat.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.unique("label")
{'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]}
```

#### cleanup_cache_files[[datasets.DatasetDict.cleanup_cache_files]]

```python
cleanup_cache_files()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L250)

**Mengembalikan:**

`Dict` dengan jumlah file yang dihapus untuk setiap split

Bersihkan semua file cache di direktori cache dataset, kecuali file cache yang sedang digunakan jika ada. Hati-hati saat menjalankan perintah ini agar tidak ada proses lain yang sedang menggunakan file cache lainnya.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.cleanup_cache_files()
{'test': 0, 'train': 0, 'validation': 0}
```

#### map[[datasets.DatasetDict.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L814)

**Parameter:**

function (`callable`) : dengan salah satu dari signature berikut: - `function(example: Dict[str, Any]) -> Dict[str, Any]` jika `batched=False` dan `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]` jika `batched=False` dan `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` jika `batched=True` dan `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` jika `batched=True` dan `with_indices=True` Untuk penggunaan lanjutan, fungsi juga dapat mengembalikan `pyarrow.Table`. Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel. Selain itu, jika fungsi Anda tidak mengembalikan apa pun (`None`), maka `map` akan menjalankan fungsi Anda dan mengembalikan dataset tanpa perubahan. Jika tidak ada fungsi yang diberikan, default ke fungsi identitas: `lambda x: x`.

with_indices (`bool`, defaultnya `False`) : Berikan indeks contoh ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx): ...`.

with_rank (`bool`, defaultnya `False`) : Menyediakan peringkat proses ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example[, idx], rank): ...`.

with_split (`bool`, defaultnya `False`) : Berikan pembagian proses ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example[, idx], split): ...`.

input_columns (`[Union[str, list[str]]]`, *opsional*, defaultnya `None`) : Kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, dict yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True`, `batch_size <= 0` atau `batch_size == None` maka berikan seluruh dataset sebagai satu batch ke `function`.

drop_last_batch (`bool`, defaultnya `False`) : Apakah batch terakhir yang lebih kecil dari batch_size harus dibuang alih-alih diproses oleh fungsi.

remove_columns (`[Union[str, list[str]]]`, *opsional*, defaultnya `None`) : Menghapus pilihan kolom saat melakukan pemetaan. Kolom akan dihapus sebelum memperbarui contoh dengan output dari `function`, yaitu jika `function` menambahkan kolom dengan nama yang ada di `remove_columns`, kolom-kolom ini akan tetap dipertahankan.

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan komputasi saat ini dari `function` dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

cache_file_names (`[Dict[str, str]]`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan hasil komputasi alih-alih nama file cache yang dihasilkan secara otomatis. Anda harus menyediakan satu `cache_file_name` per dataset dalam kamus dataset.

writer_batch_size (`int`, default `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

features (`[datasets.Features]`, *opsional*, defaultnya `None`) : Gunakan [Features](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features) tertentu untuk menyimpan file cache alih-alih yang dihasilkan secara otomatis.

disable_nullable (`bool`, defaultnya `False`) : Larang nilai null dalam tabel.

fn_kwargs (`Dict`, *opsional*, defaultnya `None`) : Argumen kata kunci yang akan diteruskan ke `function`

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses yang digunakan untuk multiprocessing. - Jika `None` atau `0`, multiprocessing tidak digunakan dan operasi dijalankan di proses utama. - Jika lebih besar dari `1`, satu atau beberapa proses worker digunakan untuk memproses data secara paralel. Catatan: Fungsi yang diteruskan ke `map()` harus dapat di-pickle agar multiprocessing dapat bekerja dengan benar (yaitu, lebih disukai fungsi yang didefinisikan di tingkat atas modul, bukan di dalam fungsi atau kelas lain).

desc (`str`, *opsional*, defaultnya `None`) : Deskripsi bermakna yang akan ditampilkan berdampingan dengan bilah progres saat memetakan contoh.

try_original_type (`Optional[bool]`, defaultnya `True`) : Berusaha mempertahankan tipe kolom asli (mis. int32 -> int32). Atur ke False jika Anda ingin selalu menyimpulkan tipe baru.

on_mixed_types (`Literal["use_json"]`, *opsional*, defaultnya `None`) : Jika "use_json", gunakan tipe Json() untuk field bertipe campuran, yaitu field tidak terstruktur yang berisi data tanpa skema yang didefinisikan sebelumnya. Dalam kasus ini, field dengan tipe campuran diatur ke Json(). Hal ini memungkinkan pemuatan daftar dengan campuran string/integer/float, misalnya, atau kamus dengan tipe nilai yang sewenang-wenang.

Terapkan fungsi ke semua contoh dalam tabel (secara individual atau dalam batch) dan perbarui tabel. Jika fungsi Anda mengembalikan kolom yang sudah ada, maka kolom tersebut akan ditimpa. Transformasi diterapkan ke semua dataset dalam kamus dataset.

Anda dapat menentukan apakah fungsi harus di-batch atau tidak dengan parameter `batched`:

- Jika `False`, fungsi menerima 1 contoh dan harus mengembalikan 1 contoh. Contoh adalah kamus, misalnya `{"text": "Hello there !"}`.
- Jika `True` dan `batch_size` adalah 1, maka fungsi mengambil batch berisi 1 contoh sebagai input dan dapat mengembalikan batch berisi 1 atau lebih contoh. Batch adalah kamus, misalnya batch berisi 1 contoh adalah `{"text": ["Hello there !"]}`.
- Jika `True` dan `batch_size` adalah `n > 1`, maka fungsi tersebut mengambil batch berisi `n` contoh sebagai input dan dapat mengembalikan batch berisi `n` contoh, atau dengan jumlah contoh yang sembarang. Perhatikan bahwa batch terakhir mungkin memiliki kurang dari `n` contoh. Batch adalah kamus, misalnya batch berisi `n` contoh adalah `{"text": ["Hello there !"] * n}`.

Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel, dengan hingga seribu panggilan simultan. Disarankan untuk menggunakan `asyncio.Semaphore` di dalam fungsi Anda jika Anda ingin menetapkan jumlah maksimum operasi yang dapat berjalan pada saat yang sama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> def add_prefix(example):
...     example["text"] = "Review: " + example["text"]
...     return example
>>> ds = ds.map(add_prefix)
>>> ds["train"][0:3]["text"]
['Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .',
 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .',
 'Review: effective but too-tepid biopic']

# process a batch of examples
>>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True)
# set number of processors
>>> ds = ds.map(add_prefix, num_proc=4)
```

#### filter[[datasets.DatasetDict.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L986)

**Parameter:**

function (`Callable`) : Callable dengan salah satu dari tanda tangan berikut: - `function(example: Dict[str, Any]) -> bool` jika `batched=False` dan `with_indices=False` dan `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` jika `batched=False` dan `with_indices=True` dan/atau `with_rank=True` (satu argumen tambahan untuk masing-masing) - `function(batch: Dict[str, list]) -> list[bool]` jika `batched=True` dan `with_indices=False` dan `with_rank=False` - `function(batch: Dict[str, list], *extra_args) -> list[bool]` jika `batched=True` dan `with_indices=True` dan/atau `with_rank=True` (satu argumen tambahan untuk masing-masing) Jika tidak ada fungsi yang diberikan, secara default menggunakan fungsi yang selalu `True`: `lambda x: True`.

with_indices (`bool`, defaultnya `False`) : Menyediakan indeks contoh untuk `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx[, rank]): ...`.

with_rank (`bool`, defaultnya `False`) : Menyediakan peringkat proses ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example[, idx], rank): ...`.

input_columns (`[Union[str, list[str]]]`, *opsional*, defaultnya `None`) : Kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, dict yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True` `batch_size <= 0` atau `batch_size == None` maka berikan seluruh dataset sebagai satu batch ke `function`.

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan komputasi saat ini dari `function` dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

cache_file_names (`[Dict[str, str]]`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan hasil komputasi alih-alih nama file cache yang dihasilkan secara otomatis. Anda harus menyediakan satu `cache_file_name` per dataset dalam kamus dataset.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

fn_kwargs (`Dict`, *opsional*, defaultnya `None`) : Argumen kata kunci yang akan diteruskan ke `function`

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses yang digunakan untuk multiprocessing. - Jika `None` atau `0`, multiprocessing tidak digunakan dan operasi dijalankan di proses utama. - Jika lebih besar dari `1`, satu atau beberapa proses worker digunakan untuk memproses data secara paralel. Catatan: Fungsi yang diteruskan ke `map()` harus dapat di-pickle agar multiprocessing dapat bekerja dengan benar (yaitu, lebih disukai fungsi yang didefinisikan di tingkat atas modul, bukan di dalam fungsi atau kelas lain).

desc (`str`, *opsional*, defaultnya `None`) : Deskripsi bermakna yang akan ditampilkan berdampingan dengan bilah kemajuan saat memfilter contoh.

Terapkan fungsi filter pada semua elemen dalam tabel secara batch dan perbarui tabel sehingga dataset hanya mencakup contoh sesuai dengan fungsi filter. Transformasi diterapkan pada semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.filter(lambda x: x["label"] == 1)
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 4265
    })
    validation: Dataset({
        features: ['text', 'label'],
        num_rows: 533
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 533
    })
})
```

#### sort[[datasets.DatasetDict.sort]]

```python
sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1151)

**Parameter:**

column_names (`Union[str, Sequence[str]]`) : Nama kolom untuk diurutkan.

reverse (`Union[bool, Sequence[bool]]`, defaultnya `False`) : Jika `True`, urutkan berdasarkan urutan menurun, bukan menaik. Jika satu bool diberikan, nilai tersebut diterapkan pada pengurutan semua nama kolom. Sebaliknya, daftar bool dengan panjang dan urutan yang sama dengan column_names harus diberikan.

null_placement (`str`, defaultnya `at_end`) : Letakkan nilai `None` di awal jika `at_start` atau `first` atau di akhir jika `at_end` atau `last`

keep_in_memory (`bool`, defaultnya `False`) : Simpan indeks yang telah diurutkan di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan indeks terurut dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

indices_cache_file_names (`[Dict[str, str]]`, *opsional*, defaultnya `None`) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan pemetaan indeks alih-alih nama file cache yang dihasilkan secara otomatis. Anda harus menyediakan satu `cache_file_name` per dataset dalam kamus dataset.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai yang lebih tinggi menghasilkan file cache yang lebih kecil, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit.

Buat dataset baru yang diurutkan berdasarkan satu atau beberapa kolom.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes')
>>> ds['train']['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> sorted_ds = ds.sort('label')
>>> sorted_ds['train']['label'][:10]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False])
>>> another_sorted_ds['train']['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```

#### shuffle[[datasets.DatasetDict.shuffle]]

```python
shuffle(seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = None, seed: typing.Optional[int] = None, generators: typing.Optional[dict[str, numpy.random._generator.Generator]] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1218)

**Parameter:**

seeds (`Dict[str, int]` atau `int`, *opsional*) : Benih untuk menginisialisasi BitGenerator default jika `generator=None`. Jika `None`, maka entropi baru yang tidak dapat diprediksi akan diambil dari OS. Jika `int` atau `array_like[ints]` diberikan, maka nilai tersebut akan diteruskan ke SeedSequence untuk menurunkan keadaan awal BitGenerator. Anda dapat menyediakan satu `seed` per dataset dalam kamus dataset.

seed (`int`, *opsional*) : Benih untuk menginisialisasi BitGenerator default jika `generator=None`. Alias untuk seeds (sebuah `ValueError` akan dilempar jika keduanya disediakan).

generators (`Dict[str, *optional*, np.random.Generator]`) : Generator acak Numpy yang digunakan untuk menghitung permutasi baris dataset. Jika `generator=None` (default), menggunakan `np.random.default_rng` (BitGenerator default (PCG64) dari NumPy). Anda harus menyediakan satu `generator` per dataset dalam kamus dataset.

keep_in_memory (`bool`, defaultnya `False`) : Simpan dataset di memori alih-alih menuliskannya ke file cache.

load_from_cache_file (`Optional[bool]`, defaultnya `True` jika caching diaktifkan) : Jika file cache yang menyimpan komputasi saat ini dari `function` dapat diidentifikasi, gunakan file tersebut alih-alih menghitung ulang.

indices_cache_file_names (`Dict[str, str]`, *opsional*) : Berikan nama path untuk file cache. Ini digunakan untuk menyimpan pemetaan indeks alih-alih nama file cache yang dihasilkan secara otomatis. Anda harus menyediakan satu `cache_file_name` per dataset dalam kamus dataset.

writer_batch_size (`int`, defaultnya `1000`) : Jumlah baris per operasi penulisan untuk penulis file cache. Nilai ini merupakan kompromi yang baik antara penggunaan memori selama pemrosesan dan kecepatan pemrosesan. Nilai yang lebih tinggi membuat pemrosesan melakukan lebih sedikit pencarian, sedangkan nilai yang lebih rendah mengonsumsi memori sementara yang lebih sedikit saat menjalankan `map`.

Buat Dataset baru di mana barisnya diacak.

Transformasi diterapkan ke semua dataset dalam kamus dataset.

Saat ini, shuffling menggunakan generator acak numpy. Anda dapat menyediakan NumPy BitGenerator untuk digunakan, atau seed untuk menginisiasi generator acak default NumPy (PCG64).

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds["train"]["label"][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

# set a seed
>>> shuffled_ds = ds.shuffle(seed=42)
>>> shuffled_ds["train"]["label"][:10]
[0, 1, 0, 1, 0, 0, 0, 0, 0, 0]
```

#### set_format[[datasets.DatasetDict.set_format]]

```python
set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L571)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti `__getitem__` mengembalikan objek python (default).

columns (`list[str]`, *opsional*) : Kolom yang akan diformat dalam output. `None` berarti `__getitem__` mengembalikan semua kolom (default).

output_all_columns (`bool`, defaultnya False) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python),

- ****format_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang diteruskan ke fungsi konversi seperti `np.array`, `torch.tensor` atau `tensorflow.ragged.constant`.

Set format pengembalian `__getitem__` (tipe dan kolom). Format ini diset untuk setiap dataset dalam kamus dataset.

Memanggil `map` setelah memanggil `set_format` dimungkinkan. Karena `map` dapat menambahkan kolom baru, daftar kolom yang diformat akan diperbarui. Dalam kasus ini, jika Anda menerapkan `map` pada dataset untuk menambahkan kolom baru, kolom tersebut akan diformat:

`new formatted columns = (all columns - previously unformatted columns)`

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True)
>>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'])
>>> ds["train"].format
{'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'numpy'}
```

#### reset_format[[datasets.DatasetDict.reset_format]]

```python
reset_format()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L622)

Reset format pengembalian `__getitem__` ke objek python dan semua kolom. Transformasi diterapkan ke semua dataset dalam kamus dataset.

Sama seperti `self.set_format()`

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True)
>>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'])
>>> ds["train"].format
{'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'numpy'}
>>> ds.reset_format()
>>> ds["train"].format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': None}
```

#### formatted_as[[datasets.DatasetDict.formatted_as]]

```python
formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L531)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti `__getitem__` mengembalikan objek python (default).

columns (`list[str]`, *opsional*) : Kolom yang akan diformat dalam output. `None` berarti `__getitem__` mengembalikan semua kolom (default).

output_all_columns (`bool`, defaultnya False) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python).

- ****format_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang diteruskan ke fungsi konversi seperti `np.array`, `torch.tensor` atau `tensorflow.ragged.constant`.

Digunakan dalam pernyataan `with`. Mengatur format pengembalian `__getitem__` (tipe dan kolom). Transformasi diterapkan ke semua dataset dalam kamus dataset.

#### with_format[[datasets.DatasetDict.with_format]]

```python
with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L683)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti `__getitem__` mengembalikan objek python (default).

columns (`list[str]`, *opsional*) : Kolom yang akan diformat dalam output. `None` berarti `__getitem__` mengembalikan semua kolom (default).

output_all_columns (`bool`, defaultnya `False`) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python).

- ****format_kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang diteruskan ke fungsi konversi seperti `np.array`, `torch.tensor` atau `tensorflow.ragged.constant`.

Set format pengembalian `__getitem__` (tipe dan kolom). Pemformatan data diterapkan secara langsung. Format `type` (misalnya "numpy") digunakan untuk memformat batch saat menggunakan `__getitem__`. Format ini diset untuk setiap dataset dalam kamus dataset.

Anda juga dapat menggunakan transform kustom untuk format menggunakan [with_transform()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.with_transform).

Berbeda dengan [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict.set_format), `with_format` mengembalikan objek [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) baru dengan objek [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds["train"].format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': None}
>>> ds = ds.with_format("torch")
>>> ds["train"].format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'torch'}
>>> ds["train"][0]
{'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'label': tensor(1),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
        1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
        1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### with_transform[[datasets.DatasetDict.with_transform]]

```python
with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L760)

**Parameter:**

transform (`Callable`, *opsional*) : Transformasi format yang didefinisikan pengguna, menggantikan format yang didefinisikan oleh [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format). Fungsi format adalah callable yang menerima batch (sebagai dict) sebagai input dan mengembalikan batch. Fungsi ini diterapkan tepat sebelum mengembalikan objek di `__getitem__`.

columns (`list[str]`, *opsional*) : Kolom yang akan diformat dalam output. Jika ditentukan, maka batch input dari transform hanya berisi kolom-kolom tersebut.

output_all_columns (`bool`, defaultnya False) : Simpan juga kolom yang tidak diformat dalam output (sebagai objek python). Jika diset ke `True`, maka kolom-kolom lain yang tidak diformat akan disimpan bersama output dari transform.

Set format pengembalian `__getitem__` menggunakan transform ini. Transform diterapkan secara on-the-fly pada batch saat `__getitem__` dipanggil. Transform diset untuk setiap dataset dalam kamus dataset

Seperti [set_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.set_format), ini dapat direset menggunakan [reset_format()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.reset_format).

Berbeda dengan `set_transform()`, `with_transform` mengembalikan objek [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) baru dengan objek [Dataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset) baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> def encode(example):
...     return tokenizer(example['text'], truncation=True, padding=True, return_tensors="pt")
>>> ds = ds.with_transform(encode)
>>> ds["train"][0]
{'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1]),
 'input_ids': tensor([  101,  1103,  2067,  1110, 17348,  1106,  1129,  1103,  6880,  1432,
        112,   188,  1207,   107, 14255,  1389,   107,  1105,  1115,  1119,
        112,   188,  1280,  1106,  1294,   170, 24194,  1256,  3407,  1190,
        170, 11791,  5253,   188,  1732,  7200, 10947, 12606,  2895,   117,
        179,  7766,   118,   172, 15554,  1181,  3498,  6961,  3263,  1137,
        188,  1566,  7912, 14516,  6997,   119,   102]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### flatten[[datasets.DatasetDict.flatten]]

```python
flatten(max_depth = 16)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L193)

Ratakan Apache Arrow Table dari setiap split (fitur bersarang diratakan). Setiap kolom dengan tipe struct diratakan menjadi satu kolom per field struct. Kolom lainnya tidak diubah.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("rajpurkar/squad")
>>> ds["train"].features
{'id': Value('string'),
 'title': Value('string'),
 'context': Value('string'),
 'question': Value('string'),
 'answers.text': List(Value('string')),
 'answers.answer_start': List(Value('int32'))}
>>> ds.flatten()
DatasetDict({
    train: Dataset({
        features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'],
        num_rows: 87599
    })
    validation: Dataset({
        features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'],
        num_rows: 10570
    })
})
```

#### cast[[datasets.DatasetDict.cast]]

```python
cast(features: Features)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L274)

**Parameter:**

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features)) : Fitur baru untuk mengubah tipe dataset. Nama dan urutan field dalam fitur harus sesuai dengan nama kolom saat ini. Tipe data juga harus dapat dikonversi dari satu tipe ke tipe lainnya. Untuk konversi yang tidak sederhana, misalnya `string` <-> `ClassLabel`, Anda harus menggunakan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict.map) untuk memperbarui dataset.

Cast dataset ke set fitur baru. Transformasi diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset, ClassLabel, Value
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds["train"].features.copy()
>>> new_features['label'] = ClassLabel(names=['bad', 'good'])
>>> new_features['text'] = Value('large_string')
>>> ds = ds.cast(new_features)
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### cast_column[[datasets.DatasetDict.cast_column]]

```python
cast_column(column: str, feature)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L306)

**Parameter:**

column (`str`) : Nama kolom.

feature (`Feature`) : Fitur target.

**Mengembalikan:**

[DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Cast kolom ke fitur untuk decoding.

Contoh:

```py
>>> from datasets import load_dataset, ClassLabel
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good']))
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('string')}
```

#### remove_columns[[datasets.DatasetDict.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L335)

**Parameter:**

column_names (`Union[str, list[str]]`) : Nama kolom yang akan dihapus.

**Mengembalikan:** [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Salinan objek dataset tanpa kolom yang akan dihapus.

Hapus satu atau beberapa kolom dari setiap split dalam dataset beserta fitur yang terkait dengan kolom tersebut.

Transformasi diterapkan ke semua split dari kamus dataset.

Anda juga dapat menghapus kolom menggunakan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict.map) dengan `remove_columns`, tetapi metode yang ada tidak menyalin data dari kolom yang tersisa sehingga lebih cepat.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds = ds.remove_columns("label")
DatasetDict({
    train: Dataset({
        features: ['text'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text'],
        num_rows: 1066
    })
})
```

#### rename_column[[datasets.DatasetDict.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L377)

**Parameter:**

original_column_name (`str`) : Nama kolom yang akan diganti namanya.

new_column_name (`str`) : Nama baru untuk kolom.

Ganti nama kolom dalam dataset dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru. Transformasi ini diterapkan ke semua dataset dalam kamus dataset.

Anda juga dapat mengubah nama kolom menggunakan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict.map) dengan `remove_columns` tetapi metode yang ada:
- menangani pemindahan fitur asli di bawah nama kolom baru.
- tidak menyalin data ke dataset baru sehingga jauh lebih cepat.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds = ds.rename_column("label", "label_new")
DatasetDict({
    train: Dataset({
        features: ['text', 'label_new'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text', 'label_new'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text', 'label_new'],
        num_rows: 1066
    })
})
```

#### rename_columns[[datasets.DatasetDict.rename_columns]]

```python
rename_columns(column_mapping: dict)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L425)

**Parameter:**

column_mapping (`Dict[str, str]`) : Pemetaan kolom untuk diubah namanya menjadi nama baru.

**Mengembalikan:** [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Salinan dataset dengan kolom yang namanya diubah.

Ganti nama beberapa kolom dalam dataset, dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru. Transformasi ini diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.rename_columns({'text': 'text_new', 'label': 'label_new'})
DatasetDict({
    train: Dataset({
        features: ['text_new', 'label_new'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text_new', 'label_new'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text_new', 'label_new'],
        num_rows: 1066
    })
})
```

#### select_columns[[datasets.DatasetDict.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L463)

**Parameter:**

column_names (`Union[str, list[str]]`) : Nama kolom yang akan dipertahankan.

Pilih satu atau beberapa kolom dari setiap split dalam dataset beserta fitur yang terkait dengan kolom tersebut.

Transformasi diterapkan ke semua split dari kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.select_columns("text")
DatasetDict({
    train: Dataset({
        features: ['text'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text'],
        num_rows: 1066
    })
})
```

#### class_encode_column[[datasets.DatasetDict.class_encode_column]]

```python
class_encode_column(column: str, include_nulls: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L499)

**Parameter:**

column (`str`) : Nama kolom yang akan di-cast.

include_nulls (`bool`, defaultnya `False`) : Apakah akan menyertakan nilai null dalam label kelas. Jika `True`, nilai null akan dikodekan sebagai label kelas `"None"`.

Mencast kolom yang diberikan sebagai [ClassLabel](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.ClassLabel) dan memperbarui tabel.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("google/boolq")
>>> ds["train"].features
{'answer': Value('bool'),
 'passage': Value('string'),
 'question': Value('string')}
>>> ds = ds.class_encode_column("answer")
>>> ds["train"].features
{'answer': ClassLabel(num_classes=2, names=['False', 'True']),
 'passage': Value('string'),
 'question': Value('string')}
```

#### push_to_hub[[datasets.DatasetDict.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1623)

**Parameter:**

repo_id (`str`) : ID repositori tujuan push dalam format berikut: `<user>/<dataset_name>` atau `<org>/<dataset_name>`. Juga menerima `<dataset_name>`, yang secara default akan menggunakan namespace pengguna yang sedang login. Bisa juga berupa lokasi di dalam bucket, misalnya `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`) : Nama konfigurasi dari dataset. Bawaan adalah "default".

set_default (`bool`, *opsional*) : Apakah akan mengatur konfigurasi ini sebagai konfigurasi default. Jika tidak, konfigurasi default adalah yang bernama "default".

data_dir (`str`, *opsional*) : Nama direktori yang akan berisi file data yang diunggah. Bawaan adalah `config_name` jika berbeda dari "default", jika tidak "data".

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan default ke `"Upload dataset"`.

commit_description (`str`, *opsional*) : Deskripsi dari commit yang akan dibuat. Selain itu, deskripsi dari PR jika PR dibuat (`create_pr` adalah True).

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat. Jika `None` (default), repo akan menjadi publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada.

token (`str`, *opsional*) : Token autentikasi opsional untuk Hugging Face Hub. Jika tidak ada token yang diteruskan, akan menggunakan token yang disimpan secara lokal saat login dengan `hf auth login`. Akan memicu error jika tidak ada token yang diteruskan dan pengguna tidak dalam keadaan login.

revision (`str`, *opsional*) : Cabang untuk mendorong file yang diunggah. Bawaan ke cabang `"main"`.

create_pr (`bool`, *opsional*, defaultnya `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit.

max_shard_size (`int` atau `str`, *opsional*, defaultnya `"500MB"`) : Ukuran maksimum dari shard dataset yang akan diunggah ke hub. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"500MB"` atau `"1GB"`).

num_shards (`Dict[str, int]`, *opsional*) : Jumlah shard yang akan ditulis. Secara default, jumlah shard bergantung pada `max_shard_size`. Gunakan kamus untuk mendefinisikan num_shards yang berbeda untuk setiap split.

embed_external_files (`bool`, defaultnya `True`) : Apakah akan menyematkan byte file ke dalam shard. Secara khusus, ini akan melakukan hal berikut sebelum push untuk field bertipe: - [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) dan [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image) menghapus informasi path lokal dan menyematkan konten file ke dalam file Parquet.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat menyiapkan dan mengunggah dataset. Ini berguna jika dataset terdiri dari banyak sampel atau file media untuk di-embed. I menggunakan konteks "spawn" untuk bekerja dengan hf_xet, klien rust untuk unggahan cepat ke HF. Multiprocessing dinonaktifkan secara default.

**Mengembalikan:**

huggingface_hub.CommitInfo

Mendorong [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) ke hub sebagai dataset Parquet. [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) didorong menggunakan permintaan HTTP dan tidak memerlukan instalasi git atau git-lfs.

Setiap split dataset akan didorong secara independen. Dataset yang didorong akan mempertahankan nama split aslinya.

File Parquet yang dihasilkan bersifat mandiri secara bawaan: jika dataset Anda berisi data [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image) atau [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio), file Parquet akan menyimpan byte dari file gambar atau audio Anda. Anda dapat menonaktifkan ini dengan mengatur `embed_external_files` ke False.

Contoh:

```python
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", num_shards={"train": 1024, "test": 8})
```

Jika Anda ingin menambahkan konfigurasi baru (atau subset) ke dataset (misalnya jika dataset memiliki beberapa tugas/versi/bahasa):

```python
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")
```

#### save_to_disk[[datasets.DatasetDict.save_to_disk]]

```python
save_to_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1301)

**Parameter:**

dataset_dict_path (`path-like`) : Path (misalnya `dataset/train`) atau URI jarak jauh (misalnya `s3://my-bucket/dataset/train`) dari direktori dataset dict tempat dataset dict akan disimpan.

max_shard_size (`int` atau `str`, *opsional*, defaultnya `"500MB"`) : Ukuran maksimum dari shard dataset yang akan disimpan ke filesystem. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"50MB"`).

num_shards (`Dict[str, int]`, *opsional*) : Jumlah shard yang akan ditulis. Secara default, jumlah shard bergantung pada `max_shard_size` dan `num_proc`. Anda perlu menyediakan jumlah shard untuk setiap dataset dalam kamus dataset. Gunakan kamus untuk mendefinisikan num_shards yang berbeda untuk setiap split.

num_proc (`int`, *opsional*, default `None`) : Jumlah proses saat mengunduh dan menghasilkan dataset secara lokal. Multiprocessing dinonaktifkan secara default.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

Menyimpan dataset dict ke sistem file menggunakan `fsspec.spec.AbstractFileSystem`.

Untuk data [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) dan [Video](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Video):

Semua data Image(), Audio() dan Video() disimpan dalam file arrow. Jika Anda ingin menyimpan path atau url, silakan gunakan tipe Value("string").

Contoh:

```python
>>> dataset_dict.save_to_disk("path/to/dataset/directory")
>>> dataset_dict.save_to_disk("path/to/dataset/directory", max_shard_size="1GB")
>>> dataset_dict.save_to_disk("path/to/dataset/directory", num_shards={"train": 1024, "test": 8})
```

#### load_from_disk[[datasets.DatasetDict.load_from_disk]]

```python
load_from_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1375)

**Parameter:**

dataset_dict_path (`path-like`) : Path (misalnya `"dataset/train"`) atau URI jarak jauh (misalnya `"s3//my-bucket/dataset/train"`) dari direktori dataset dict tempat dataset dict akan dimuat.

keep_in_memory (`bool`, defaultnya `None`) : Apakah dataset akan disalin ke memori. Jika `None`, dataset tidak akan disalin ke memori kecuali secara eksplisit diaktifkan dengan mengatur `datasets.config.IN_MEMORY_MAX_SIZE` ke nilai bukan nol. Lihat detail lebih lanjut di bagian [improve performance](../cache#improve-performance).

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

**Mengembalikan:**

[DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Muat dataset yang sebelumnya disimpan menggunakan `save_to_disk` dari sistem file menggunakan `fsspec.spec.AbstractFileSystem`.

Contoh:

```py
>>> ds = load_from_disk('path/to/dataset/directory')
```

#### from_csv[[datasets.DatasetDict.from_csv]]

```python
from_csv(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1435)

**Parameter:**

path_or_paths (`dict` of path-like) : Path dari file CSV.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (str, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `pandas.read_csv`.

**Mengembalikan:**

[DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Buat [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) dari file CSV.

Contoh:

```py
>>> from datasets import DatasetDict
>>> ds = DatasetDict.from_csv({'train': 'path/to/dataset.csv'})
```

#### from_json[[datasets.DatasetDict.from_json]]

```python
from_json(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1478)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file JSON Lines.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (str, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `JsonConfig`.

**Mengembalikan:**

[DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Buat [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) dari file JSON Lines.

Contoh:

```py
>>> from datasets import DatasetDict
>>> ds = DatasetDict.from_json({'train': 'path/to/dataset.json'})
```

#### from_parquet[[datasets.DatasetDict.from_parquet]]

```python
from_parquet(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1521)

**Parameter:**

path_or_paths (`dict` of path-like) : Path dari file CSV.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

columns (`list[str]`, *opsional*) : Jika bukan `None`, hanya kolom-kolom ini yang akan dibaca dari file. Nama kolom dapat berupa prefiks dari field bersarang, misalnya 'a' akan memilih 'a.b', 'a.c', dan 'a.d.e'.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `ParquetConfig`.

**Mengembalikan:**

[DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Buat [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) dari file Parquet.

Contoh:

```py
>>> from datasets import DatasetDict
>>> ds = DatasetDict.from_parquet({'train': 'path/to/dataset/parquet'})
```

#### from_text[[datasets.DatasetDict.from_text]]

```python
from_text(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1570)

**Parameter:**

path_or_paths (`dict` of path-like) : Path dari file teks.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

cache_dir (`str`, *opsional*, defaultnya `"~/.cache/huggingface/datasets"`) : Direktori untuk meng-cache data.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `TextConfig`.

**Mengembalikan:**

[DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict)

Buat [DatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetDict) dari file teks.

Contoh:

```py
>>> from datasets import DatasetDict
>>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'})
```

## IterableDataset[[datasets.IterableDataset]]

Kelas dasar [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset) mengimplementasikan Dataset yang dapat diiterasi dan didukung oleh generator python.

#### datasets.IterableDataset[[datasets.IterableDataset]]

```python
datasets.IterableDataset(ex_iterable: _BaseExamplesIterable, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, formatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = None, distributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = None, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2690)

Dataset yang didukung oleh iterable.

#### from_file[[datasets.IterableDataset.from_file]]

```python
from_file(filename: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3188)

**Parameter:**

filename (`str`) : Nama file dataset.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Instansiasi IterableDataset dari tabel Arrow di filename.

#### from_pandas[[datasets.IterableDataset.from_pandas]]

```python
from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None, num_shards: typing.Optional[int] = 1)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3204)

**Parameter:**

df (`pandas.DataFrame`) : Dataframe yang berisi dataset.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

preserve_index (`bool`, *opsional*) : Apakah menyimpan indeks sebagai kolom tambahan dalam Dataset yang dihasilkan. Nilai default `None` akan menyimpan indeks sebagai kolom, kecuali untuk `RangeIndex` yang hanya disimpan sebagai metadata. Gunakan `preserve_index=True` untuk memaksa indeks disimpan sebagai kolom.

num_shards (`int`, default `1`) : Jumlah shard yang didefinisikan saat menginstansiasi dataset iterable. Ini sangat berguna untuk dataset besar agar shuffle dapat dilakukan dengan benar, dan juga untuk memungkinkan pemuatan paralel yang cepat menggunakan PyTorch DataLoader atau dalam setup terdistribusi, misalnya.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Konversi `pandas.DataFrame` menjadi `pyarrow.Table` untuk membuat [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset).

Tipe kolom dalam Arrow Table yang dihasilkan disimpulkan dari dtype dari `pandas.Series` dalam DataFrame. Untuk Series non-object, dtype NumPy diterjemahkan ke padanan Arrow-nya. Untuk `object`, kita perlu menebak tipe data dengan melihat objek Python dalam Series ini.

Perhatikan bahwa Series dengan dtype `object` tidak membawa informasi yang cukup untuk selalu menghasilkan tipe Arrow yang bermakna. Dalam kasus di mana tipe tidak dapat disimpulkan, misalnya karena DataFrame memiliki panjang 0 atau Series hanya berisi objek `None/nan`, tipe akan diatur ke `null`. Perilaku ini dapat dihindari dengan membuat fitur secara eksplisit dan meneruskannya ke fungsi ini.

Penting: dataset yang dibuat dengan from_pandas() disimpan di memori. Hal ini mungkin berubah di masa depan, tetapi sementara itu, jika Anda ingin mengurangi penggunaan memori, sebaiknya tulis dataset tersebut ke disk dan muat ulang menggunakan, misalnya, to_parquet / from_parquet.

Contoh:

```py
>>> ds = IterableDataset.from_pandas(df)
```

#### from_dict[[datasets.IterableDataset.from_dict]]

```python
from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3316)

**Parameter:**

mapping (`Mapping`) : Pemetaan string ke Array atau daftar Python.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

info (`DatasetInfo`, *opsional*) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, *opsional*) : Nama dari split dataset.

num_shards (`int`, default `1`) : Jumlah shard yang didefinisikan saat menginstansiasi dataset iterable. Ini sangat berguna untuk dataset besar agar shuffle dapat dilakukan dengan benar, dan juga untuk memungkinkan pemuatan paralel yang cepat menggunakan PyTorch DataLoader atau dalam setup terdistribusi, misalnya.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Konversi `dict` menjadi `pyarrow.Table` untuk membuat [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset).

Penting: dataset yang dibuat dengan from_dict() disimpan di memori. Hal ini mungkin berubah di masa depan, tetapi sementara itu, jika Anda ingin mengurangi penggunaan memori, Anda sebaiknya menuliskannya kembali ke disk dan memuat ulang menggunakan, misalnya, to_parquet / from_parquet.

#### from_list[[datasets.IterableDataset.from_list]]

```python
from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3353)

**Parameter:**

mapping (`List[dict]`) : Daftar pemetaan string ke nilai baris.

features (`Features`, opsional) : Fitur dataset.

info (`DatasetInfo`, opsional) : Informasi dataset, seperti deskripsi, sitasi, dll.

split (`NamedSplit`, opsional) : Nama dari split dataset.

num_shards (`int`, default `1`) : Jumlah shard yang didefinisikan saat menginstansiasi dataset iterable. Ini sangat berguna untuk dataset besar agar shuffle dapat dilakukan dengan benar, dan juga untuk memungkinkan pemuatan paralel yang cepat menggunakan PyTorch DataLoader atau dalam setup terdistribusi, misalnya.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Konversi daftar dict menjadi `pyarrow.Table` untuk membuat [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset).

Perhatikan bahwa kunci dari entri pertama akan digunakan untuk menentukan kolom dataset, terlepas dari apa yang diteruskan ke features.

Penting: dataset yang dibuat dengan from_list() disimpan di memori. Hal ini mungkin berubah di masa depan, tetapi sementara itu, jika Anda ingin mengurangi penggunaan memori, Anda sebaiknya menuliskannya kembali ke disk dan memuat ulang menggunakan, misalnya, from_parquet / to_parquet.

#### from_generator[[datasets.IterableDataset.from_generator]]

```python
from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, gen_kwargs: typing.Optional[dict] = None, split: NamedSplit = NamedSplit('train'))
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3090)

**Parameter:**

generator (`Callable`) : Fungsi generator yang `yields` contoh.

features (`Features`, *opsional*) : Fitur dataset.

gen_kwargs(`dict`, *opsional*) : Argumen kata kunci yang akan diteruskan ke callable `generator`. Anda dapat mendefinisikan dataset iterable yang terbagi (sharded) dengan meneruskan daftar shard di `gen_kwargs`. Hal ini dapat digunakan untuk meningkatkan pengacakan (shuffling) dan saat mengiterasi dataset dengan beberapa worker.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), defaultnya `Split.TRAIN`) : Nama split yang akan ditugaskan ke dataset.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Buat Iterable Dataset dari generator.

Contoh:

```py
>>> def gen():
...     yield {"text": "Good", "label": 0}
...     yield {"text": "Bad", "label": 1}
...
>>> ds = IterableDataset.from_generator(gen)
```

```py
>>> def gen(shards):
...     for shard in shards:
...         with open(shard) as f:
...             for line in f:
...                 yield {"line": line}
...
>>> shards = [f"data{i}.txt" for i in range(32)]
>>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards})
>>> ds = ds.shuffle(seed=42, buffer_size=10_000)  # shuffles the shards order + uses a shuffle buffer
>>> from torch.utils.data import DataLoader
>>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4)  # give each worker a subset of 32/4=8 shards
```

#### remove_columns[[datasets.IterableDataset.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4343)

**Parameter:**

column_names (`Union[str, List[str]]`) : Nama kolom yang akan dihapus.

**Mengembalikan:** `IterableDataset`

Salinan objek dataset tanpa kolom yang akan dihapus.

Hapus satu atau beberapa kolom dalam dataset beserta fitur yang terkait dengan kolom tersebut. Penghapusan dilakukan secara langsung pada contoh saat iterasi dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> next(iter(ds))
{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1}
>>> ds = ds.remove_columns("label")
>>> next(iter(ds))
{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### select_columns[[datasets.IterableDataset.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4378)

**Parameter:**

column_names (`Union[str, List[str]]`) : Nama kolom yang akan dipilih.

**Mengembalikan:** `IterableDataset`

Salinan objek dataset dengan kolom yang dipilih.

Pilih satu atau beberapa kolom dalam dataset beserta fitur yang terkait dengannya. Pemilihan dilakukan secara langsung pada contoh saat melakukan iterasi pada dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> next(iter(ds))
{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1}
>>> ds = ds.select_columns("text")
>>> next(iter(ds))
{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### cast_column[[datasets.IterableDataset.cast_column]]

```python
cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4428)

**Parameter:**

column (`str`) : Nama kolom.

feature (`Feature`) : Fitur target.

**Mengembalikan:** `IterableDataset`

Cast kolom ke fitur untuk decoding.

Contoh:

```py
>>> from datasets import load_dataset, Audio
>>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train", streaming=True)
>>> ds.features
{'audio': Audio(sampling_rate=8000, mono=True, decode=True, id=None),
 'english_transcription': Value('string'),
 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan',  'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']),
 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR',  'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']),
 'path': Value('string'),
 'transcription': Value('string')}
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> ds.features
{'audio': Audio(sampling_rate=16000, mono=True, decode=True, id=None),
 'english_transcription': Value('string'),
 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan',  'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill']),
 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR',  'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN']),
 'path': Value('string'),
 'transcription': Value('string')}
```

#### cast[[datasets.IterableDataset.cast]]

```python
cast(features: Features)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4474)

**Parameter:**

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features)) : Fitur baru untuk mengubah tipe dataset. Nama kolom dalam fitur harus sesuai dengan nama kolom saat ini. Tipe data juga harus dapat dikonversi dari satu tipe ke tipe lainnya. Untuk konversi yang tidak sederhana, misalnya `string` <-> `ClassLabel`, gunakan [map()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Dataset.map) untuk memperbarui Dataset.

**Mengembalikan:** `IterableDataset`

Salinan dataset dengan fitur yang telah di-cast.

Cast dataset ke set fitur baru.

Contoh:

```py
>>> from datasets import load_dataset, ClassLabel, Value
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> ds.features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds.features.copy()
>>> new_features["label"] = ClassLabel(names=["bad", "good"])
>>> new_features["text"] = Value("large_string")
>>> ds = ds.cast(new_features)
>>> ds.features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### decode[[datasets.IterableDataset.decode]]

```python
decode(enable: bool = True, num_threads: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4520)

**Parameter:**

enable (`bool`, defaultnya `True`) : Mengaktifkan atau menonaktifkan fitur decoding.

num_threads (`int`, *opsional*, defaultnya `None`) : Aktifkan multithreading untuk decoding fitur. Perhatikan bahwa [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset) sudah menggunakan beberapa thread secara default saat streaming dataset di HF dengan fitur yang dapat didekode. Secara default, `num_threads` diatur ke 32 jika setidaknya satu fitur memerlukan decoding, dan 0 jika tidak.

**Mengembalikan:** `IterableDataset`

Salinan dataset dengan fitur yang telah di-cast.

Aktifkan atau nonaktifkan decoding fitur dataset untuk audio, gambar, dan video.

Saat diaktifkan (default), tipe media akan didekodekan:

* audio -> dict berisi "array" dan "sampling_rate" dan "path"
* image -> PIL.Image
* video -> torchcodec.decoders.VideoDecoder

Multithreading dapat diaktifkan dengan `num_threads`: setiap file media kemudian dibaca dan didekodekan di dalam worker thread, sehingga round trip jaringan dari contoh yang berurutan dapat tumpang tindih. Hal ini sangat berguna untuk mempercepat streaming data jarak jauh, dan [load_dataset()](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.load_dataset) sudah mengaktifkannya secara default saat melakukan streaming dataset jarak jauh yang memiliki fitur yang dapat didekodekan (lihat `HF_DATASETS_DECODE_NUM_THREADS`). Dataset yang dibaca dari disk lokal di-stream dengan `num_threads=0`, karena multithreading bisa lebih lambat daripada dekoding di thread utama untuk data lokal pada disk yang cepat. Karena contoh didekodekan di muka, setiap thread yang sedang berjalan dapat menyimpan satu contoh di memori: turunkan `num_threads` untuk menggunakan memori lebih sedikit.

Menonaktifkan decoding berguna jika Anda ingin mengiterasi path atau byte dari file media tanpa benar-benar mendekode kontennya. Untuk menonaktifkan decoding, Anda dapat menggunakan `.decode(False)`, yang setara dengan memanggil `.cast()` atau `.cast_column()` dengan semua tipe Audio, Image, dan Video diset ke `decode=False`.

Contoh:

Nonaktifkan decoding:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True)
>>> next(iter(ds))
{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=2048x1024>,
'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'}
>>> ds = ds.decode(False)
>>> ds.features
{'image': Image(mode=None, decode=False, id=None),
'text': Value('string')}
>>> next(iter(ds))
{
  'image': {
    'path': 'hf://datasets/sshh12/planet-textures@69dc4cef7a5c4b2cfe387727ec8ea73d4bff7302/train/textures/0000.png',
    'bytes': None
  },
  'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'
}
```

Percepat streaming dengan multithreading:

```py
>>> import os
>>> from datasets import load_dataset
>>> from tqdm import tqdm
>>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True)
>>> # already threaded by default with 32 threads, but more threads can help going even faster
>>> ds = ds.decode(num_threads=64)
>>> for _ in tqdm(ds):  # 2 times faster !
...     ...
```

#### __iter__[[datasets.IterableDataset.__iter__]]

```python
__iter__()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3035)

#### iter[[datasets.IterableDataset.iter]]

```python
iter(batch_size: int, drop_last_batch: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3056)

**Parameter:**

batch_size (`int`) : ukuran setiap batch yang dihasilkan.

drop_last_batch (`bool`, default *False*) : Apakah batch terakhir yang lebih kecil dari batch_size harus dibuang

Iterasi melalui batch berukuran *batch_size*.

#### map[[datasets.IterableDataset.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, features: typing.Optional[datasets.features.features.Features] = None, fn_kwargs: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3676)

**Parameter:**

function (`Callable`, *opsional*, defaultnya `None`) : Fungsi yang diterapkan secara langsung pada contoh saat Anda mengiterasi dataset. Fungsi ini harus memiliki salah satu dari tanda tangan berikut:  - `function(example: Dict[str, Any]) -> Dict[str, Any]` jika `batched=False` dan `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` jika `batched=False` dan `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` jika `batched=True` dan `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` jika `batched=True` dan `with_indices=True`  Untuk penggunaan lanjutan, fungsi juga dapat mengembalikan `pyarrow.Table`. Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel. Selain itu, jika fungsi Anda tidak mengembalikan apa pun (`None`), maka `map` akan menjalankan fungsi Anda dan mengembalikan dataset tanpa perubahan. Jika tidak ada fungsi yang disediakan, defaultnya adalah fungsi identitas: `lambda x: x`.

with_indices (`bool`, defaultnya `False`) : Menyediakan indeks contoh untuk `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx[, rank]): ...`.

input_columns (`Optional[Union[str, List[str]]]`, defaultnya `None`) : Kolom-kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, sebuah dict yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True`. Jika `batch_size <= 0` atau `batch_size == None`, maka seluruh dataset diberikan sebagai satu batch ke `function`.

drop_last_batch (`bool`, defaultnya `False`) : Apakah batch terakhir yang lebih kecil dari batch_size harus dibuang alih-alih diproses oleh fungsi.

remove_columns (`[List[str]]`, *opsional*, defaultnya `None`) : Menghapus pilihan kolom saat melakukan pemetaan. Kolom akan dihapus sebelum memperbarui contoh dengan output dari `function`, yaitu jika `function` menambahkan kolom dengan nama yang ada di `remove_columns`, kolom-kolom ini akan tetap dipertahankan.

features (`[Features]`, *opsional*, defaultnya `None`) : Jenis fitur dari dataset yang dihasilkan.

fn_kwargs (`Dict`, *opsional*, default `None`) : Argumen kata kunci yang akan diteruskan ke `function`.

Terapkan fungsi ke semua contoh dalam dataset iterable (secara individual atau dalam batch) dan perbarui mereka. Jika fungsi Anda mengembalikan kolom yang sudah ada, maka kolom tersebut akan ditimpa. Fungsi diterapkan secara langsung pada contoh saat iterasi dataset.

Anda dapat menentukan apakah fungsi harus di-batch atau tidak dengan parameter `batched`:

- Jika `False`, fungsi menerima 1 contoh dan harus mengembalikan 1 contoh. Contoh adalah kamus, misalnya `{"text": "Hello there !"}`.
- Jika `True` dan `batch_size` adalah 1, maka fungsi mengambil batch berisi 1 contoh sebagai input dan dapat mengembalikan batch berisi 1 atau lebih contoh. Batch adalah kamus, misalnya batch berisi 1 contoh adalah {"text": ["Hello there !"]}.
- Jika `True` dan `batch_size` adalah `n` > 1, maka fungsi tersebut mengambil batch berisi `n` contoh sebagai input dan dapat mengembalikan batch berisi `n` contoh, atau dengan jumlah contoh yang sembarang. Perhatikan bahwa batch terakhir mungkin memiliki kurang dari `n` contoh. Batch adalah kamus, misalnya batch berisi `n` contoh adalah `{"text": ["Hello there !"] * n}`.

Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel, dengan hingga seribu panggilan simultan. Disarankan untuk menggunakan `asyncio.Semaphore` di dalam fungsi Anda jika Anda ingin menetapkan jumlah maksimum operasi yang dapat berjalan pada saat yang sama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> def add_prefix(example):
...     example["text"] = "Review: " + example["text"]
...     return example
>>> ds = ds.map(add_prefix)
>>> list(ds.take(3))
[{'label': 1,
 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'Review: effective but too-tepid biopic'}]
```

#### rename_column[[datasets.IterableDataset.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4288)

**Parameter:**

original_column_name (`str`) : Nama kolom yang akan diganti namanya.

new_column_name (`str`) : Nama baru untuk kolom.

**Mengembalikan:** `IterableDataset`

Salinan dataset dengan kolom yang namanya diubah.

Ganti nama kolom dalam dataset, dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> next(iter(ds))
{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
>>> ds = ds.rename_column("text", "movie_review")
>>> next(iter(ds))
{'label': 1,
 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### filter[[datasets.IterableDataset.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3858)

**Parameter:**

function (`Callable`) : Callable dengan salah satu dari signature berikut: - `function(example: Dict[str, Any]) -> bool` jika `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` jika `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` jika `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` jika `with_indices=True, batched=True` Jika fungsi bersifat asinkron, maka `filter` akan menjalankan fungsi Anda secara paralel. Jika tidak ada fungsi yang diberikan, defaultnya adalah fungsi yang selalu True: `lambda x: True`.

with_indices (`bool`, defaultnya `False`) : Berikan indeks contoh ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx): ...`.

input_columns (`str` atau `List[str]`, *opsional*) : Kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, dict yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, default `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True`.

fn_kwargs (`Dict`, *opsional*, default `None`) : Argumen kata kunci yang akan diteruskan ke `function`.

Terapkan fungsi filter ke semua elemen sehingga dataset hanya mencakup contoh sesuai dengan fungsi filter tersebut. Pemfilteran dilakukan secara langsung saat iterasi dataset.

Jika fungsi bersifat asinkron, maka `filter` akan menjalankan fungsi Anda secara paralel, dengan hingga seribu panggilan simultan (dapat dikonfigurasi). Disarankan untuk menggunakan `asyncio.Semaphore` di dalam fungsi Anda jika Anda ingin menetapkan jumlah maksimum operasi yang dapat berjalan pada saat yang sama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> ds = ds.filter(lambda x: x["label"] == 0)
>>> list(ds.take(3))
[{'label': 0, 'movie_review': 'simplistic , silly and tedious .'},
 {'label': 0,
 'movie_review': "it's so laddish and juvenile , only teenage boys could possibly find it funny ."},
 {'label': 0,
 'movie_review': 'exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}]
```

#### shuffle[[datasets.IterableDataset.shuffle]]

```python
shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3961)

**Parameter:**

seed (`int`, *opsional*, defaultnya `None`) : Random seed yang akan digunakan untuk mengacak dataset. Seed ini digunakan untuk mengambil sampel dari buffer shuffle dan juga untuk mengacak shard data.

generator (`numpy.random.Generator`, *opsional*) : Generator acak Numpy yang digunakan untuk menghitung permutasi baris dataset. Jika `generator=None` (default), menggunakan `np.random.default_rng` (BitGenerator default (PCG64) dari NumPy).

buffer_size (`int`, defaultnya `1000`) : Ukuran buffer.

max_buffer_input_shards (`int`, defaultnya `10`) : Jumlah maksimum shard yang digunakan untuk mengisi buffer sekaligus.

Mengacak elemen dataset ini secara acak.

Dataset ini mengisi buffer dengan `buffer_size` elemen, kemudian mengambil sampel elemen secara acak dari buffer ini, menggantikan elemen yang dipilih dengan elemen baru. Untuk pengacakan sempurna, ukuran buffer harus lebih besar dari atau sama dengan ukuran penuh dataset.

Sebagai contoh, jika dataset Anda berisi 10.000 elemen tetapi `buffer_size` diatur ke 1000, maka `shuffle` awalnya akan memilih elemen acak hanya dari 1000 elemen pertama di buffer. Setelah sebuah elemen dipilih, ruang elemennya di buffer digantikan oleh elemen berikutnya (yaitu elemen ke-1.001), sehingga buffer tetap berisi 1000 elemen.

Jika dataset terdiri dari beberapa shard, buffer diisi menggunakan hingga `max_buffer_input_shards` shard pada satu waktu dan urutan shard juga diacak. Hal ini sangat meningkatkan kualitas pengacakan. Shard input diinterleaved di dalam setiap node dan worker, dengan mempertahankan jumlah shard yang tersedia untuk pemuatan data paralel.

Namun, jika urutan telah diperbaiki dengan menggunakan [skip()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.skip) atau [take()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.take), maka urutan shard tetap tidak berubah dan hanya satu shard pada satu waktu yang digunakan untuk mengisi buffer.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> list(ds.take(3))
[{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .',
 'label': 1},
 {'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .',
 'label': 1},
 {'text': 'effective but too-tepid biopic', 'label': 1}]
>>> shuffled_ds = ds.shuffle(seed=42)
>>> list(shuffled_ds.take(3))
[{'text': "a sports movie with action that's exciting on the field and a story you care about off it .",
 'label': 1},
 {'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .',
 'label': 1},
 {'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune .",
 'label': 1}]
>>> resharded_ds = ds.reshard()  # useful to shard Parquet datasets by row group instead of by file, improving shuffling quality on dataset with one or few files.
>>> shuffled_resharded_ds = resharded_ds.shuffle(seed=42)
>>> list(shuffled_resharded_ds.take(3))
[{'text': 'this mistaken-identity picture is so film-culture referential that the final product is a ghost .',
 'label': 0},
 {'text': 'woody allen used to ridicule movies like hollywood ending . now he makes them .',
 'label': 0},
 {'text': "not only is undercover brother as funny , if not more so , than both austin powers films , but it's also one of the smarter , savvier spoofs to come along in some time .",
 'label': 1}]
```

#### batch[[datasets.IterableDataset.batch]]

```python
batch(batch_size: typing.Optional[int] = None, by_column: typing.Union[str, list[str], NoneType] = None, drop_last_batch: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4657)

**Parameter:**

batch_size (`int`, opsional) : Jumlah sampel dalam setiap batch.

by_column (`Union[str, list[str]`, opsional) : Kolom yang digunakan untuk mengelompokkan contoh ke dalam batch. Contoh berurutan dengan nilai yang sama untuk kolom tersebut dikelompokkan ke dalam batch yang sama. Ini juga bisa berupa daftar kolom jika Anda ingin melakukan batching berdasarkan beberapa kolom. Jika melakukan batching berdasarkan kolom, batch_size hanya digunakan untuk mengontrol ukuran batch yang akan dikelompokkan atau dipotong selama akumulasi.

drop_last_batch (`bool`, defaultnya `False`) : Apakah akan membuang batch terakhir yang tidak lengkap.

Kelompokkan sampel dari dataset menjadi batch.

Contoh:

Ukuran batch tetap:

```py
>>> ds = load_dataset("some_dataset", streaming=True, split="train")
>>> batched_ds = ds.batch(batch_size=32)
```

Batch dari sampel berurutan dengan nilai identik untuk "my_column":

```py
>>> ds = load_dataset("some_dataset", streaming=True, split="train")
>>> batched_ds = ds.batch(by_column="my_column")
```

#### lewati[[datasets.IterableDataset.skip]]

```python
skip(n: int)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4058)

**Parameter:**

n (`int`) : Jumlah elemen yang akan dilewati.

Buat [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset) baru yang melewati `n` elemen pertama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> list(ds.take(3))
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'}]
>>> ds = ds.skip(1)
>>> list(ds.take(3))
[{'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'},
 {'label': 1,
 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}]
```

#### ambil[[datasets.IterableDataset.take]]

```python
take(n: int)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4144)

**Parameter:**

n (`int`) : Jumlah elemen yang diambil.

Buat [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset) baru dengan hanya `n` elemen pertama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> small_ds = ds.take(2)
>>> list(small_ds)
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}]
```

#### shard[[datasets.IterableDataset.shard]]

```python
shard(num_shards: int, index: int, contiguous: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4179)

**Parameter:**

num_shards (`int`) : Berapa banyak shard untuk membagi dataset.

index (`int`) : Shard mana yang akan dipilih dan dikembalikan.

contiguous : (`bool`, defaultnya `True`): Apakah akan memilih blok indeks yang berurutan untuk shard.

Kembalikan shard ke-`index` dari dataset yang dipecah menjadi `num_shards` bagian.

Ini memecah secara deterministik. `dataset.shard(n, i)` membagi dataset menjadi potongan-potongan yang berurutan, sehingga dapat dengan mudah digabungkan kembali setelah diproses. Jika `dataset.num_shards % n == l`, maka `l` dataset pertama masing-masing memiliki `(dataset.num_shards // n) + 1` shard, dan dataset sisanya memiliki `(dataset.num_shards // n)` shard. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` mengembalikan dataset dengan urutan yang sama seperti aslinya. Secara khusus, `dataset.shard(dataset.num_shards, i)` mengembalikan dataset dengan 1 shard.

Catatan: n harus kurang dari atau sama dengan jumlah shard dalam dataset `dataset.num_shards`.

Di sisi lain, `dataset.shard(n, i, contiguous=False)` berisi semua shard dari dataset yang indeksnya mod `n = i`.

Pastikan untuk melakukan sharding sebelum menggunakan operator acak (seperti `shuffle`). Sebaiknya operator sharding digunakan di awal pipeline dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True)
>>> ds
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 4
})
>>> ds.shard(num_shards=2, index=0)
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 2
})
```

#### reshard[[datasets.IterableDataset.reshard]]

```python
reshard()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4235)

Reshard dataset jika memungkinkan, yaitu dengan memecah shard saat ini lebih lanjut menjadi shard yang lebih banyak. Hal ini meningkatkan jumlah shard dan dataset yang dihasilkan memiliki num_shards >= previous_num_shards. Kesamaan dapat terjadi jika tidak ada shard yang dapat dipecah lebih lanjut.

Mekanisme resharding bergantung pada format file dataset:

* Parquet: shard per grup baris, bukan per file
* Vortex: shard per rentang chunk berurutan (masing-masing sekitar 64MB data file) alih-alih per file
* Lainnya: belum diimplementasikan (kontribusi disambut baik!)

Pastikan untuk melakukan reshard/shard sebelum menggunakan operator acak (seperti `shuffle`). Sebaiknya operator shard digunakan di awal pipeline dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True)
>>> ds
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 4
})
>>> ds.reshard()
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 3600
})
```

#### repeat[[datasets.IterableDataset.repeat]]

```python
repeat(num_times: typing.Optional[int])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4100)

**Parameter:**

num_times (`int`) atau (`None`) : Jumlah pengulangan dataset. Jika `None`, dataset akan diulang tanpa batas.

Buat [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset) baru yang mengulang dataset dasar sebanyak `num_times` kali.

Input kosong mengakhiri proses bahkan ketika `num_times` adalah `None`.

N.B. Efek pemanggilan shuffle setelah repeat sangat bergantung pada ukuran buffer. Dengan buffer_size 1, data duplikat tidak pernah terlihat dalam iterasi yang sama, bahkan setelah pengacakan: ds.repeat(n).shuffle(seed=42, buffer_size=1) ekuivalen dengan ds.shuffle(seed=42, buffer_size=1).repeat(n), dan hanya mengacak urutan shard di dalam setiap iterasi. Dengan ukuran buffer >= (jumlah sampel dalam dataset * num_times), kita mendapatkan pengacakan penuh dari data yang diulang, yaitu kita dapat mengamati duplikat dalam iterasi yang sama.

Contoh:
```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> ds = ds.take(2).repeat(2)
>>> list(ds)
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'},
 {'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'}]
```

#### to_csv[[datasets.IterableDataset.to_csv]]

```python
to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4856)

**Parameter:**

path_or_buf (`PathLike` atau `FileOrBuffer`) : Baik berupa path ke file (mis. `file.csv`), URI jarak jauh (mis. `hf://datasets/username/my_dataset_name/data.csv`), atau BinaryIO, tempat dataset akan disimpan dalam format yang ditentukan.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

- ****to_csv_kwargs** (argumen kata kunci tambahan) : Parameter untuk diteruskan ke [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) dari pandas. Parameter `index` secara default bernilai `False` jika tidak ditentukan. Jika Anda ingin menulis indeks, teruskan `index=True` dan juga atur nama untuk kolom indeks dengan meneruskan `index_label`.

**Mengembalikan:** `int`

Jumlah karakter atau byte yang ditulis.

Mengekspor dataset ke csv.

Ini mengiterasi dataset dan memuatnya sepenuhnya ke memori sebelum menuliskannya.

Contoh:

```py
>>> ds.to_csv("path/to/dataset/directory")
```

#### to_pandas[[datasets.IterableDataset.to_pandas]]

```python
to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4777)

**Parameter:**

batch_size (`int`, *opsional*) : Ukuran (jumlah baris) dari batch jika `batched` adalah `True`. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

batched (`bool`) : Setel ke `True` untuk mengembalikan generator yang menghasilkan dataset sebagai batch berisi `batch_size` baris. Defaultnya adalah `False` (mengembalikan seluruh dataset sekali).

**Mengembalikan:**

`pandas.DataFrame` atau `Iterator[pandas.DataFrame]`

Mengembalikan dataset sebagai `pandas.DataFrame`. Dapat juga mengembalikan generator untuk dataset besar.

Contoh:

```py
>>> ds.to_pandas()
```

#### to_dict[[datasets.IterableDataset.to_dict]]

```python
to_dict(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4737)

**Parameter:**

batch_size (`int`, *opsional*) : Ukuran (jumlah baris) dari batch jika `batched` adalah `True`. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

**Mengembalikan:**

`dict` atau `Iterator[dict]`

Mengembalikan dataset sebagai dict Python. Dapat juga mengembalikan generator untuk dataset besar.

Contoh:

```py
>>> ds.to_dict()
```

#### to_json[[datasets.IterableDataset.to_json]]

```python
to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4899)

**Parameter:**

path_or_buf (`PathLike` atau `FileOrBuffer`) : Baik berupa path ke file (mis. `file.json`), URI jarak jauh (mis. `hf://datasets/username/my_dataset_name/data.json`), atau BinaryIO, tempat dataset akan disimpan dalam format yang ditentukan.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

- ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`.

**Mengembalikan:** `int`

Jumlah karakter atau byte yang ditulis.

Ekspor dataset ke JSON Lines atau JSON.

Ini mengiterasi dataset dan memuatnya sepenuhnya ke memori sebelum menuliskannya.

Format output default adalah [JSON Lines](https://jsonlines.org/). Untuk mengekspor ke [JSON](https://www.json.org), berikan argumen `lines=False` dan `orient` yang diinginkan.

Contoh:

```py
>>> ds.to_json("path/to/dataset/directory/filename.jsonl")
```

```py
>>> num_shards = dataset.num_shards
>>> for index in range(num_shards):
...     shard = dataset.shard(index, num_shards)
...     shard.to_json(f"path/of/my/dataset/data-{index:05d}.jsonl")
```

#### to_parquet[[datasets.IterableDataset.to_parquet]]

```python
to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4995)

**Parameter:**

path_or_buf (`PathLike` atau `FileOrBuffer`) : Baik berupa path ke file (mis. `file.parquet`), URI remote (mis. `hf://datasets/username/my_dataset_name/data.parquet`), atau BinaryIO, tempat dataset akan disimpan dalam format yang ditentukan.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

storage_options (`dict`, *opsional*) : Pasangan key/value yang akan diteruskan ke backend file-system, jika ada.

- ****parquet_writer_kwargs** (argumen kata kunci tambahan) : Parameter untuk diteruskan ke `pyarrow.parquet.ParquetWriter` dari PyArrow.

**Mengembalikan:** `int`

Jumlah karakter atau byte yang ditulis.

Mengekspor dataset ke parquet

Contoh:

```py
>>> ds.to_parquet("path/to/dataset/directory")
```

```py
>>> num_shards = dataset.num_shards
>>> for index in range(num_shards):
...     shard = dataset.shard(index, num_shards)
...     shard.to_parquet(f"path/of/my/dataset/data-{index:05d}.parquet")
```

#### to_sql[[datasets.IterableDataset.to_sql]]

```python
to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, **sql_writer_kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4953)

**Parameter:**

name (`str`) : Nama tabel SQL.

con (`str` atau `sqlite3.Connection` atau `sqlalchemy.engine.Connection` atau `sqlalchemy.engine.Connection`) : String [URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) atau objek koneksi SQLite3/SQLAlchemy yang digunakan untuk menulis ke database.

batch_size (`int`, *opsional*) : Ukuran batch untuk dimuat ke memori dan ditulis sekaligus. Bawaan adalah `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

- ****sql_writer_kwargs** (argumen kata kunci tambahan) : Parameter untuk diteruskan ke [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) dari pandas. Parameter `index` secara default bernilai `False` jika tidak ditentukan. Jika Anda ingin menulis indeks, teruskan `index=True` dan juga atur nama untuk kolom indeks dengan meneruskan `index_label`.

**Mengembalikan:** `int`

Jumlah rekaman yang ditulis.

Mengekspor dataset ke basis data SQL.

Contoh:

```py
>>> # con provided as a connection URI string
>>> ds.to_sql("data", "sqlite:///my_own_db.sql")
>>> # con provided as a sqlite3 connection object
>>> import sqlite3
>>> con = sqlite3.connect("my_own_db.sql")
>>> with con:
...     ds.to_sql("data", con)
```

#### push_to_hub[[datasets.IterableDataset.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L5330)

**Parameter:**

repo_id (`str`) : ID repositori tujuan push dalam format berikut: `<user>/<dataset_name>` atau `<org>/<dataset_name>`. Juga menerima `<dataset_name>`, yang secara default akan menggunakan namespace pengguna yang sedang login. Bisa juga berupa lokasi di dalam bucket, misalnya `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`, defaultnya "default") : Nama konfigurasi (atau subset) dari dataset. Defaultnya "default".

set_default (`bool`, *opsional*) : Apakah akan mengatur konfigurasi ini sebagai konfigurasi default. Jika tidak, konfigurasi default adalah yang bernama "default".

split (`str`, *opsional*) : Nama split yang akan diberikan ke dataset tersebut. Defaultnya adalah `self.split`.

data_dir (`str`, *opsional*) : Nama direktori yang akan berisi file data yang diunggah. Bawaan adalah `config_name` jika berbeda dari "default", jika tidak "data".

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan default ke `"Upload dataset"`.

commit_description (`str`, *opsional*) : Deskripsi dari commit yang akan dibuat. Selain itu, deskripsi dari PR jika PR dibuat (`create_pr` adalah True).

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat. Jika `None` (default), repo akan menjadi publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada.

token (`str`, *opsional*) : Token autentikasi opsional untuk Hugging Face Hub. Jika tidak ada token yang diteruskan, akan menggunakan token yang disimpan secara lokal saat login dengan `hf auth login`. Akan memicu error jika tidak ada token yang diteruskan dan pengguna tidak dalam keadaan login.

revision (`str`, *opsional*) : Cabang untuk mendorong file yang diunggah. Bawaan ke cabang `"main"`.

create_pr (`bool`, *opsional*, defaultnya `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit.

max_shard_size (`int` atau `str`, *opsional*) : Ukuran maksimum opsional untuk shard dataset yang akan diunggah ke hub. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"5MB"`). Jika tidak disediakan, jumlah shard secara default mengikuti `.num_shards` dari dataset ini.

num_shards (`int`, *opsional*) : Jumlah shard yang akan ditulis. Jika `max_shard_size` diberikan dan `num_shards` tidak, maka jumlah shard diperkirakan dari `max_shard_size`. Nilai ini bisa lebih besar dari `.num_shards` dataset ini: setiap shard input kemudian disebar ke beberapa shard output dengan menulis contoh-contohnya secara bergiliran (round-robin).

embed_external_files (`bool`, defaultnya `True`) : Apakah akan menyematkan byte file ke dalam shard. Secara khusus, ini akan melakukan hal berikut sebelum push untuk field bertipe: - [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) dan [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image): menghapus informasi path lokal dan menyematkan konten file ke dalam file Parquet.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat menyiapkan dan mengunggah dataset. Ini berguna jika dataset terdiri dari banyak sampel dan transformasi. I menggunakan konteks "spawn" untuk bekerja dengan hf_xet, klien rust untuk unggahan cepat ke HF. Multiprocessing dinonaktifkan secara default.

**Mengembalikan:**

huggingface_hub.CommitInfo

Mendorong dataset ke hub sebagai dataset Parquet. Dataset didorong menggunakan permintaan HTTP dan tidak memerlukan instalasi git atau git-lfs.

File Parquet yang dihasilkan bersifat mandiri secara bawaan. Jika dataset Anda berisi data [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) atau [Video](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Video), file Parquet akan menyimpan byte dari file gambar atau audio Anda. Anda dapat menonaktifkan ini dengan mengatur `embed_external_files` ke `False`.

Contoh:

```python
>>> dataset.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)
```

Jika dataset Anda memiliki beberapa split (misalnya train/validation/test):

```python
>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train")
>>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation")
>>> # later
>>> dataset = load_dataset("<organization>/<dataset_id>")
>>> train_dataset = dataset["train"]
>>> val_dataset = dataset["validation"]
```

Jika Anda ingin menambahkan konfigurasi baru (atau subset) ke dataset (misalnya jika dataset memiliki beberapa tugas/versi/bahasa):

```python
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")
```

#### load_state_dict[[datasets.IterableDataset.load_state_dict]]

```python
load_state_dict(state_dict: dict)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2800)

Muat state_dict dari dataset. Iterasi akan dimulai ulang dari contoh berikutnya setelah state disimpan.

Melanjutkan proses akan kembali tepat ke titik di mana checkpoint disimpan, kecuali dalam dua kasus berikut:

1. contoh dari buffer shuffle hilang saat melanjutkan dan buffer diisi ulang dengan data baru
2. kombinasi `.with_format(arrow)` dan `.map()` yang di-batch dapat melewatkan satu batch.

Contoh:

```py
>>> from datasets import Dataset, concatenate_datasets
>>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3)
>>> for idx, example in enumerate(ds):
...     print(example)
...     if idx == 2:
...         state_dict = ds.state_dict()
...         print("checkpoint")
...         break
>>> ds.load_state_dict(state_dict)
>>> print(f"restart from checkpoint")
>>> for example in ds:
...     print(example)
```

yang mengembalikan:
```
{'a': 0}
{'a': 1}
{'a': 2}
checkpoint
restart from checkpoint
{'a': 3}
{'a': 4}
{'a': 5}
```

```py
>>> from torchdata.stateful_dataloader import StatefulDataLoader
>>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train")
>>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4)
>>> # checkpoint
>>> state_dict = dataloader.state_dict()  # uses ds.state_dict() under the hood
>>> # resume from checkpoint
>>> dataloader.load_state_dict(state_dict)  # uses ds.load_state_dict() under the hood
```

#### state_dict[[datasets.IterableDataset.state_dict]]

```python
state_dict()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2747)

**Mengembalikan:** `dict`

Dapatkan state_dict saat ini dari dataset. Ini sesuai dengan state pada contoh terakhir yang dihasilkan.

Melanjutkan proses akan kembali tepat ke titik di mana checkpoint disimpan, kecuali dalam dua kasus berikut:

1. contoh dari buffer shuffle hilang saat melanjutkan dan buffer diisi ulang dengan data baru
2. kombinasi `.with_format(arrow)` dan `.map()` yang di-batch dapat melewatkan satu batch.

Contoh:

```py
>>> from datasets import Dataset, concatenate_datasets
>>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3)
>>> for idx, example in enumerate(ds):
...     print(example)
...     if idx == 2:
...         state_dict = ds.state_dict()
...         print("checkpoint")
...         break
>>> ds.load_state_dict(state_dict)
>>> print(f"restart from checkpoint")
>>> for example in ds:
...     print(example)
```

yang mengembalikan:
```
{'a': 0}
{'a': 1}
{'a': 2}
checkpoint
restart from checkpoint
{'a': 3}
{'a': 4}
{'a': 5}
```

```py
>>> from torchdata.stateful_dataloader import StatefulDataLoader
>>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train")
>>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4)
>>> # checkpoint
>>> state_dict = dataloader.state_dict()  # uses ds.state_dict() under the hood
>>> # resume from checkpoint
>>> dataloader.load_state_dict(state_dict)  # uses ds.load_state_dict() under the hood
```

#### info[[datasets.IterableDataset.info]]

```python
info()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172)

objek [DatasetInfo](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.DatasetInfo) yang berisi semua metadata dalam dataset.

#### split[[datasets.IterableDataset.split]]

```python
split()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177)

objek [NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit) yang sesuai dengan split dataset bernama.

#### builder_name[[datasets.IterableDataset.builder_name]]

```python
builder_name()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182)

#### sitasi[[datasets.IterableDataset.citation]]

```python
citation()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186)

#### config_name[[datasets.IterableDataset.config_name]]

```python
config_name()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190)

#### dataset_size[[datasets.IterableDataset.dataset_size]]

```python
dataset_size()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194)

#### deskripsi[[datasets.IterableDataset.description]]

```python
description()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198)

#### download_checksums[[datasets.IterableDataset.download_checksums]]

```python
download_checksums()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202)

#### download_size[[datasets.IterableDataset.download_size]]

```python
download_size()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206)

#### fitur[[datasets.IterableDataset.features]]

```python
features()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L210)

#### beranda[[datasets.IterableDataset.homepage]]

```python
homepage()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214)

#### lisensi[[datasets.IterableDataset.license]]

```python
license()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218)

#### size_in_bytes[[datasets.IterableDataset.size_in_bytes]]

```python
size_in_bytes()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222)

#### supervised_keys[[datasets.IterableDataset.supervised_keys]]

```python
supervised_keys()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226)

#### versi[[datasets.IterableDataset.version]]

```python
version()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230)

#### from_csv[[datasets.IterableDataset.from_csv]]

```python
from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3392)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Path dari file CSV.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), *opsional*) : Nama split yang akan ditugaskan ke dataset.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `pandas.read_csv`.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Buat IterableDataset dari file CSV.

Contoh:

```py
>>> ds = IterableDataset.from_csv('path/to/dataset.csv')
```

#### from_json[[datasets.IterableDataset.from_json]]

```python
from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3435)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file JSON atau JSON Lines.

split ([NamedSplit](/docs/datasets/v5.2.0/id/package_reference/builder_classes#datasets.NamedSplit), *opsional*) : Nama split yang akan ditugaskan ke dataset.

features ([Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features), *opsional*) : Fitur dataset.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

field (`str`, *opsional*) : Nama field dari file JSON tempat dataset tersebut berada.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `JsonConfig`.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Buat IterableDataset dari file JSON atau JSON Lines.

Contoh:

```py
>>> ds = IterableDataset.from_json('path/to/dataset.json')
```

#### from_parquet[[datasets.IterableDataset.from_parquet]]

```python
from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3482)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file Parquet.

split (`NamedSplit`, *opsional*) : Nama split yang akan ditugaskan ke dataset.

features (`Features`, *opsional*) : Fitur dataset.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

columns (`List[str]`, *opsional*) : Jika bukan `None`, hanya kolom-kolom ini yang akan dibaca dari file. Nama kolom dapat berupa prefiks dari field bersarang, misalnya 'a' akan memilih 'a.b', 'a.c', dan 'a.d.e'.

filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *opsional*) : Kembalikan hanya baris yang cocok dengan filter. Jika memungkinkan, predikat akan didorong ke bawah untuk memanfaatkan informasi partisi atau metadata internal yang ditemukan di sumber data, misalnya statistik Parquet. Jika tidak, filterkan RecordBatches yang dimuat sebelum menghasilkannya.

fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *opsional*) : Opsi khusus pemindaian untuk fragmen Parquet. Ini sangat berguna untuk mengatur buffering dan caching.

on_bad_files (`Literal["error", "warn", "skip"]`, *opsional*, defaultnya "error") : Tentukan tindakan yang dilakukan saat menemukan file yang rusak (file yang tidak dapat dibaca). Nilai yang diizinkan adalah : * 'error', lempar Exception saat menemukan file yang rusak. * 'warn', lempar peringatan saat menemukan file yang rusak dan lewati file tersebut. * 'skip', lewati file yang rusak tanpa lempar atau peringatan saat ditemukan.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `ParquetConfig`.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Buat IterableDataset dari file Parquet.

Contoh:

```py
>>> ds = IterableDataset.from_parquet('path/to/dataset.parquet')
```

Muat subset kolom:

```python
>>> ds = IterableDataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"])
```

Saring data secara efisien, dengan kemungkinan melewati seluruh file atau grup baris:

```python
>>> filters = [("col_0", "==", 0)]
>>> ds = IterableDataset.from_parquet(parquet_files_list, filters=filters)
```

#### from_text[[datasets.IterableDataset.from_text]]

```python
from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3567)

**Parameter:**

path_or_paths (`path-like` atau daftar `path-like`) : Jalur file teks.

split (`NamedSplit`, *opsional*) : Nama split yang akan ditugaskan ke dataset.

features (`Features`, *opsional*) : Fitur dataset.

keep_in_memory (`bool`, defaultnya `False`) : Apakah menyalin data di memori.

keep_linebreaks : (`bool`, defaultnya False): Apakah akan mempertahankan baris baru.

sample_by (`Literal["line", "paragraph", "document"]`, defaultnya "line") : Apakah memuat data per baris, paragraf, atau dokumen. Secara default, satu baris dalam dataset = satu baris.

- ****kwargs** (argumen kata kunci tambahan) : Argumen kata kunci yang akan diteruskan ke `TextConfig`.

**Mengembalikan:**

[IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset)

Buat IterableDataset dari file teks.

Contoh:

```py
>>> ds = IterableDataset.from_text('path/to/dataset.txt')
```

#### datasets.IterableColumn[[datasets.IterableColumn]]

```python
datasets.IterableColumn(source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')], column_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2657)

Iterable untuk kolom tertentu dari [IterableDataset](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset).

Contoh:

Iterasi pada teks di kolom "text" dari dataset:

```python
for text in dataset["text"]:
    ...
```

Ini juga berfungsi dengan kolom bersarang:

```python
for source in dataset["metadata"]["source"]:
    ...
```

## IterableDatasetDict[[datasets.IterableDatasetDict]]

Dictionary dengan nama split sebagai kunci (misalnya 'train', 'test'), dan objek `IterableDataset` sebagai nilai.

#### datasets.IterableDatasetDict[[datasets.IterableDatasetDict]]

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1810)

#### map[[datasets.IterableDatasetDict.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: int = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, fn_kwargs: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1911)

**Parameter:**

function (`Callable`, *opsional*, defaultnya `None`) : Fungsi yang diterapkan secara langsung pada contoh saat Anda mengiterasi dataset. Fungsi ini harus memiliki salah satu dari tanda tangan berikut:  - `function(example: Dict[str, Any]) -> Dict[str, Any]` jika `batched=False` dan `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` jika `batched=False` dan `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` jika `batched=True` dan `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` jika `batched=True` dan `with_indices=True`  Untuk penggunaan lanjutan, fungsi juga dapat mengembalikan `pyarrow.Table`. Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel. Selain itu, jika fungsi Anda tidak mengembalikan apa pun (`None`), maka `map` akan menjalankan fungsi Anda dan mengembalikan dataset tanpa perubahan. Jika tidak ada fungsi yang disediakan, defaultnya adalah fungsi identitas: `lambda x: x`.

with_indices (`bool`, defaultnya `False`) : Menyediakan indeks contoh untuk `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx[, rank]): ...`.

input_columns (`[Union[str, list[str]]]`, *opsional*, defaultnya `None`) : Kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, dict yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`.

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True`.

drop_last_batch (`bool`, defaultnya `False`) : Apakah batch terakhir yang lebih kecil dari `batch_size` harus dibuang alih-alih diproses oleh fungsi.

remove_columns (`[list[str]]`, *opsional*, defaultnya `None`) : Menghapus pilihan kolom saat melakukan pemetaan. Kolom akan dihapus sebelum memperbarui contoh dengan output dari `function`, yaitu jika `function` menambahkan kolom dengan nama yang ada di `remove_columns`, kolom-kolom ini akan tetap dipertahankan.

fn_kwargs (`Dict`, *opsional*, defaultnya `None`) : Argumen kata kunci yang akan diteruskan ke `function`

Terapkan fungsi ke semua contoh dalam dataset iterable (secara individual atau dalam batch) dan perbarui mereka. Jika fungsi Anda mengembalikan kolom yang sudah ada, maka kolom tersebut akan ditimpa. Fungsi diterapkan secara langsung (on-the-fly) pada contoh saat iterasi dataset. Transformasi diterapkan ke semua dataset dalam kamus dataset.

Anda dapat menentukan apakah fungsi harus di-batch atau tidak dengan parameter `batched`:

- Jika `False`, fungsi menerima 1 contoh dan harus mengembalikan 1 contoh. Contoh adalah kamus, misalnya `{"text": "Hello there !"}`.
- Jika `True` dan `batch_size` adalah 1, maka fungsi mengambil batch berisi 1 contoh sebagai input dan dapat mengembalikan batch berisi 1 atau lebih contoh. Batch adalah kamus, misalnya batch berisi 1 contoh adalah `{"text": ["Hello there !"]}`.
- Jika `True` dan `batch_size` adalah `n` > 1, maka fungsi tersebut mengambil batch berisi `n` contoh sebagai input dan dapat mengembalikan batch berisi `n` contoh, atau dengan jumlah contoh yang sembarang. Perhatikan bahwa batch terakhir mungkin memiliki kurang dari `n` contoh. Batch adalah kamus, misalnya batch berisi `n` contoh adalah `{"text": ["Hello there !"] * n}`.

Jika fungsi bersifat asinkron, maka `map` akan menjalankan fungsi Anda secara paralel, dengan hingga seribu panggilan simultan. Disarankan untuk menggunakan `asyncio.Semaphore` di dalam fungsi Anda jika Anda ingin menetapkan jumlah maksimum operasi yang dapat berjalan pada saat yang sama.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> def add_prefix(example):
...     example["text"] = "Review: " + example["text"]
...     return example
>>> ds = ds.map(add_prefix)
>>> next(iter(ds["train"]))
{'label': 1,
 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### filter[[datasets.IterableDatasetDict.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2011)

**Parameter:**

function (`Callable`) : Callable dengan salah satu dari tanda tangan berikut: - `function(example: Dict[str, Any]) -> bool` jika `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` jika `with_indices=True, batched=False` - `function(example: Dict[str, list]) -> list[bool]` jika `with_indices=False, batched=True` - `function(example: Dict[str, list], indices: list[int]) -> list[bool]` jika `with_indices=True, batched=True` Jika tidak ada fungsi yang diberikan, defaultnya adalah fungsi yang selalu True: `lambda x: True`.

with_indices (`bool`, defaultnya `False`) : Berikan indeks contoh ke `function`. Perhatikan bahwa dalam kasus ini, tanda tangan `function` harus berupa `def function(example, idx): ...`.

input_columns (`str` atau `list[str]`, *opsional*) : Kolom yang akan diteruskan ke `function` sebagai argumen posisional. Jika `None`, dict yang memetakan ke semua kolom terformat akan diteruskan sebagai satu argumen.

batched (`bool`, defaultnya `False`) : Berikan batch contoh ke `function`

batch_size (`int`, *opsional*, defaultnya `1000`) : Jumlah contoh per batch yang diberikan ke `function` jika `batched=True`.

fn_kwargs (`Dict`, *opsional*, defaultnya `None`) : Argumen kata kunci yang akan diteruskan ke `function`

Terapkan fungsi filter ke semua elemen sehingga dataset hanya mencakup contoh sesuai dengan fungsi filter tersebut. Pemfilteran dilakukan secara langsung saat iterasi pada dataset. Pemfilteran diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds = ds.filter(lambda x: x["label"] == 0)
>>> list(ds["train"].take(3))
[{'label': 0, 'text': 'Review: simplistic , silly and tedious .'},
 {'label': 0,
 'text': "Review: it's so laddish and juvenile , only teenage boys could possibly find it funny ."},
 {'label': 0,
 'text': 'Review: exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}]
```

#### shuffle[[datasets.IterableDatasetDict.shuffle]]

```python
shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2074)

**Parameter:**

seed (`int`, *opsional*, defaultnya `None`) : Random seed yang akan digunakan untuk mengacak dataset. Seed ini digunakan untuk mengambil sampel dari buffer shuffle dan juga untuk mengacak shard data.

generator (`numpy.random.Generator`, *opsional*) : Generator acak Numpy yang digunakan untuk menghitung permutasi baris dataset. Jika `generator=None` (default), menggunakan `np.random.default_rng` (BitGenerator default (PCG64) dari NumPy).

buffer_size (`int`, defaultnya `1000`) : Ukuran buffer.

max_buffer_input_shards (`int`, defaultnya `10`) : Jumlah maksimum shard yang digunakan untuk mengisi buffer sekaligus.

Mengacak elemen dataset ini secara acak. Pengacakan diterapkan ke semua dataset dalam kamus dataset.

Dataset ini mengisi buffer dengan buffer_size elemen, kemudian mengambil sampel elemen secara acak dari buffer ini, menggantikan elemen yang dipilih dengan elemen baru. Untuk pengacakan sempurna, ukuran buffer harus lebih besar dari atau sama dengan ukuran penuh dataset.

Sebagai contoh, jika dataset Anda berisi 10.000 elemen tetapi `buffer_size` diatur ke 1000, maka `shuffle` awalnya akan memilih elemen acak hanya dari 1000 elemen pertama di buffer. Setelah sebuah elemen dipilih, ruang elemennya di buffer digantikan oleh elemen berikutnya (yaitu elemen ke-1.001), sehingga buffer tetap berisi 1000 elemen.

Jika dataset terdiri dari beberapa shard, ia juga melakukan `shuffle` pada urutan shard tersebut. Namun, jika urutan telah ditetapkan dengan menggunakan [skip()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.skip) atau [take()](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDataset.take), maka urutan shard tetap tidak berubah.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> list(ds["train"].take(3))
[{'label': 1,
 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'},
 {'label': 1,
 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'},
 {'label': 1, 'text': 'effective but too-tepid biopic'}]
>>> ds = ds.shuffle(seed=42)
>>> list(ds["train"].take(3))
[{'label': 1,
 'text': "a sports movie with action that's exciting on the field and a story you care about off it ."},
 {'label': 1,
 'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .'},
 {'label': 1,
 'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune ."}]
```

#### with_format[[datasets.IterableDatasetDict.with_format]]

```python
with_format(type: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1865)

**Parameter:**

type (`str`, *opsional*) : Jenis output yang dipilih dari `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` berarti mengembalikan objek python (default).

Kembalikan dataset dengan format yang ditentukan.

Contoh:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation", streaming=True)
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds = ds.with_format("torch")
>>> next(iter(ds))
{'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'label': tensor(1),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
        1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
        1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### cast[[datasets.IterableDatasetDict.cast]]

```python
cast(features: Features)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2290)

**Parameter:**

features (`Features`) : Fitur baru untuk mengubah tipe dataset. Nama field dalam fitur harus cocok dengan nama kolom saat ini. Tipe data juga harus dapat dikonversi dari satu tipe ke tipe lainnya. Untuk konversi yang tidak sederhana, misalnya `string` <-> `ClassLabel`, Anda harus menggunakan `map` untuk memperbarui Dataset.

**Mengembalikan:** [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict)

Salinan dataset dengan fitur yang telah di-cast.

Cast dataset ke set fitur baru. Type casting diterapkan ke semua dataset dalam dictionary dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds["train"].features.copy()
>>> new_features['label'] = ClassLabel(names=['bad', 'good'])
>>> new_features['text'] = Value('large_string')
>>> ds = ds.cast(new_features)
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### cast_column[[datasets.IterableDatasetDict.cast_column]]

```python
cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2259)

**Parameter:**

column (`str`) : Nama kolom.

feature (`Feature`) : Fitur target.

**Mengembalikan:**

[IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict)

Cast kolom menjadi fitur untuk decoding. Type casting diterapkan ke semua dataset dalam dataset dictionary.

Contoh:

```py
>>> from datasets import load_dataset, ClassLabel
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good']))
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('string')}
```

#### remove_columns[[datasets.IterableDatasetDict.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2207)

**Parameter:**

column_names (`Union[str, list[str]]`) : Nama kolom yang akan dihapus.

**Mengembalikan:** [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict)

Salinan objek dataset tanpa kolom yang akan dihapus.

Hapus satu atau beberapa kolom dalam dataset beserta fitur yang terkait dengan kolom tersebut. Penghapusan dilakukan secara langsung pada contoh saat iterasi dataset. Penghapusan diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds = ds.remove_columns("label")
>>> next(iter(ds["train"]))
{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### rename_column[[datasets.IterableDatasetDict.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2143)

**Parameter:**

original_column_name (`str`) : Nama kolom yang akan diganti namanya.

new_column_name (`str`) : Nama baru untuk kolom.

**Mengembalikan:** [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict)

Salinan dataset dengan kolom yang namanya diubah.

Ganti nama kolom dalam dataset, dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru. Penggantian nama ini diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds = ds.rename_column("text", "movie_review")
>>> next(iter(ds["train"]))
{'label': 1,
 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### rename_columns[[datasets.IterableDatasetDict.rename_columns]]

```python
rename_columns(column_mapping: dict)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2179)

**Parameter:**

column_mapping (`Dict[str, str]`) : Pemetaan kolom untuk diubah namanya menjadi nama baru.

**Mengembalikan:** [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict)

Salinan dataset dengan kolom yang namanya diubah

Ganti nama beberapa kolom dalam dataset, dan pindahkan fitur yang terkait dengan kolom asli ke bawah nama kolom baru. Penggantian nama ini diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds = ds.rename_columns({"text": "movie_review", "label": "rating"})
>>> next(iter(ds["train"]))
{'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .',
 'rating': 1}
```

#### select_columns[[datasets.IterableDatasetDict.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2233)

**Parameter:**

column_names (`Union[str, list[str]]`) : Nama kolom yang akan dipertahankan.

**Mengembalikan:** [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict)

Salinan objek dataset dengan hanya kolom yang dipilih.

Pilih satu atau beberapa kolom dalam dataset beserta fitur yang terkait dengannya. Pemilihan dilakukan secara langsung pada contoh saat iterasi dataset. Pemilihan diterapkan ke semua dataset dalam kamus dataset.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds = ds.select("text")
>>> next(iter(ds["train"]))
{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}
```

#### push_to_hub[[datasets.IterableDatasetDict.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2327)

**Parameter:**

repo_id (`str`) : ID repositori tujuan push dalam format berikut: `<user>/<dataset_name>` atau `<org>/<dataset_name>`. Juga menerima `<dataset_name>`, yang secara default akan menggunakan namespace pengguna yang sedang login. Bisa juga berupa lokasi di dalam bucket, misalnya `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`) : Nama konfigurasi dari dataset. Bawaan adalah "default".

set_default (`bool`, *opsional*) : Apakah akan mengatur konfigurasi ini sebagai konfigurasi default. Jika tidak, konfigurasi default adalah yang bernama "default".

data_dir (`str`, *opsional*) : Nama direktori yang akan berisi file data yang diunggah. Bawaan adalah `config_name` jika berbeda dari "default", jika tidak "data".

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan default ke `"Upload dataset"`.

commit_description (`str`, *opsional*) : Deskripsi dari commit yang akan dibuat. Selain itu, deskripsi dari PR jika PR dibuat (`create_pr` adalah True).

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat. Jika `None` (default), repo akan menjadi publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada.

token (`str`, *opsional*) : Token autentikasi opsional untuk Hugging Face Hub. Jika tidak ada token yang diteruskan, akan menggunakan token yang disimpan secara lokal saat login dengan `hf auth login`. Akan memicu error jika tidak ada token yang diteruskan dan pengguna tidak dalam keadaan login.

revision (`str`, *opsional*) : Cabang untuk mendorong file yang diunggah. Bawaan ke cabang `"main"`.

create_pr (`bool`, *opsional*, defaultnya `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit.

max_shard_size (`int` atau `str`, *opsional*) : Ukuran maksimum opsional untuk shard dataset yang akan diunggah ke hub. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"500MB"` atau `"1GB"`). Jika tidak disediakan, setiap split mempertahankan jumlah shard asli dari dataset.

num_shards (`Dict[str, int]`, *opsional*) : Jumlah shard yang akan ditulis. Gunakan kamus untuk mendefinisikan `num_shards` yang berbeda untuk setiap split. Jika `max_shard_size` diberikan dan `num_shards` untuk suatu split tidak diberikan, maka jumlah shard untuk split tersebut diperkirakan dari `max_shard_size`.

embed_external_files (`bool`, defaultnya `True`) : Apakah akan menyematkan byte file ke dalam shard. Secara khusus, ini akan melakukan hal berikut sebelum push untuk field bertipe: - [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) dan [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image) menghapus informasi path lokal dan menyematkan konten file ke dalam file Parquet.

num_proc (`int`, *opsional*, defaultnya `None`) : Jumlah proses saat menyiapkan dan mengunggah dataset. Ini berguna jika dataset terdiri dari banyak sampel atau file media untuk di-embed. I menggunakan konteks "spawn" untuk bekerja dengan hf_xet, klien rust untuk unggahan cepat ke HF. Multiprocessing dinonaktifkan secara default.

**Mengembalikan:**

huggingface_hub.CommitInfo

Mendorong [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict) ke hub sebagai dataset Parquet. [IterableDatasetDict](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.IterableDatasetDict) didorong menggunakan permintaan HTTP dan tidak memerlukan instalasi git atau git-lfs.

Setiap split dataset akan didorong secara independen. Dataset yang didorong akan mempertahankan nama split aslinya.

File Parquet yang dihasilkan bersifat mandiri secara bawaan: jika dataset Anda berisi data [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image) atau [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio), file Parquet akan menyimpan byte dari file gambar atau audio Anda. Anda dapat menonaktifkan ini dengan mengatur `embed_external_files` ke False.

Contoh:

```python
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True)
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB")
>>> dataset_dict.push_to_hub("<organization>/<dataset_id>", num_shards={"train": 1024, "test": 8})
```

Jika Anda ingin menambahkan konfigurasi baru (atau subset) ke dataset (misalnya jika dataset memiliki beberapa tugas/versi/bahasa):

```python
>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en")
>>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr")
>>> # later
>>> english_dataset = load_dataset("<organization>/<dataset_id>", "en")
>>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")
```

## Fitur[[datasets.Features]]

#### datasets.Features[[datasets.Features]]

```python
datasets.Features(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1931)

Kamus khusus yang mendefinisikan struktur internal dari dataset.

Diinstansiasi dengan kamus bertipe `dict[str, FieldType]`, di mana kunci adalah nama kolom yang diinginkan, dan nilai adalah tipe kolom tersebut.

`FieldType` dapat berupa salah satu dari berikut ini:
- Fitur [Value](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Value) menentukan nilai satu tipe data, misalnya `int64` atau `string`.
- Fitur [ClassLabel](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.ClassLabel) menentukan seperangkat kelas yang telah didefinisikan sebelumnya, yang dapat memiliki label yang terkait dengannya dan akan disimpan sebagai bilangan bulat dalam dataset.
- Python `dict` menentukan fitur komposit yang berisi pemetaan sub-field ke sub-fitur. Anda dapat memiliki field bersarang di dalam field bersarang dengan cara yang bebas.
- [List](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.List) atau [LargeList](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.LargeList) menentukan fitur komposit yang berisi urutan sub-fitur, semuanya dengan tipe fitur yang sama.
- Fitur [Array2D](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Array2D), [Array3D](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Array3D), [Array4D](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Array4D) atau [Array5D](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Array5D) untuk array multidimensi.
- Fitur [Audio](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Audio) untuk menyimpan path absolut ke file audio atau dictionary dengan path relatif ke file audio (kunci "path") dan konten bytes-nya (kunci "bytes"). Fitur ini memuat audio secara lazy dengan decoder.
- Fitur [Image](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Image) untuk menyimpan path absolut ke file gambar, objek `np.ndarray`, objek `PIL.Image.Image`, atau dictionary dengan path relatif ke file gambar (kunci "path") dan konten bytes-nya (kunci "bytes"). Fitur ini mengekstrak data gambar.
- Fitur [Video](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Video) untuk menyimpan path absolut ke file video, objek `torchcodec.decoders.VideoDecoder`, atau dictionary dengan path relatif ke file video (kunci "path") dan konten bytes-nya (kunci "bytes"). Fitur ini memuat video secara lazy dengan decoder.
- Fitur [Pdf](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Pdf) untuk menyimpan path absolut ke file PDF, objek `pdfplumber.pdf.PDF`, atau dictionary dengan path relatif ke file PDF (kunci "path") dan konten bytes-nya (kunci "bytes"). Fitur ini memuat PDF secara lazy menggunakan pembaca PDF.
- Fitur [Nifti](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Nifti) untuk menyimpan path absolut ke file neuroimaging NIfTI, objek `nibabel.Nifti1Image`, atau dictionary dengan path relatif ke file NIfTI (kunci "path") dan konten bytes-nya (kunci "bytes"). Fitur ini memuat file NIfTI secara lazy menggunakan nibabel.
- Fitur [Translation](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Translation) atau [TranslationVariableLanguages](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.TranslationVariableLanguages) yang spesifik untuk Machine Translation.
- Fitur [Json](/docs/datasets/v5.2.0/id/package_reference/loading_methods#datasets.Json) untuk menyimpan data tidak terstruktur, misalnya yang berisi tipe campuran/sembarang. Di balik layar

#### salin[[datasets.Features.copy]]

```python
copy()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2364)

**Mengembalikan:**

[Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features)

Buat salinan dalam (deep copy) dari [Features](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features).

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> copy_of_features = ds.features.copy()
>>> copy_of_features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
```

#### decode_batch[[datasets.Features.decode_batch]]

```python
decode_batch(batch: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2337)

**Parameter:**

batch (`dict[str, list[Any]]`) : Data batch dataset.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file audio atau gambar dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (str) -> token (bool atau str)

**Mengembalikan:**

`dict[str, list[Any]]`

Decode batch dengan decoding fitur kustom.

#### decode_column[[datasets.Features.decode_column]]

```python
decode_column(column: list, column_name: str, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2312)

**Parameter:**

column (`list[Any]`) : Data kolom Dataset.

column_name (`str`) : Nama kolom dataset.

**Mengembalikan:**

`list[Any]`

Decode kolom dengan decoding fitur kustom.

#### decode_example[[datasets.Features.decode_example]]

```python
decode_example(example: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2289)

**Parameter:**

example (`dict[str, Any]`) : Data baris dataset.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file audio atau gambar dari repositori privat di Hub, Anda dapat meneruskan kamus `repo_id (str) -> token (bool or str)`.

**Mengembalikan:**

`dict[str, Any]`

Contoh decode dengan decoding fitur kustom.

#### encode_batch[[datasets.Features.encode_batch]]

```python
encode_batch(batch)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2270)

**Parameter:**

batch (`dict[str, list[Any]]`) : Data dalam batch Dataset.

**Mengembalikan:**

`dict[str, list[Any]]`

Encode batch ke dalam format untuk Arrow.

#### encode_column[[datasets.Features.encode_column]]

```python
encode_column(column, column_name: str)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2254)

**Parameter:**

column (`list[Any]`) : Data dalam kolom Dataset.

column_name (`str`) : Nama kolom dataset.

**Mengembalikan:**

`list[Any]`

Enkode kolom ke dalam format untuk Arrow.

#### encode_example[[datasets.Features.encode_example]]

```python
encode_example(example)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2240)

**Parameter:**

example (`dict[str, Any]`) : Data dalam baris Dataset.

**Mengembalikan:**

`dict[str, Any]`

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Features.flatten]]

```python
flatten(max_depth = 16)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2437)

**Mengembalikan:** [Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features)

Fitur yang telah diratakan.

Ratakan fitur. Setiap kolom dictionary dihapus dan diganti dengan semua subfield yang dikandungnya. Nama field baru dibuat dengan menggabungkan nama kolom asli dan nama subfield seperti ini: `<original>.<subfield>`.

Jika sebuah kolom berisi kamus bersarang, maka semua nama subfield tingkat bawah juga digabungkan untuk membentuk kolom baru: `<original>.<subfield>.<subsubfield>`, dan seterusnya.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("rajpurkar/squad", split="train")
>>> ds.features.flatten()
{'answers.answer_start': List(Value('int32'), id=None),
 'answers.text': List(Value('string'), id=None),
 'context': Value('string'),
 'id': Value('string'),
 'question': Value('string'),
 'title': Value('string')}
```

#### from_arrow_schema[[datasets.Features.from_arrow_schema]]

```python
from_arrow_schema(pa_schema: Schema)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2023)

**Parameter:**

pa_schema (`pyarrow.Schema`) : Skema Arrow.

**Mengembalikan:**

[Fitur](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features)

Konstruksi [Features](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Features) dari Skema Arrow. Ini juga memeriksa metadata skema untuk fitur Hugging Face Datasets. Field yang tidak nullable tidak didukung dan diatur menjadi nullable.

Selain itu, pa.dictionary tidak didukung dan menggunakan tipe dasarnya sebagai gantinya. Oleh karena itu, datasets mengonversi objek DictionaryArray menjadi nilai sebenarnya.

#### from_dict[[datasets.Features.from_dict]]

```python
from_dict(dic)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2057)

**Parameter:**

dic (*dict[str, Any]*) : Kamus Python.

**Mengembalikan:** `*Features*`

Konstruksi [*Features*] dari dict.

Regenerasi objek fitur bersarang dari dict yang dideserialisasi. Kami menggunakan kunci *_type* untuk menyimpulkan nama dataclass dari fitur *FieldType*.

Fungsi ini memungkinkan sintaks konstruktor yang nyaman untuk mendefinisikan fitur dari kamus JSON yang telah dideserialisasi. Fungsi ini digunakan khususnya saat mendeserialisasi [*DatasetInfo*] yang telah dituangkan ke objek JSON. Ini berfungsi sebagai padanan dari [*Features.from_arrow_schema*] dan menangani instansiasi rekursif per bidang, tetapi tidak memerlukan pemetaan ke/dari pyarrow, kecuali karena memanfaatkan pemetaan dtype primitif pyarrow yang secara otomatis dilakukan oleh [*Value*].

Contoh:

```python
>>> Features.from_dict(&amp;lcub;'_type': &amp;lcub;'dtype': 'string', 'id': None, '_type': 'Value'}})
&amp;lcub;'_type': Value('string')}
```

#### reorder_fields_as[[datasets.Features.reorder_fields_as]]

```python
reorder_fields_as(other: Features)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2384)

**Parameter:**

other ([*Fitur*]) : [*Fitur*] lain yang harus diselaraskan.

**Mengembalikan:**

[*Fitur*]

Urutkan ulang field Features agar sesuai dengan urutan field dari [*Features*] lainnya.

Urutan field penting karena memengaruhi data arrow yang mendasarinya. Mengubah urutan field memungkinkan tipe data arrow yang mendasarinya menjadi cocok.

Contoh:

```python
>>> from datasets import Features, List, Value
>>> # let's say we have two features with a different order of nested fields (for a and b for example)
>>> f1 = Features(&amp;lcub;"root": &amp;lcub;"a": Value("string"), "b": Value("string")}})
>>> f2 = Features(&amp;lcub;"root": &amp;lcub;"b": Value("string"), "a": Value("string")}})
>>> assert f1.type != f2.type
>>> # re-ordering keeps the base structure (here List is defined at the root level), but makes the fields order match
>>> f1.reorder_fields_as(f2)
&amp;lcub;'root': List(&amp;lcub;'b': Value('string'), 'a': Value('string')})}
>>> assert f1.reorder_fields_as(f2).type == f2.type
```

### Skalar[[datasets.Value]]

#### datasets.Value[[datasets.Value]]

```python
datasets.Value(dtype: str, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L511)

**Parameter:**

dtype (`str`) : Nama dari tipe data.

Nilai fitur skalar dari tipe data tertentu.

dtype yang mungkin untuk `Value` adalah sebagai berikut:
- `null`
- `bool`
- `int8`
- `int16`
- `int32`
- `int64`
- `uint8`
- `uint16`
- `uint32`
- `uint64`
- `float16`
- `float32` (alias float)
- `float64` (alias double)
- `time32[(s|ms)]`
- `time64[(us|ns)]`
- `timestamp[(s|ms|us|ns)]`
- `timestamp[(s|ms|us|ns), tz=(tzstring)]`
- `date32`
- `date64`
- `duration[(s|ms|us|ns)]`
- `decimal128(precision, scale)`
- `decimal256(precision, scale)`
- `binary`
- `large_binary`
- `binary_view`
- `string`
- `large_string`
- `string_view`

Contoh:

```py
>>> from datasets import Features
>>> features = Features({'stars': Value('int32')})
>>> features
{'stars': Value('int32')}
```

#### datasets.ClassLabel[[datasets.ClassLabel]]

```python
datasets.ClassLabel(num_classes: dataclasses.InitVar[typing.Optional[int]] = None, names: list = None, names_file: dataclasses.InitVar[typing.Optional[str]] = None, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1052)

**Parameter:**

num_classes (`int`, *opsional*) : Jumlah kelas. Semua label harus < `num_classes`.

names (`list` dari `str`, *opsional*) : Nama string untuk kelas bilangan bulat. Urutan pemberian nama dipertahankan.

names_file (`str`, *opsional*) : Path ke file yang berisi nama untuk kelas integer, satu per baris.

Jenis fitur untuk label kelas bilangan bulat.

Ada 3 cara untuk mendefinisikan `ClassLabel`, yang sesuai dengan 3 argumen:

* `num_classes`: Buat label dari 0 hingga (num_classes-1).
* `names`: Daftar string label.
* `names_file`: File yang berisi daftar label.

Di balik layar, label disimpan sebagai bilangan bulat. Anda dapat menggunakan -1 untuk merepresentasikan label yang tidak diketahui/hilang.

Contoh:

```py
>>> from datasets import Features, ClassLabel
>>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])})
>>> features
{'label': ClassLabel(names=['bad', 'ok', 'good'])}
```

#### cast_storage[[datasets.ClassLabel.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1217)

**Parameter:**

storage (`Union[pa.StringArray, pa.IntegerArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.Int64Array`

Array dalam tipe penyimpanan arrow `ClassLabel`.

Cast array Arrow ke tipe penyimpanan arrow `ClassLabel`. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow `ClassLabel` adalah:

- `pa.string()`
- `pa.int()`

#### int2str[[datasets.ClassLabel.int2str]]

```python
int2str(values: typing.Union[int, collections.abc.Iterable])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1171)

Konversi `integer` => `string` nama kelas.

Mengenai label yang tidak diketahui/hilang: meneruskan bilangan bulat negatif akan memicu `ValueError`.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> ds.features["label"].int2str(0)
'neg'
```

#### str2int[[datasets.ClassLabel.str2int]]

```python
str2int(values: typing.Union[str, collections.abc.Iterable])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1126)

Nama kelas konversi `string` => `integer`.

Contoh:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> ds.features["label"].str2int('neg')
0
```

### Komposit[[datasets.LargeList]]

#### datasets.LargeList[[datasets.LargeList]]

```python
datasets.LargeList(feature: typing.Any, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1414)

**Parameter:**

feature (`FeatureType`) : Tipe data fitur anak dari setiap item di dalam daftar besar.

Jenis fitur untuk data daftar besar yang terdiri dari jenis data fitur anak.

Dukungan ini berasal dari `pyarrow.LargeListType`, yang mirip dengan `pyarrow.ListType` tetapi menggunakan offset 64-bit alih-alih 32-bit.

#### datasets.List[[datasets.List]]

```python
datasets.List(feature: typing.Any, length: int = -1, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1386)

**Parameter:**

feature (`FeatureType`) : Tipe data fitur anak dari setiap item di dalam daftar besar.

length (opional `int`, default -1) : Panjang daftar jika tetap. Defaultnya -1 yang berarti panjang sembarang.

Jenis fitur untuk data daftar besar yang terdiri dari jenis data fitur anak.

Didukung oleh `pyarrow.ListType`, yang menggunakan offset 32-bit atau panjang tetap.

#### datasets.Sequence[[datasets.Sequence]]

```python
datasets.Sequence(feature = None, length = -1, **kwargs)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1352)

**Parameter:**

feature (`FeatureType`) : Tipe data fitur anak dari setiap item di dalam daftar besar.

length (opional `int`, default -1) : Panjang daftar jika tetap. Defaultnya -1 yang berarti panjang sembarang.

**Mengembalikan:**

[Daftar](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.List) dari fitur yang ditentukan, kecuali `dict` dari sub-fitur yang dikonversi menjadi `dict` dari daftar sub-fitur untuk kompatibilitas dengan TFDS.

`Sequence` adalah utilitas yang secara otomatis mengonversi fitur dictionary internal menjadi dictionary dari list. Perilaku ini diimplementasikan untuk memiliki lapisan kompatibilitas dengan pustaka TensorFlow Datasets, tetapi mungkin tidak diinginkan dalam beberapa kasus. Jika Anda tidak menginginkan perilaku ini, Anda dapat menggunakan [List](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.List) atau [LargeList](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.LargeList) sebagai pengganti [Sequence](/docs/datasets/v5.2.0/id/package_reference/main_classes#datasets.Sequence).

### Terjemahan[[datasets.Translation]]

#### datasets.Translation[[datasets.Translation]]

```python
datasets.Translation(languages: list, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L12)

**Parameter:**

languages (`dict`) : Kamus untuk setiap contoh yang memetakan kode bahasa string ke terjemahan string.

`Feature` untuk terjemahan dengan bahasa tetap per contoh. Di sini untuk kompatibilitas dengan tfds.

Contoh:

```python
>>> # At construction time:
>>> datasets.features.Translation(languages=['en', 'fr', 'de'])
>>> # During data generation:
>>> yield {
...         'en': 'the cat',
...         'fr': 'le chat',
...         'de': 'die katze'
... }
```

#### flatten[[datasets.Translation.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L44)

Ratakan fitur Translation menjadi kamus.

#### datasets.TranslationVariableLanguages[[datasets.TranslationVariableLanguages]]

```python
datasets.TranslationVariableLanguages(languages: typing.Optional[list] = None, num_languages: typing.Optional[int] = None, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L52)

**Parameter:**

languages (`dict`) : Kamus untuk setiap contoh yang memetakan kode bahasa string ke satu atau beberapa terjemahan string. Bahasa yang ada dapat bervariasi dari satu contoh ke contoh lainnya.

**Mengembalikan:** - `language` atau `translation` (`tf.Tensor` 1D `tf.string` dengan panjang variabel)

Kode bahasa yang diurutkan secara menaik atau terjemahan teks polos, diurutkan agar selaras dengan kode bahasa.

`Feature` untuk terjemahan dengan bahasa yang bervariasi per contoh. Di sini untuk kompatibilitas dengan tfds.

Contoh:

```python
>>> # At construction time:
>>> datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de'])
>>> # During data generation:
>>> yield {
...         'en': 'the cat',
...         'fr': ['le chat', 'la chatte,']
...         'de': 'die katze'
... }
>>> # Tensor returned :
>>> {
...         'language': ['en', 'de', 'fr', 'fr'],
...         'translation': ['the cat', 'die katze', 'la chatte', 'le chat'],
... }
```

#### flatten[[datasets.TranslationVariableLanguages.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L122)

Ratakan fitur TranslationVariableLanguages menjadi kamus.

### Array[[datasets.Array2D]]

#### datasets.Array2D[[datasets.Array2D]]

```python
datasets.Array2D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L608)

**Parameter:**

shape (`tuple`) : Ukuran setiap dimensi.

dtype (`str`) : Nama dari tipe data.

Buat array dua dimensi.

Contoh:

```py
>>> from datasets import Features
>>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')})
```

#### datasets.Array3D[[datasets.Array3D]]

```python
datasets.Array3D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L633)

**Parameter:**

shape (`tuple`) : Ukuran setiap dimensi.

dtype (`str`) : Nama dari tipe data.

Buat array tiga dimensi.

Contoh:

```py
>>> from datasets import Features
>>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')})
```

#### datasets.Array4D[[datasets.Array4D]]

```python
datasets.Array4D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L658)

**Parameter:**

shape (`tuple`) : Ukuran setiap dimensi.

dtype (`str`) : Nama dari tipe data.

Buat array berdimensi empat.

Contoh:

```py
>>> from datasets import Features
>>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')})
```

#### datasets.Array5D[[datasets.Array5D]]

```python
datasets.Array5D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L683)

**Parameter:**

shape (`tuple`) : Ukuran setiap dimensi.

dtype (`str`) : Nama dari tipe data.

Buat array lima dimensi.

Contoh:

```py
>>> from datasets import Features
>>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')})
```

### Audio[[datasets.Audio]]

#### datasets.Audio[[datasets.Audio]]

```python
datasets.Audio(sampling_rate: typing.Optional[int] = None, decode: bool = True, num_channels: typing.Optional[int] = None, stream_index: typing.Optional[int] = None, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L24)

**Parameter:**

sampling_rate (`int`, *opsional*) : Laju sampling target. Jika `None`, laju sampling asli digunakan.

num_channels (`int`, *opsional*) : Jumlah kanal yang diinginkan untuk sampel. Secara default, jumlah kanal dari sumber digunakan. Dekoding audio akan mengembalikan sampel dengan bentuk (num_channels, num_samples) Saat ini, `None` (jumlah kanal dari sumber, default), `1` (mono) atau `2` (stereo) kanal yang didukung. Argumen `num_channels` diteruskan ke `torchcodec.decoders.AudioDecoder`.

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data audio. Jika `False`, mengembalikan kamus dasar dalam format `{"path": audio_path, "bytes": audio_bytes}`.

stream_index (`int`, *opsional*) : Indeks streaming yang akan digunakan dari file. Jika `None`, secara default menggunakan indeks "terbaik".

Audio `Feature` untuk mengekstrak data audio dari file audio.

Input: Fitur Audio menerima input berupa:
- Sebuah `str`: Path absolut ke file audio (yaitu akses acak diizinkan).
- `pathlib.Path`: jalur ke file audio (yaitu akses acak diizinkan).
- `dict` dengan kunci:

  - `path`: String berisi path relatif file audio ke file arsip.
  - `bytes`: Konten byte dari file audio.

  Hal ini berguna untuk file parquet atau webdataset yang menyematkan file audio.

- `dict` dengan kunci:

  - `array`: Array yang berisi sampel audio
  - `sampling_rate`: Integer yang sesuai dengan laju sampling dari sampel audio.

- Sebuah `torchcodec.decoders.AudioDecoder`: objek decoder audio torchcodec.

Output: Fitur Audio mengoutputkan data sebagai objek `torchcodec.decoders.AudioDecoder`, dengan kunci tambahan:

- `array`: Array yang berisi sampel audio
- `sampling_rate`: Integer yang sesuai dengan laju sampling dari sampel audio.

Contoh:

```py
>>> from datasets import load_dataset, Audio
>>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=44100, num_channels=2))
>>> ds[0]["audio"]
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> audio = ds[0]["audio"]
>>> audio.get_samples_played_in_range(0, 10)
AudioSamples:
    data (shape): torch.Size([2, 110592])
    pts_seconds: 0.0
    duration_seconds: 2.507755102040816
    sample_rate: 44100
```

#### cast_storage[[datasets.Audio.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L237)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan arrow Audio, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`

Cast array Arrow ke tipe penyimpanan arrow Audio. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow Audio adalah:

- `pa.string()` - harus berisi data "path"
- `pa.binary()` - harus berisi byte audio
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting

#### decode_example[[datasets.Audio.decode_example]]

```python
decode_example(value: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L164)

**Parameter:**

value (`dict`) : Kamus dengan kunci: - `path`: String berisi path file audio relatif. - `bytes`: Bytes dari file audio.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file audio dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`)

**Mengembalikan:**

`torchcodec.decoders.AudioDecoder`

Decode file audio contoh menjadi data audio.

#### embed_storage[[datasets.Audio.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L283)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file lokal ke dalam array

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array. Misalnya, file dengan path yang diawali dengan hf:// atau https://

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan arrow Audio, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Embed file audio ke dalam array Arrow.

#### encode_example[[datasets.Audio.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L96)

**Parameter:**

value (`str`, `bytes`,`bytearray`,`dict`, `AudioDecoder`) : Data yang diteruskan sebagai input ke fitur Audio.

**Mengembalikan:** `dict`

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Audio.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L226)

Jika berada dalam keadaan dapat didekodekan, lempar error, selain itu ratakan fitur menjadi kamus.

### Gambar[[datasets.Image]]

#### datasets.Image[[datasets.Image]]

```python
datasets.Image(mode: typing.Optional[str] = None, decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L47)

**Parameter:**

mode (`str`, *opsional*) : Mode untuk mengkonversi gambar. Jika `None`, mode asli gambar digunakan.

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data gambar. Jika `False`, mengembalikan kamus dasar dalam format `{"path": image_path, "bytes": image_bytes}`.

Image `Feature` untuk membaca data gambar dari file gambar.

Input: Fitur Image menerima sebagai input:
- A `str`: Path absolut ke file gambar (yaitu, akses acak diizinkan).
- `pathlib.Path`: jalur ke file gambar (yaitu akses acak diizinkan).
- `dict` dengan kunci:

  - `path`: String berisi path relatif dari file gambar ke file arsip.
  - `bytes`: Byte dari file gambar.

  Hal ini berguna untuk file parquet atau webdataset yang menyematkan file gambar.

- `np.ndarray`: array NumPy yang merepresentasikan sebuah gambar.
- `PIL.Image.Image`: objek gambar PIL.

Output: Data output fitur Gambar sebagai objek `PIL.Image.Image`.

Contoh:

```py
>>> from datasets import load_dataset, Image
>>> ds = load_dataset("AI-Lab-Makerere/beans", split="train")
>>> ds.features["image"]
Image(decode=True, id=None)
>>> ds[0]["image"]
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x15E52E7F0>
>>> ds = ds.cast_column('image', Image(decode=False))
{'bytes': None,
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'}
```

#### cast_storage[[datasets.Image.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L216)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan Image arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow Image. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow Image adalah:

- `pa.string()` - harus berisi data "path"
- `pa.large_string()` - harus berisi data "path" (akan di-cast ke string jika memungkinkan)
- `pa.binary()` - harus berisi byte gambar
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting
- `pa.list(*)` - harus berisi data array gambar

#### decode_example[[datasets.Image.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L139)

**Parameter:**

value (`str` atau `dict`) : String dengan path file gambar absolut, atau dictionary dengan kunci: - `path`: String dengan path file gambar absolut atau relatif. - `bytes`: Byte dari file gambar.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file gambar dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

`PIL.Image.Image`

Decode file gambar contoh menjadi data gambar.

#### embed_storage[[datasets.Image.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L278)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file lokal ke dalam array

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array. Misalnya, file dengan path yang diawali dengan hf:// atau https://

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan Image arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Sisipkan file gambar ke dalam array Arrow.

#### encode_example[[datasets.Image.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L98)

**Parameter:**

value (`str`, `np.ndarray`, `PIL.Image.Image` atau `dict`) : Data yang diteruskan sebagai input ke fitur Image.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Image.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L203)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

### Video[[datasets.Video]]

#### datasets.Video[[datasets.Video]]

```python
datasets.Video(decode: bool = True, stream_index: typing.Optional[int] = None, dimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW', num_ffmpeg_threads: int = 1, device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu', seek_mode: typing.Literal['exact', 'approximate'] = 'exact', id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L29)

**Parameter:**

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data video. Jika `False`, mengembalikan kamus dasar dalam format `{"path": video_path, "bytes": video_bytes}`.

stream_index (`int`, *opsional*) : Indeks streaming yang akan digunakan dari file. Jika `None`, secara default menggunakan indeks "terbaik".

dimension_order (`str`, defaultnya `NCHW`) : Urutan dimensi dari frame yang didekodekan, di mana N adalah ukuran batch, C adalah jumlah channel, H adalah tinggi, dan W adalah lebar dari frame.

num_ffmpeg_threads (`int`, defaultnya `1`) : Jumlah thread yang digunakan untuk mendekode video. (Disarankan untuk tetap pada 1)

device (`str` atau `torch.device`, defaultnya `cpu`) : Perangkat yang digunakan untuk mendekode video.

seek_mode (`str`, defaultnya `exact`) : Menentukan apakah akses frame akan “exact” atau “approximate”. Exact menjamin bahwa permintaan frame i akan selalu mengembalikan frame i, tetapi hal ini memerlukan pemindaian awal pada file. Approximate lebih cepat karena menghindari pemindaian file, tetapi kurang akurat karena menggunakan metadata file untuk menghitung di mana i kemungkinan berada. baca selengkapnya [di sini](https://docs.pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html#sphx-glr-generated-examples-approximate-mode-py)

Video `Feature` untuk membaca data video dari file video.

Input: Fitur Video menerima sebagai input:
- A `str`: Path absolut ke file video (yaitu, akses acak diizinkan).
- `pathlib.Path`: path ke file video (yaitu akses acak diizinkan).
- `dict` dengan kunci:

  - `path`: String berisi path relatif dari file video dalam repositori dataset.
  - `bytes`: Byte dari file video.

  Hal ini berguna untuk file parquet atau webdataset yang menyematkan file video.

- A `torchcodec.decoders.VideoDecoder`: objek decoder video torchcodec.

Output: Fitur Video menyajikan data sebagai objek `torchcodec.decoders.VideoDecoder`.

Contoh:

```py
>>> from datasets import Dataset, Video
>>> ds = Dataset.from_dict({"video":["path/to/Screen Recording.mov"]}).cast_column("video", Video())
>>> ds.features["video"]
Video(decode=True, id=None)
>>> ds[0]["video"]
<torchcodec.decoders._video_decoder.VideoDecoder object at 0x14a61e080>
>>> video = ds[0]["video"]
>>> video.get_frames_in_range(0, 10)
FrameBatch:
data (shape): torch.Size([10, 3, 50, 66])
pts_seconds: tensor([0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333,
        0.4333], dtype=torch.float64)
duration_seconds: tensor([0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167,
        0.0167], dtype=torch.float64)
>>> ds.cast_column('video', Video(decode=False))[0]["video]
{'bytes': None,
 'path': 'path/to/Screen Recording.mov'}
```

#### cast_storage[[datasets.Video.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L242)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan Video arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow Video. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow Video adalah:

- `pa.string()` - harus berisi data "path"
- `pa.binary()` - harus berisi byte video
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting
- `pa.list(*)` - harus berisi data array video

#### decode_example[[datasets.Video.decode_example]]

```python
decode_example(value: typing.Union[str, datasets.features.video.Example], token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L153)

**Parameter:**

value (`str` atau `dict`) : String dengan path file video absolut, atau dictionary dengan kunci:  - `path`: String dengan path file video absolut atau relatif. - `bytes`: Byte dari file video.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file video dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

`torchcodec.decoders.VideoDecoder`

Decode file video contoh menjadi data video.

#### embed_storage[[datasets.Video.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L294)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file lokal ke dalam array

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array. Misalnya, file dengan path yang diawali dengan hf:// atau https://

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan Video arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Sisipkan file gambar ke dalam array Arrow.

#### encode_example[[datasets.Video.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L105)

**Parameter:**

value (`str`, `np.ndarray`, `bytes`, `bytearray`, `VideoDecoder` atau `dict`) : Data yang diteruskan sebagai input ke fitur Video.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Video.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L229)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

### Mesh[[datasets.Mesh]]

#### datasets.Mesh[[datasets.Mesh]]

```python
datasets.Mesh(decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L23)

**Parameter:**

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data mesh. Jika `False`, mengembalikan kamus dasar dalam format `{"path": mesh_path, "bytes": mesh_bytes}`. Dekoding mesh menggunakan `trimesh` dan mendukung file `.glb`, `.gltf`, `.ply`, dan `.stl`.

Mesh `Feature` untuk membaca data mesh 3D dari file.

Input: Fitur Mesh menerima sebagai input:
- A `str`: Path absolut ke file mesh (yaitu, akses acak diizinkan).
- `pathlib.Path`: jalur ke file mesh (yaitu akses acak diizinkan).
- `dict` dengan kunci:

  - `path`: String berisi path relatif dari file mesh ke file arsip.
  - `bytes`: Byte dari file mesh.

  Hal ini berguna untuk file parquet atau webdataset yang menyematkan file mesh.

- A `trimesh.Trimesh` or `trimesh.Scene`: 3D mesh or scene object.

Output: Fitur Mesh mengoutputkan data sebagai objek `trimesh.Trimesh` atau `trimesh.Scene`.

#### cast_storage[[datasets.Mesh.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L162)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan Mesh arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow Mesh. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow Mesh adalah:

- `pa.string()` - harus berisi data "path"
- `pa.large_string()` - harus berisi data "path" (akan di-cast ke string jika memungkinkan)
- `pa.binary()` - harus berisi byte mesh
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting

#### decode_example[[datasets.Mesh.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L91)

**Parameter:**

value (`dict`) : Kamus dengan kunci:  - `path`: String berisi jalur file mesh absolut atau relatif. - `bytes`: Byte dari file mesh.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file mesh dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

`trimesh.Trimesh` atau `trimesh.Scene`

Decode file mesh contoh.

#### embed_storage[[datasets.Mesh.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L215)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah data file lokal akan disematkan ke dalam array.

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan Mesh arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Embed file mesh ke dalam array Arrow.

#### encode_example[[datasets.Mesh.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L57)

**Parameter:**

value (`str`, `bytes`, `dict`, `trimesh.Trimesh`, atau `trimesh.Scene`) : Data yang diteruskan sebagai input ke fitur Mesh.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Mesh.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L149)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

### Json[[datasets.Json]]

#### datasets.Json[[datasets.Json]]

```python
datasets.Json(decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1258)

Jenis fitur untuk objek JSON.

Di balik layar, objek disimpan sebagai string yang dikodekan JSON.

Contoh:

```py
>>> from datasets import Features, Json
>>> features = Features({'json': Json()})
>>> features
{'json': Json()}
```

```py
>>> from datasets import Dataset, Features, Json, List
>>> features = Features({"a": List(Json())})
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features)
>>> # OR
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json")
>>> ds.features
{'a': List(Json())}
>>> ds[0]
{'a': [{'b': 0}, {'c': 0}]}
>>> def f(x):
...     for y in x["a"]:
...         y["d"] = "foo"
...     return x
>>> ds = ds.map(f)
>>> ds.features
>>> ds[0]
{'a': [{'b': 0, 'd': 'foo'}, {'c': 0, 'd': 'foo'}]}
```

#### cast_storage[[datasets.Json.cast_storage]]

```python
cast_storage(storage: Array)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1321)

**Parameter:**

storage (`Union[pa.StringArray, pa.IntegerArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.JsonArray`

Array dalam tipe penyimpanan arrow `Json`.

Cast array Arrow ke tipe penyimpanan arrow `Json`.

### Pdf[[datasets.Pdf]]

#### datasets.Pdf[[datasets.Pdf]]

```python
datasets.Pdf(decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L31)

**Parameter:**

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data pdf. Jika `False`, mengembalikan kamus dasar dalam format `{"path": pdf_path, "bytes": pdf_bytes}`.

**Eksperimental.** Fitur `Feature` untuk membaca dokumen pdf dari file pdf.

Input: Fitur Pdf menerima input berupa:
- A `str`: Path absolut ke file pdf (yaitu, akses acak diizinkan).
- `pathlib.Path`: path ke file pdf (yaitu akses acak diizinkan).
- `dict` dengan kunci:
  - `path`: String berisi path relatif dari file pdf dalam repositori dataset.
  - `bytes`: Byte dari file pdf. Ini berguna untuk file arsip dengan akses berurutan.

- `pdfplumber.pdf.PDF`: objek pdf dari pdfplumber.

Contoh:

```py
>>> from datasets import Dataset, Pdf
>>> ds = Dataset.from_dict({"pdf": ["path/to/pdf/file.pdf"]}).cast_column("pdf", Pdf())
>>> ds.features["pdf"]
Pdf(decode=True, id=None)
>>> ds[0]["pdf"]
<pdfplumber.pdf.PDF object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("pdf", Pdf(decode=False))
>>> ds[0]["pdf"]
{'bytes': None,
'path': 'path/to/pdf/file.pdf'}
```

#### cast_storage[[datasets.Pdf.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L183)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan panah Pdf, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow Pdf. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow Pdf adalah:

- `pa.string()` - harus berisi data "path"
- `pa.binary()` - harus berisi byte gambar
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting
- `pa.list(*)` - harus berisi data array pdf

#### decode_example[[datasets.Pdf.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L113)

**Parameter:**

value (`str` atau `dict`) : String dengan path file pdf absolut, atau dictionary dengan kunci:  - `path`: String dengan path file pdf absolut atau relatif. - `bytes`: Byte dari file pdf.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file pdf dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

`pdfplumber.pdf.PDF`

Decode file contoh pdf menjadi data pdf.

#### embed_storage[[datasets.Pdf.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L220)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file lokal ke dalam array

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array. Misalnya, file dengan path yang diawali dengan hf:// atau https://

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan PDF arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Embed file PDF ke dalam array Arrow.

#### encode_example[[datasets.Pdf.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L78)

**Parameter:**

value (`str`, `bytes`, `pdfplumber.pdf.PDF` atau `dict`) : Data yang diteruskan sebagai input ke fitur Pdf.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Pdf.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L170)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

### Nifti[[datasets.Nifti]]

#### datasets.Nifti[[datasets.Nifti]]

```python
datasets.Nifti(decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L64)

**Parameter:**

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data NIfTI. Jika `False`, sebuah string berisi byte akan dikembalikan. `decode=False` tidak didukung saat mendekode contoh.

**Eksperimental.** `Feature` Nifti untuk membaca file neuroimaging NIfTI.

Input: Fitur Nifti menerima input berupa:
- `str`: Path absolut ke file NIfTI (yaitu akses acak diizinkan).
- `pathlib.Path`: jalur ke file NIfTI (yaitu akses acak diizinkan).
- `dict` dengan kunci:
  - `path`: String berisi path relatif dari file NIfTI dalam repositori dataset.
  - `bytes`: Byte dari file NIfTI. Ini berguna untuk file arsip dengan akses berurutan.

- Objek gambar `nibabel` (misalnya, `nibabel.nifti1.Nifti1Image`).

Contoh:

```py
>>> from datasets import Dataset, Nifti
>>> ds = Dataset.from_dict({"nifti": ["path/to/file.nii.gz"]}).cast_column("nifti", Nifti())
>>> ds.features["nifti"]
Nifti(decode=True, id=None)
>>> ds[0]["nifti"]
<nibabel.nifti1.Nifti1Image object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("nifti", Nifti(decode=False))
>>> ds[0]["nifti"]
{'bytes': None,
'path': 'path/to/file.nii.gz'}
```

#### cast_storage[[datasets.Nifti.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L298)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray, pa.BinaryArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan panah Nifti, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow Nifti. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow Nifti adalah:

- `pa.string()` - harus berisi data "path"
- `pa.binary()` - harus berisi byte NIfTI
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting

#### decode_example[[datasets.Nifti.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L150)

**Parameter:**

value (`str` atau `dict`) : String dengan path file NIfTI absolut, atau dictionary dengan kunci: - `path`: String dengan path file NIfTI absolut atau relatif. - `bytes`: Byte dari file NIfTI.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file NIfTI dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

objek `nibabel.Nifti1Image`

Decode file NIfTI contoh menjadi objek gambar nibabel.

#### embed_storage[[datasets.Nifti.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L216)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file lokal ke dalam array

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array. Misalnya, file dengan path yang diawali dengan hf:// atau https://

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan NifTI arrow, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Embed file NifTI ke dalam array Arrow.

#### encode_example[[datasets.Nifti.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L110)

**Parameter:**

value (`str`, `bytes`, `nibabel.Nifti1Image` atau `dict`) : Data yang diteruskan sebagai input ke fitur Nifti.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.Nifti.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L285)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

### BioSequence[[datasets.BioSequence]]

#### datasets.BioSequence[[datasets.BioSequence]]

```python
datasets.BioSequence(format: str = 'fasta', decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L44)

**Parameter:**

format (`str`, defaultnya `"fasta"`) : Nama format urutan, sesuai yang dipahami oleh `Bio.SeqIO`. Nilai umum adalah `"fasta"`, `"fastq"` dan `"genbank"`.

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data sekuens. Jika `False`, mengembalikan kamus dasar dalam format `{"path": path, "bytes": bytes}`.

**Eksperimental.** `Feature` BioSequence untuk membaca rekaman sekuens biologis dari file sekuens.

File sekuens menyimpan satu atau lebih catatan residu beserta pengenal dan anotasi mereka. FASTA, FASTQ, dan GenBank memiliki bentuk yang sama pada level ini, berbeda hanya pada parser yang digunakan, sehingga `format` memilih parser, bukan tipe.

Input: Fitur BioSequence menerima input berupa:
- A `str`: Path absolut ke file sekuens (yaitu akses acak diizinkan).
- `pathlib.Path`: jalur ke file urutan (yaitu akses acak diizinkan).
- `dict` dengan kunci:
  - `path`: String berisi path relatif dari file sequence dalam repositori dataset.
  - `bytes`: Byte dari file sekuensial. Ini berguna untuk file arsip dengan akses berurutan.

- A `Bio.SeqRecord.SeqRecord`: rekaman sekuens biopython.

Contoh:

```py
>>> from datasets import Dataset, BioSequence
>>> ds = Dataset.from_dict({"seq": ["path/to/sequences.fasta"]}).cast_column("seq", BioSequence())
>>> ds.features["seq"]
BioSequence(format='fasta', decode=True)
>>> ds[0]["seq"]
SeqRecord(seq=Seq('ACGT'), id='seq1', name='seq1', description='seq1', dbxrefs=[])
>>> ds = ds.cast_column("seq", BioSequence(decode=False))
>>> ds[0]["seq"]
{'bytes': None,
'path': 'path/to/sequences.fasta'}
```

#### cast_storage[[datasets.BioSequence.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L199)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan arrow BioSequence, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow BioSequence. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow BioSequence adalah:

- `pa.string()` - harus berisi data "path"
- `pa.binary()` - harus berisi byte file
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting

#### decode_example[[datasets.BioSequence.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L132)

**Parameter:**

value (`str` atau `dict`) : String dengan path file absolut, atau kamus dengan kunci: - `path`: String dengan path file absolut atau relatif. - `bytes`: Byte dari file tersebut.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

`Bio.SeqRecord.SeqRecord`

Decode file sekuens contoh menjadi record biopython.

Sebuah file dapat menyimpan banyak rekaman; fungsi ini mengembalikan rekaman pertama, karena satu baris adalah satu rekaman. Gunakan pemuat sekuens yang dikemas untuk memperluas file multi-rekaman menjadi satu baris per rekaman.

#### embed_storage[[datasets.BioSequence.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L219)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah data file lokal akan disematkan ke dalam array.

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan arrow BioSequence.

Embed file sekuens ke dalam array Arrow.

#### encode_example[[datasets.BioSequence.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L99)

**Parameter:**

value (`str`, `bytes`, `Bio.SeqRecord.SeqRecord` atau `dict`) : Data yang diteruskan sebagai input ke fitur BioSequence.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.BioSequence.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L186)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

### BioStructure[[datasets.BioStructure]]

#### datasets.BioStructure[[datasets.BioStructure]]

```python
datasets.BioStructure(format: str = 'pdb', decode: bool = True, id: typing.Optional[str] = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L48)

**Parameter:**

format (`str`, defaultnya `"pdb"`) : Format struktur, yaitu `"pdb"` atau `"mmcif"`.

decode (`bool`, defaultnya `True`) : Apakah akan mendekode data struktur. Jika `False`, mengembalikan kamus dasar dalam format `{"path": path, "bytes": bytes}`.

**Eksperimental.** Fitur BioStructure `Feature` untuk membaca struktur makromolekul dari file struktur.

File struktur menyimpan koordinat tiga dimensi dari atom-atom molekul, yang dikelompokkan menjadi rantai dan residu. PDB dan mmCIF mendeskripsikan objek yang sama dan hanya berbeda pada parser yang digunakan, sehingga `format` memilih parser, bukan tipe.

Input: Fitur BioStructure menerima sebagai input:
- A `str`: Path absolut ke file struktur (yaitu, akses acak diizinkan).
- `pathlib.Path`: jalur ke file struktur (yaitu akses acak diizinkan).
- `dict` dengan kunci:
  - `path`: String berisi path relatif dari file struktur di dalam repositori dataset.
  - `bytes`: Byte dari file struktur. Ini berguna untuk file arsip dengan akses berurutan.

- Sebuah `Bio.PDB.Structure.Structure`: struktur biopython.

Contoh:

```py
>>> from datasets import Dataset, BioStructure
>>> ds = Dataset.from_dict({"st": ["path/to/1abc.pdb"]}).cast_column("st", BioStructure())
>>> ds.features["st"]
BioStructure(format='pdb', decode=True)
>>> ds[0]["st"]
<Structure id=1abc>
>>> ds = ds.cast_column("st", BioStructure(decode=False))
>>> ds[0]["st"]
{'bytes': None,
'path': 'path/to/1abc.pdb'}
```

#### cast_storage[[datasets.BioStructure.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L204)

**Parameter:**

storage (`Union[pa.StringArray, pa.StructArray]`) : array PyArrow untuk di-cast.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan arrow BioStructure, yaitu `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Cast array Arrow ke tipe penyimpanan arrow BioStructure. Tipe Arrow yang dapat dikonversi ke tipe penyimpanan pyarrow BioStructure adalah:

- `pa.string()` - harus berisi data "path"
- `pa.binary()` - harus berisi byte file
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - urutan tidak penting

#### decode_example[[datasets.BioStructure.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L138)

**Parameter:**

value (`str` atau `dict`) : String dengan path file absolut, atau kamus dengan kunci: - `path`: String dengan path file absolut atau relatif. - `bytes`: Byte dari file tersebut.

token_per_repo_id (`dict`, *opsional*) : Untuk mengakses dan mendekode file dari repositori privat di Hub, Anda dapat meneruskan kamus repo_id (`str`) -> token (`bool` atau `str`).

**Mengembalikan:**

`Bio.PDB.Structure.Structure`

Decode file struktur contoh menjadi struktur biopython.

#### embed_storage[[datasets.BioStructure.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L224)

**Parameter:**

storage (`pa.StructArray`) : array PyArrow untuk disematkan.

token_per_repo_id (`dict`, opsional) : Kamus repo_id -> token untuk mengambil byte file.

local_files (`bool`, defaultnya `True`) : Apakah data file lokal akan disematkan ke dalam array.

remote_files (`bool`, defaultnya `True`) : Apakah akan menyematkan data file jarak jauh ke dalam array.

**Mengembalikan:** `pa.StructArray`

Array dalam tipe penyimpanan arrow BioStructure.

Embed file struktur ke dalam array Arrow.

#### encode_example[[datasets.BioStructure.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')])
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L105)

**Parameter:**

value (`str`, `bytes`, `Bio.PDB.Structure.Structure` atau `dict`) : Data yang diteruskan sebagai input ke fitur BioStructure.

**Mengembalikan:**

`dict` dengan field "path" dan "bytes"

Enkodekan contoh ke dalam format untuk Arrow.

#### flatten[[datasets.BioStructure.flatten]]

```python
flatten()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L191)

Jika berada dalam keadaan dapat didekodekan, kembalikan fitur itu sendiri, selain itu ratakan fitur menjadi kamus.

## Sistem Berkas[[datasets.filesystems.is_remote_filesystem]]

#### datasets.filesystems.is_remote_filesystem[[datasets.filesystems.is_remote_filesystem]]

```python
datasets.filesystems.is_remote_filesystem(fs: AbstractFileSystem)
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/filesystems/__init__.py#L33)

**Parameter:**

fs (`fsspec.spec.AbstractFileSystem`) : Kelas super abstrak untuk sistem file yang pythonic, misalnya `fsspec.filesystem('file')` atau `s3fs.S3FileSystem`.

Memeriksa apakah `fs` adalah sistem file jarak jauh.

## Sidik jari[[datasets.fingerprint.Hasher]]

#### datasets.fingerprint.Hasher[[datasets.fingerprint.Hasher]]

```python
datasets.fingerprint.Hasher()
```

[Sumber](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L196)

Hasher yang menerima objek python sebagai input.

