Muat

Data Anda dapat disimpan di berbagai tempat; bisa di disk mesin lokal Anda, di repositori Github, dan dalam struktur data in-memory seperti kamus Python dan Pandas DataFrames. Di mana pun dataset disimpan, 🤗 Datasets dapat membantu Anda memuatnya.

Panduan ini akan menunjukkan cara memuat dataset dari:

• Hugging Face Hub
• File lokal
• Data di memori
• Offline
• Potongan spesifik dari sebuah split

Untuk detail lebih lanjut yang spesifik mengenai pemuatan modalitas dataset lain, lihat panduan pemuatan dataset audio, panduan pemuatan dataset gambar, panduan pemuatan dataset video, panduan pemuatan dataset mesh, panduan pemuatan dataset teks, atau panduan pemuatan tugas evaluasi agen.

Hugging Face Hub

Anda juga dapat memuat dataset dari repositori dataset mana pun di Hub! Mulailah dengan membuat repositori dataset dan unggah file data Anda. Sekarang Anda dapat menggunakan fungsi load_dataset() untuk memuat dataset.

Sebagai contoh, coba muat file dari repo demo ini dengan menyediakan namespace repo dan nama dataset. Repo dataset ini berisi file CSV, dan kode di bawah ini memuat dataset dari file CSV:

>>> from datasets import load_dataset
>>> dataset = load_dataset("lhoestq/demo1")

Beberapa dataset mungkin memiliki lebih dari satu versi berdasarkan tag, cabang, atau commit Git. Gunakan parameter revision untuk menentukan versi dataset yang ingin Anda muat:

>>> dataset = load_dataset(
...   "lhoestq/custom_squad",
...   revision="main"  # tag name, or branch name, or commit hash
... )

Lihat tutorial Upload a dataset to the Hub untuk detail lebih lanjut tentang cara membuat repositori dataset di Hub, dan cara mengunggah file data Anda.

Dataset memuat semua data ke dalam split train secara default, atau memeriksa penyebutan atau nama split di dalam nama file data (misalnya “train”, “test” dan “validation”). Gunakan parameter data_files untuk memetakan file data ke split seperti train, validation dan test:

>>> data_files = {"train": "train.csv", "test": "test.csv"}
>>> dataset = load_dataset("namespace/your_dataset_name", data_files=data_files)

Jika Anda tidak menentukan file data mana yang akan digunakan, load_dataset() akan mengembalikan semua file data. Hal ini dapat memakan waktu lama jika Anda memuat dataset besar seperti C4, yang berisi sekitar 13TB data.

Anda juga dapat memuat subset tertentu dari file dengan parameter data_files atau data_dir. Parameter ini dapat menerima path relatif yang dipecahkan ke path dasar yang sesuai dengan tempat dataset dimuat.

>>> from datasets import load_dataset

# load files that match the grep pattern
>>> c4_subset = load_dataset("allenai/c4", data_files="en/c4-train.0000*-of-01024.json.gz")

# load dataset from the en directory on the Hub
>>> c4_subset = load_dataset("allenai/c4", data_dir="en")

Parameter split juga dapat memetakan file data ke split tertentu:

>>> data_files = {"validation": "en/c4-validation.*.json.gz"}
>>> c4_validation = load_dataset("allenai/c4", data_files=data_files, split="validation")

File lokal dan jarak jauh

Dataset dapat dimuat dari file lokal yang tersimpan di komputer Anda dan dari file jarak jauh. Dataset kemungkinan besar disimpan sebagai file csv, json, txt, parquet atau tsfile. Fungsi load_dataset() dapat memuat masing-masing tipe file ini.

CSV

🤗 Datasets dapat membaca dataset yang terdiri dari satu atau beberapa file CSV (dalam hal ini, berikan file CSV Anda sebagai daftar):

>>> from datasets import load_dataset
>>> dataset = load_dataset("csv", data_files="my_file.csv")

Untuk detail lebih lanjut, lihat panduan cara memuat dataset tabular dari file CSV.

JSON

File JSON dimuat langsung dengan load_dataset() seperti yang ditunjukkan di bawah ini:

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json")

File JSON memiliki format yang beragam, tetapi kami menganggap format yang paling efisien adalah memiliki beberapa objek JSON; setiap baris mewakili satu baris data individu. Sebagai contoh:

{"a": 1, "b": 2.0, "c": "foo", "d": false}
{"a": 4, "b": -5.5, "c": null, "d": true}

Format JSON lain yang mungkin Anda temui adalah field bersarang, di mana Anda perlu menentukan argumen field seperti yang ditunjukkan berikut:

{"version": "0.1.0",
 "data": [{"a": 1, "b": 2.0, "c": "foo", "d": false},
          {"a": 4, "b": -5.5, "c": null, "d": true}]
}

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json", field="data")

Untuk memuat file JSON jarak jauh melalui HTTP, berikan URL-nya sebagai gantinya:

>>> base_url = "https://rajpurkar.github.io/SQuAD-explorer/dataset/"
>>> dataset = load_dataset("json", data_files={"train": base_url + "train-v1.1.json", "validation": base_url + "dev-v1.1.json"}, field="data")

Meskipun ini adalah format JSON yang paling umum, Anda akan melihat dataset lain yang diformat secara berbeda. 🤗 Datasets mengenali format lain ini dan akan kembali ke metode pemuatan JSON Python untuk menanganinya.

Parquet

File Parquet disimpan dalam format kolom, berbeda dengan file berbasis baris seperti CSV. Dataset besar dapat disimpan dalam file Parquet karena lebih efisien dan lebih cepat dalam mengembalikan kueri Anda.

Untuk memuat file Parquet:

>>> from datasets import load_dataset
>>> dataset = load_dataset("parquet", data_files={'train': 'train.parquet', 'test': 'test.parquet'})

Untuk memuat file Parquet jarak jauh melalui HTTP, berikan URL-nya sebagai gantinya:

>>> base_url = "https://huggingface.co/datasets/wikimedia/wikipedia/resolve/main/20231101.ab/"
>>> data_files = {"train": base_url + "train-00000-of-00001.parquet"}
>>> wiki = load_dataset("parquet", data_files=data_files, split="train")

Arrow

File Arrow disimpan dalam format kolomar in-memory, berbeda dengan format berbasis baris seperti CSV dan format tidak terkompresi seperti Parquet.

Untuk memuat file Arrow:

>>> from datasets import load_dataset
>>> dataset = load_dataset("arrow", data_files={'train': 'train.arrow', 'test': 'test.arrow'})

Untuk memuat file Arrow jarak jauh melalui HTTP, berikan URL-nya sebagai gantinya:

>>> base_url = "https://huggingface.co/datasets/croissantllm/croissant_dataset/resolve/main/english_660B_11/"
>>> data_files = {"train": base_url + "train/data-00000-of-00080.arrow"}
>>> wiki = load_dataset("arrow", data_files=data_files, split="train")

Arrow adalah format file yang digunakan oleh 🤗 Datasets di balik layar, sehingga Anda dapat memuat file Arrow lokal menggunakan Dataset.from_file() secara langsung:

>>> from datasets import Dataset
>>> dataset = Dataset.from_file("data.arrow")

Berbeda dengan load_dataset(), Dataset.from_file() melakukan memory mapping file Arrow tanpa menyiapkan dataset di cache, sehingga menghemat ruang disk Anda. Dalam kasus tersebut, direktori cache untuk menyimpan hasil pemrosesan antara akan menjadi direktori file Arrow.

Saat ini, hanya format streaming Arrow yang didukung. Format file Arrow IPC (juga dikenal sebagai Feather V2) tidak didukung.

Lance

Lance adalah format tabel lakehouse multimodal terbuka untuk AI. Tabel Lance dapat menyimpan secara native tidak hanya teks dan nilai skalar, tetapi juga objek biner besar (blobs) seperti gambar, audio, dan video berdampingan dengan data tabular Anda.

>>> from datasets import load_dataset
>>> lance_base_url = "lance-format/laion-1m"

Untuk mengalirkan dataset tanpa menyalinnya ke mesin lokal Anda, tentukan parameter streaming=True:

ds = load_dataset(lance_base_url, split="train", streaming=True)
# Take first three rows
for row in ds.take(3):
    print(row["caption"], row["image"])

Ini akan mengembalikan caption gambar dan byte gambar dalam satu permintaan.

Vortex

Vortex adalah format file kolom yang dibangun untuk pemindaian cepat pada data terkompresi. Instal dengan pip install vortex-data, lalu muat file .vortex seperti format paket lainnya:

>>> from datasets import load_dataset
>>> dataset = load_dataset("vortex", data_files="data.vortex", split="train")

Kolom dan filter diteruskan ke dalam pemindaian Vortex, sehingga hanya baris dan kolom yang Anda minta yang dibaca. Hal ini juga berfungsi saat streaming, yang memungkinkan Anda memfilter dataset di Hub tanpa mengunduh bagian yang tidak cocok:

>>> filters = [("label", "==", 1)]
>>> dataset = load_dataset(vortex_dataset_id, columns=["text", "label"], filters=filters, streaming=True, split="train")

Filter menggunakan bentuk normal disjunktif yang sama dengan loader Parquet: daftar predikat (column, operator, value) adalah konjungsi, dan daftar dari predikat tersebut adalah disjungsi. Null mengikuti semantik SQL — null tidak memenuhi perbandingan apa pun, sehingga baris yang kolom terfilternya null tidak pernah dikembalikan, termasuk untuk not in. Untuk apa pun yang tidak dapat diekspresikan oleh bentuk tersebut, berikan ekspresi Vortex sebagai gantinya:

>>> import vortex.expr as ve
>>> dataset = load_dataset(vortex_dataset_id, filters=ve.column("score") >= 0.5, split="train")

Vortex membuka file secara mandiri, bukan melalui fsspec, sehingga data_files dapat menunjuk ke path lokal, dataset Hub, dan lokasi remote yang dibaca secara native oleh Vortex (HTTP dan object store umum) — tetapi tidak di dalam arsip (zip://...) atau protokol khusus fsspec lainnya.

File HDF5

HDF5 file sering digunakan untuk menyimpan sejumlah besar data numerik dalam komputasi ilmiah dan machine learning. Memuat file HDF5 dengan 🤗 Datasets mirip dengan memuat file CSV:

>>> from datasets import load_dataset
>>> dataset = load_dataset("hdf5", data_files="data.h5")

Perhatikan bahwa loader HDF5 mengasumsikan bahwa file memiliki struktur “tabular”, yaitu bahwa semua dataset dalam file memiliki (jumlah baris yang sama) pada dimensi pertamanya.

TsFile

TsFile adalah format file kolom yang dirancang untuk data deret waktu, digunakan sebagai lapisan penyimpanan native dari Apache IoTDB. Format ini secara native merepresentasikan timestamp, tag perangkat, dan field pengukuran, serta mempertahankan indeks waktu internal yang memungkinkan pemangkasan rentang waktu yang efisien.

Setiap baris dalam dataset yang dihasilkan sesuai dengan satu device (diidentifikasi oleh kolom TAG-nya); kolom time dan setiap kolom FIELD adalah kolom list yang berisi seluruh time series dari device tersebut, diurutkan berdasarkan waktu secara menaik.

Untuk memuat TsFile:

>>> from datasets import load_dataset
>>> dataset = load_dataset("tsfile", data_files="my_data.tsfile")

Filter berdasarkan rentang waktu — batasannya diteruskan ke indeks waktu internal TsFile dan menerima epoch int, datetime, date, string ISO-8601, atau skalar timestamp pyarrow:

>>> from datetime import datetime
>>> dataset = load_dataset(
...     "tsfile",
...     data_files="my_data.tsfile",
...     start_time=datetime(2023, 11, 14),
...     end_time=datetime(2023, 11, 15),
... )

Untuk detail lebih lanjut, lihat panduan cara memuat data TsFile.

Harbor

Dataset Harbor adalah kumpulan task yang digunakan untuk mengevaluasi agen AI. Dataset ini terdiri dari direktori, bukan file data: setiap task adalah sebuah direktori yang berisi file konfigurasi task.toml dan file instruction.md, serta lingkungan, verifier, dan solusinya.

Setiap baris dari dataset yang dihasilkan menggambarkan satu tugas (instruksinya, task.toml-nya, file yang disertakan), dan memuatnya tidak pernah menjalankan apa pun:

>>> from datasets import load_dataset
>>> dataset = load_dataset("harborframework/terminal-bench")
>>> dataset["train"][0]["task_id"]
'tasks/atrx-vep-crispr'

Untuk detail lebih lanjut, lihat panduan cara memuat tugas evaluasi agen.

PDB

PDB (Protein Data Bank) adalah format lebar tetap warisan untuk merepresentasikan struktur makromolekul 3D. Meskipun mmCIF adalah standar modern, PDB masih banyak digunakan dan banyak dataset historis berada dalam format ini.

Setiap baris adalah satu file struktur, mengikuti tata letak folder yang sama seperti ImageFolder: nama subfolder menjadi label dan file metadata.csv/metadata.jsonl menambahkan metadata per struktur. Kolom structure menggunakan BioStructure dengan format="pdb" dan didekode menjadi objek Bio.PDB.Structure.Structure yang berisi model, rantai, residu, dan atom dari file tersebut. Dekoding memerlukan biopython; tanpa itu, mengakses struktur yang didekodekan akan memicu ImportError.

Untuk memuat file PDB dari direktori:

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("pdb", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='pdb', decode=True)

Untuk mengakses kamus {"bytes": ..., "path": ...} yang mendasarinya tanpa melakukan dekoding atau memerlukan biopython, cast kolom dengan decode=False:

>>> dataset = dataset.cast_column("structure", BioStructure(format="pdb", decode=False))

Ekstensi .pdb dan .ent didukung.

SQL

Baca isi database dengan from_sql() dengan menentukan URI untuk terhubung ke database Anda. Anda dapat membaca baik nama tabel maupun kueri:

>>> from datasets import Dataset
# load entire table
>>> dataset = Dataset.from_sql("data_table_name", con="sqlite:///sqlite_file.db")
# load from query
>>> dataset = Dataset.from_sql("SELECT text FROM table WHERE length(text) > 100 LIMIT 10", con="sqlite:///sqlite_file.db")

Untuk detail lebih lanjut, lihat panduan cara memuat dataset tabular dari database SQL.

WebDataset

Format WebDataset didasarkan pada arsip TAR dan cocok untuk dataset gambar besar. Karena ukurannya, WebDataset umumnya dimuat dalam mode streaming (menggunakan streaming=True).

Anda dapat memuat WebDataset seperti ini:

>>> from datasets import load_dataset
>>>
>>> path = "path/to/train/*.tar"
>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True)

Untuk memuat WebDatasets jarak jauh melalui HTTP, berikan URL-nya sebagai gantinya:

>>> from datasets import load_dataset
>>>
>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar"
>>> urls = [base_url.format(i=i) for i in range(4)]
>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True)

mmCIF

mmCIF (macromolecular Crystallographic Information File) adalah format standar modern untuk merepresentasikan struktur makromolekul 3D, yang digunakan oleh Protein Data Bank (PDB) sejak 2014.

Setiap baris adalah satu file struktur, mengikuti tata letak folder yang sama seperti ImageFolder: nama subfolder menjadi label dan file metadata.csv/metadata.jsonl menambahkan metadata per struktur. Kolom structure menggunakan BioStructure dengan format="mmcif" dan didekode menjadi objek Bio.PDB.Structure.Structure yang berisi model, rantai, residu, dan atom dari file tersebut. Dekoding memerlukan biopython; tanpa pustaka ini, mengakses struktur yang telah didekode akan memicu ImportError.

Untuk memuat file mmCIF dari sebuah direktori:

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("mmcif", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='mmcif', decode=True)

Untuk mengakses kamus {"bytes": ..., "path": ...} yang mendasarinya tanpa melakukan dekoding atau memerlukan biopython, cast kolom dengan decode=False:

>>> dataset = dataset.cast_column("structure", BioStructure(format="mmcif", decode=False))

Ekstensi .cif dan .mmcif didukung.

GenBank

GenBank adalah format berbasis teks dari NCBI untuk sekuens nukleotida dan protein beserta anotasi mereka. File menggunakan ekstensi .gb, .gbk, atau .genbank (opsional terkompresi), dan bagian FEATURES dari setiap record didekodekan menjadi objek terstruktur.

Selain kolom yang telah diurai secara ringan, setiap baris mencakup kolom record bertipe BioSequence(format="genbank"), yang akan didekode menjadi Bio.SeqRecord.SeqRecord saat biopython terpasang. Ubah tipe kolom ini menjadi BioSequence(format="genbank", decode=False) untuk mengakses byte record asli sebagai {"bytes": ..., "path": None}, atau abaikan kolom tersebut dengan columns=[...] untuk hanya menggunakan kolom yang telah diurai tanpa biopython.

Untuk memuat file GenBank:

>>> from datasets import load_dataset
>>> dataset = load_dataset("genbank", data_files="*.gb", split="train")

Anda dapat mencobanya pada dataset contoh kecil berisi rekaman NCBI asli (salah satunya digzip untuk menunjukkan bahwa file terkompresi dimuat secara transparan):

>>> from datasets import load_dataset
>>> dataset = load_dataset("ermiaazarkhalili/datasets-genbank-test", data_files="*.gb*", split="train")
>>> dataset[0]["locus_name"], dataset[0]["organism"], dataset[0]["length"]

FASTQ

FASTQ adalah format berbasis teks untuk menyimpan sekuens nukleotida beserta skor kualitasnya, yang banyak digunakan untuk data sekuensing berkapasitas tinggi.

Muat file FASTQ:

>>> from datasets import load_dataset
>>> dataset = load_dataset("fastq", data_files="reads.fq")

Loader mengembalikan lima kolom:

Membaca kolom yang telah diurai tidak memerlukan Biopython; hilangkan record dengan columns, atau gunakan dataset.cast_column("record", BioSequence(decode=False)) (diimpor dari datasets) untuk mengakses penyimpanan {"bytes": ..., "path": None} tanpa dekoding.

Muat hanya kolom tertentu:

>>> dataset = load_dataset("fastq", data_files="reads.fq", columns=["sequence", "quality"])

File terkompresi (.fq.gz, .fastq.gz, .fq.bz2, .fq.xz) dideteksi dan didekompresi secara otomatis.

FASTA

FASTA adalah format berbasis teks untuk merepresentasikan sekuens nukleotida (DNA/RNA) atau sekuens peptida (protein), yang banyak digunakan dalam bioinformatika.

Untuk memuat file FASTA:

>>> from datasets import load_dataset
>>> dataset = load_dataset("fasta", data_files="sequences.fasta")

Ini mengembalikan dataset dengan kolom-kolom berikut:

• id: Pengenal urutan (kata pertama setelah >)
• description: Baris deskripsi lengkap (semua setelah id)
• sequence: Urutan biologis (DNA/RNA/protein)
• record: Sebuah BioSequence dengan format="fasta" yang menyimpan byte asli dari setiap record, dan didekode menjadi SeqRecord Biopython saat diakses.

Membaca kolom yang telah diurai tidak memerlukan Biopython; hilangkan record dengan columns, atau gunakan dataset.cast_column("record", BioSequence(decode=False)) (diimpor dari datasets) untuk mengakses penyimpanan {"bytes": ..., "path": None} tanpa dekoding.

Anda juga dapat memuat hanya kolom tertentu:

>>> dataset = load_dataset("fasta", data_files="sequences.fa", columns=["id", "sequence"])

File FASTA dengan berbagai ekstensi didukung: .fa, .fasta, .fna (asam nukleat), .ffn (nukleotida dari wilayah gen), .faa (asam amino), dan .frn (RNA non-pengkode). File terkompresi (gzip, bzip2, xz) dideteksi dan didekompresi secara otomatis.

File jarak jauh

Jika Anda memiliki file jarak jauh yang kemungkinan disimpan sebagai csv, json, txt, parquet atau format apa pun yang didukung, fungsi load_dataset() dapat memuatnya jika Anda menentukan jalur jarak jauh mereka:

• URL https:// untuk file online publik, misalnya data_files=["https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json"]
• URL hf:// untuk file di Repositori Dataset atau Storage Bucket mana pun di Hugging Face, misalnya data_files=["hf://datasets/karpathy/tinystories-gpt4-clean/tinystories_gpt4_clean.parquet"] atau data_files=["hf://buckets/julien-c/my-training-bucket/julien/affluence.csv"]

Pemrosesan Multi

Ketika sebuah dataset terdiri dari beberapa file (yang kami sebut “shards”), langkah pengunduhan dan persiapan dataset dapat dipercepat secara signifikan.

Anda dapat memilih berapa banyak proses yang ingin digunakan untuk menyiapkan dataset secara paralel menggunakan num_proc. Dalam kasus ini, setiap proses diberikan subset shard untuk disiapkan:

from datasets import load_dataset

imagenet = load_dataset("timm/imagenet-1k-wds", num_proc=8)
ml_librispeech_spanish = load_dataset("facebook/multilingual_librispeech", "spanish", num_proc=8)

Data di memori

🤗 Datasets juga memungkinkan Anda membuat Dataset langsung dari struktur data in-memory seperti kamus Python dan DataFrames Pandas.

Kamus Python

Load Python dictionaries with from_dict():

>>> from datasets import Dataset
>>> my_dict = {"a": [1, 2, 3]}
>>> dataset = Dataset.from_dict(my_dict)

Daftar kamus Python

Muat daftar kamus Python dengan from_list():

>>> from datasets import Dataset
>>> my_list = [{"a": 1}, {"a": 2}, {"a": 3}]
>>> dataset = Dataset.from_list(my_list)

Generator Python

Buat dataset dari generator Python dengan from_generator():

>>> from datasets import Dataset
>>> def my_gen():
...     for i in range(1, 4):
...         yield {"a": i}
...
>>> dataset = Dataset.from_generator(my_gen)

Pendekatan ini mendukung pemuatan data yang lebih besar daripada memori yang tersedia.

Anda juga dapat mendefinisikan dataset yang dipecah (sharded) dengan meneruskan daftar ke gen_kwargs:

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

Pandas DataFrame

Load Pandas DataFrames with from_pandas():

>>> from datasets import Dataset
>>> import pandas as pd
>>> df = pd.DataFrame({"a": [1, 2, 3]})
>>> dataset = Dataset.from_pandas(df)

Untuk detail lebih lanjut, lihat panduan cara memuat dataset tabular dari Pandas DataFrames.

Offline

Meskipun Anda tidak memiliki koneksi internet, memuat dataset tetap dimungkinkan. Selama Anda pernah mengunduh dataset dari repositori Hub sebelumnya, dataset tersebut seharusnya sudah di-cache. Artinya, Anda dapat memuat ulang dataset dari cache dan menggunakannya secara offline.

Jika Anda tahu bahwa Anda tidak akan memiliki akses internet, Anda dapat menjalankan 🤗 Datasets dalam mode offline penuh. Ini menghemat waktu karena alih-alih menunggu unduhan Dataset builder habis waktu, 🤗 Datasets akan langsung mencari di cache. Atur variabel lingkungan HF_HUB_OFFLINE ke 1 untuk mengaktifkan mode offline penuh.

Slice membagi

Anda juga dapat memilih untuk hanya memuat potongan tertentu dari sebuah split. Ada dua opsi untuk memotong (slicing) sebuah split: menggunakan string atau API ReadInstruction. String lebih ringkas dan mudah dibaca untuk kasus sederhana, sedangkan ReadInstruction lebih mudah digunakan dengan parameter pemotongan yang bervariasi.

Gabungkan split train dan test dengan cara:

 
String API 
ReadInstruction
>>> train_test_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train+test")

Pilih baris tertentu dari split train:

 
String API 
ReadInstruction
>>> train_10_20_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[10:20]")

Atau pilih persentase dari split dengan:

 
String API 
ReadInstruction
>>> train_10pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]")

Pilih kombinasi persentase dari setiap split:

 
String API 
ReadInstruction
>>> train_10_80pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]+train[-80%:]")

Terakhir, Anda bahkan dapat membuat split yang divalidasi silang. Contoh di bawah ini membuat split validasi silang 10-fold. Setiap dataset validasi adalah potongan 10%, dan dataset pelatihan terdiri dari potongan komplementer 90% yang tersisa:

 
String API 
ReadInstruction
>>> val_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[{k}%:{k+10}%]" for k in range(0, 100, 10)])
>>> train_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[:{k}%]+train[{k+10}%:]" for k in range(0, 100, 10)])

Pemotongan dan pembulatan persentase

Perilaku default adalah membulatkan batas-batas ke bilangan bulat terdekat untuk dataset di mana batas slice yang diminta tidak terbagi rata oleh 100. Seperti yang ditunjukkan di bawah, beberapa slice mungkin berisi lebih banyak contoh daripada yang lain. Misalnya, jika split train berikut berisi 999 rekaman, maka:

# 19 records, from 500 (included) to 519 (excluded).
>>> train_50_52_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%]")
# 20 records, from 519 (included) to 539 (excluded).
>>> train_52_54_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%]")

Jika Anda ingin pembagian berukuran sama, gunakan pembulatan pct1_dropremainder sebagai gantinya. Ini memperlakukan batas persentase yang ditentukan sebagai kelipatan 1%.

# 18 records, from 450 (included) to 468 (excluded).
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train", from_=50, to=52, unit="%", rounding="pct1_dropremainder"))
# 18 records, from 468 (included) to 486 (excluded).
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train",from_=52, to=54, unit="%", rounding="pct1_dropremainder"))
# Or equivalently:
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%](pct1_dropremainder)")
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%](pct1_dropremainder)")

Pembulatan pct1_dropremainder dapat memotong contoh terakhir dalam dataset jika jumlah contoh dalam dataset Anda tidak habis dibagi 100.

Pemecahan Masalah

Kadang-kadang, Anda mungkin mendapatkan hasil yang tidak terduga saat memuat dataset. Dua masalah paling umum yang mungkin Anda temui adalah mengunduh dataset secara manual dan menentukan fitur dari dataset.

Tentukan fitur

Saat Anda membuat dataset dari file lokal, Features akan disimpulkan secara otomatis oleh Apache Arrow. Namun, fitur dataset mungkin tidak selalu sesuai dengan ekspektasi Anda, atau Anda mungkin ingin mendefinisikan fitur tersebut sendiri. Contoh berikut menunjukkan cara Anda dapat menambahkan label kustom dengan fitur ClassLabel.

Mulai dengan mendefinisikan label Anda sendiri menggunakan kelas Features:

>>> class_names = ["sadness", "joy", "love", "anger", "fear", "surprise"]
>>> emotion_features = Features({'text': Value('string'), 'label': ClassLabel(names=class_names)})

Selanjutnya, tentukan parameter features di load_dataset() dengan fitur yang baru saja Anda buat:

>>> dataset = load_dataset('csv', data_files=file_dict, delimiter=';', column_names=['text', 'label'], features=emotion_features)

Sekarang, saat Anda melihat fitur dataset Anda, Anda dapat melihat bahwa dataset tersebut menggunakan label kustom yang Anda definisikan:

>>> dataset['train'].features
{'text': Value('string'),
'label': ClassLabel(names=['sadness', 'joy', 'love', 'anger', 'fear', 'surprise'])}