Hugging Face's logo

資料集文件

串流

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

串流

資料集串流讓您無需下載即可處理資料集。當您疊代資料集時，資料會以串流方式傳輸。這在以下情況特別有幫助：

  • 您不想等待極大的資料集下載完成。
  • 資料集大小超出電腦上可用的磁碟空間。
  • 您只想快速瀏覽資料集的少數幾個樣本。

例如，HuggingFaceFW/fineweb 資料集的英文分割區塊有 45 TB，但您可以透過串流即時使用它。如以下所示，在 load_dataset() 中設定 streaming=True 來串流資料集

>>> from datasets import load_dataset
>>> dataset = load_dataset('HuggingFaceFW/fineweb', split='train', streaming=True)
>>> print(next(iter(dataset)))
{'text': 'How AP reported in all formats from tornado-stricken regionsMarch 8, 2012\nWhen the first serious bout of tornadoes of 2012 blew through middle America in the middle of the night, they touched down in places hours from any AP bureau...', ...,
 'language_score': 0.9721424579620361, 'token_count': 717}

資料集串流還允許您處理由本機檔案組成的資料集，無需進行任何轉換。在這種情況下，當您疊代資料集時，資料會從本機檔案以串流方式傳輸。這在以下情況特別有幫助：

  • 您不想等待極大的本機資料集轉換為 Arrow 格式。
  • 轉換後的檔案大小會超出電腦上可用的磁碟空間。
  • 您只想快速瀏覽資料集的少數幾個樣本。
  • 您只想載入特定欄位或有效率地篩選 Parquet 資料集。

例如，您可以串流數百個壓縮 JSONL 檔案的本機資料集，例如 oscar-corpus/OSCAR-2201，並即時使用它

>>> from datasets import load_dataset
>>> data_files = {'train': 'path/to/OSCAR-2201/compressed/en_meta/*.jsonl.gz'}
>>> dataset = load_dataset('json', data_files=data_files, split='train', streaming=True)
>>> print(next(iter(dataset)))
{'id': 0, 'text': 'Founded in 2015, Golden Bees is a leading programmatic recruitment platform dedicated to employers, HR agencies and job boards. The company has developed unique HR-custom technologies and predictive algorithms to identify and attract the best candidates for a job opportunity.', ...

Parquet 是一種 columnar 格式，允許您串流並僅載入部分欄位，而忽略不需要的欄位。Parquet 還儲存中繼資料，例如欄位統計資訊（在檔案和列群組層級），從而實現高效篩選。使用 datasets.packaged_modules.parquet.ParquetConfig 的 columns 和 filters 參數來串流 Parquet 資料集、選擇欄位並套用篩選條件

>>> from datasets import load_dataset
>>> dataset = load_dataset('HuggingFaceFW/fineweb', split='train', streaming=True, columns=["url", "date"])
>>> print(next(iter(dataset)))
{'url': 'http://%20jwashington@ap.org/Content/Press-Release/2012/How-AP-reported-in-all-formats-from-tornado-stricken-regions', 'date': '2013-05-18T05:48:54Z'}
>>> dataset = load_dataset('HuggingFaceFW/fineweb', split='train', streaming=True, filters=[("language_score", ">=", 0.99)])
>>> print(next(iter(dataset)))
{'text': 'Everyone wishes for something. And lots of people believe they know how to make their wishes come true with magical thinking.\nWhat is it? "Magical thinking is a belief in forms of causation, with no known physical basis," said Professor Emily Pronin of Princeton...', ...,
 'language_score': 0.9900368452072144, 'token_count': 716}

以串流模式載入資料集會建立一個新的資料集型別實例（而不是經典的 Dataset 物件），稱為 IterableDataset。這種特殊型別的資料集有自己的一套處理方法，如下所示。

IterableDataset 對於模型訓練等疊代式工作非常有用。您不應該將 IterableDataset 用於需要隨機存取範例的工作，因為您必須使用 for 迴圈疊代整個資料集。取得可疊代資料集中的最後一個範例將需要您疊代所有先前的範例。您可以在Dataset vs. IterableDataset 指南中找到更多詳細資訊。

欄位索引

有時疊代特定欄位的值會很方便。幸運的是，IterableDataset 支援欄位索引

>>> from datasets import load_dataset
>>> dataset = load_dataset("allenai/c4", "en", streaming=True, split="train")
>>> print(next(iter(dataset["text"])))
Beginners BBQ Class Taking Place in Missoula!...

從 Dataset 轉換

如果您有一個現有的 Dataset 物件，您可以使用 to_iterable_dataset() 函數將其轉換為 IterableDataset。這實際上比在 load_dataset() 中設定 streaming=True 參數更快，因為資料是從本機檔案串流的。

>>> from datasets import load_dataset

# faster 🐇
>>> dataset = load_dataset("ethz/food101")
>>> iterable_dataset = dataset.to_iterable_dataset()

# slower 🐢
>>> iterable_dataset = load_dataset("ethz/food101", streaming=True)

to_iterable_dataset() 函數在實例化 IterableDataset 時支援分片。這在處理大型資料集時非常有用，如果您想隨機重排資料集或啟用 PyTorch DataLoader 的快速平行載入。

>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("ethz/food101")
>>> iterable_dataset = dataset.to_iterable_dataset(num_shards=64) # shard the dataset
>>> iterable_dataset = iterable_dataset.shuffle(buffer_size=10_000)  # shuffles the shards order and use a shuffle buffer when you start iterating
dataloader = torch.utils.data.DataLoader(iterable_dataset, num_workers=4)  # assigns 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating

打亂 (Shuffle)

與一般的 Dataset 物件一樣，您也可以使用 IterableDataset.shuffle() 隨機重排 IterableDataset。

buffer_size 參數控制從中隨機取樣範例的緩衝區大小。假設您的資料集有一百萬個範例，並且您將 buffer_size 設定為一萬。IterableDataset.shuffle() 將從緩衝區中的前一萬個範例中隨機選擇範例。緩衝區中選定的範例會被新範例替換。預設情況下，緩衝區大小為 1,000。

>>> from datasets import load_dataset
>>> dataset = load_dataset('HuggingFaceFW/fineweb', split='train', streaming=True)
>>> shuffled_dataset = dataset.shuffle(seed=42, buffer_size=10_000)

如果資料集被分片為多個檔案，IterableDataset.shuffle() 也會隨機重排分片的順序。

重新隨機重排

有時您可能希望在每個訓練週期後重新隨機重排資料集。這將需要您為每個訓練週期設定不同的種子。在訓練週期之間使用 IterableDataset.set_epoch() 來告知資料集您目前位於哪個訓練週期。

您的種子實際上會變成：初始種子 + 目前訓練週期。

>>> for epoch in range(epochs):
...     shuffled_dataset.set_epoch(epoch)
...     for example in shuffled_dataset:
...         ...

分割資料集

您可以透過兩種方式分割資料集

>>> dataset = load_dataset('HuggingFaceFW/fineweb', split='train', streaming=True)
>>> dataset_head = dataset.take(2)
>>> list(dataset_head)
[{'text': "How AP reported in all formats from tor...},
 {'text': 'Did you know you have two little yellow...}]
>>> train_dataset = shuffled_dataset.skip(1000)

take 和 skip 會阻止對 shuffle 的後續呼叫，因為它們鎖定了分片的順序。您應該在分割資料集之前先 shuffle 資料集。

分片

🤗 Datasets 支援分片，將非常大的資料集分割成預定義數量的區塊。在 shard() 中指定 num_shards 參數來決定資料集要分割成多少個分片。您還需要提供要返回的分片索引，透過 index 參數。

例如，amazon_polarity 資料集有 4 個分片（在這種情況下，它們是 4 個 Parquet 檔案）

>>> from datasets import load_dataset
>>> dataset = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True)
>>> print(dataset)
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 4
})

將資料集分片成兩個區塊後，第一個區塊將只有 2 個分片

>>> dataset.shard(num_shards=2, index=0)
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 2
})

要增加資料集的分片數量，您可以使用 IterableDataset.reshard()

>>> dataset.reshard()
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 3600
})

重新分片機制取決於資料集檔案格式。例如，對於 Parquet，它使用列群組而不是每個分片一個檔案進行重新分片。請參閱 IterableDataset.reshard() 的文件，了解它如何適用於每種格式。

如果您的資料集在重新分片後仍有 dataset.num_shards==1，您應該改用 IterableDataset.skip() 和 IterableDataset.take() 來分塊它。

串接 (Concatenate)

如果獨立的資料集具有相同的欄位類型，則可以將它們串接。使用 concatenate_datasets() 串接資料集

>>> from datasets import concatenate_datasets, load_dataset

>>> stories = load_dataset("ajibawa-2023/General-Stories-Collection", split="train", streaming=True)
>>> stories = stories.select_columns(["text"])  # only keep the 'text' column
IterableDataset({
    features: Unknown,
    num_shards: 10
})

>>> wiki = load_dataset("wikimedia/wikipedia", "20231101.en", split="train", streaming=True)
>>> wiki = wiki.select_columns(["text"])  # only keep the 'text' column
IterableDataset({
    features: ['text'],
    num_shards: 41
})

>>> bert_dataset = concatenate_datasets([stories, wiki])
IterableDataset({
    features: ['text'],
    num_shards: 51
})

串接資料集的分片是輸入資料集的分片。

只要資料集具有相同的列數，您還可以透過設定 axis=1 來水平串接兩個資料集

>>> from datasets import IterableDataset
>>> stories_ids = IterableDataset.from_dict({"ids": list(range(num_stories))})
>>> stories_with_ids = concatenate_datasets([stories, stories_ids], axis=1)

在這種情況下，串接的資料集只有 1 個分片，以避免輸入資料集產生未對齊的分片。

交錯

interleave_datasets() 可以將 IterableDataset 與其他資料集結合，如果它們具有相同的欄位類型。結合後的資料集會交替返回原始資料集中的範例。

>>> from datasets import interleave_datasets
>>> es_dataset = load_dataset('allenai/c4', 'es', split='train', streaming=True)
IterableDataset({
    features: Unknown,
    num_shards: 2048
})
>>> fr_dataset = load_dataset('allenai/c4', 'fr', split='train', streaming=True)
IterableDataset({
    features: Unknown,
    num_shards: 2048
})

>>> multilingual_dataset = interleave_datasets([es_dataset, fr_dataset])
IterableDataset({
    features: ['text', 'timestamp', 'url'],
    num_shards: 2048
})
>>> list(multilingual_dataset.take(2))
[{'text': 'Comprar Zapatillas para niña en chancla con goma por...'},
 {'text': 'Le sacre de philippe ier, 23 mai 1059 - Compte Rendu...'}]

定義每個原始資料集的抽樣機率，以更精確地控制它們的抽樣和結合方式。使用 probabilities 參數設定您想要的抽樣機率

>>> multilingual_dataset_with_oversampling = interleave_datasets([es_dataset, fr_dataset], probabilities=[0.8, 0.2], seed=42)
>>> list(multilingual_dataset_with_oversampling.take(2))
[{'text': 'Comprar Zapatillas para niña en chancla con goma por...'},
 {'text': 'Chevrolet Cavalier Usados en Bogota - Carros en Vent...'}]

最終資料集約 80% 由 es_dataset 構成，20% 由 fr_dataset 構成。

您還可以指定 stopping_strategy。預設策略 first_exhausted 是一種次級抽樣策略，即一旦其中一個資料集樣本用盡，資料集建構就會停止。您可以指定 stopping_strategy=all_exhausted 來執行過度抽樣策略。在這種情況下，一旦每個資料集中的所有樣本至少被添加一次，資料集建構就會停止。實際上，這意味著如果一個資料集用盡，它將返回到該資料集的開頭，直到達到停止條件。請注意，如果沒有指定抽樣機率，新資料集將具有 max_length_datasets*nb_dataset 個樣本。還有 stopping_strategy=all_exhausted_without_replacement，以確保每個樣本只被看一次。

為了確保使用分片進行適當的平行處理，交錯資料集的分片至少包含每個輸入資料集的 1 個分片。因此，交錯資料集的分片層級是輸入資料集的最小分片層級。

例如，如果輸入資料集分別有 32、48 和 128 個分片，則交錯資料集有 32 = min(32, 48, 128) 個分片，每個新分片包含來自第一個資料集的 1 個分片、來自第二個資料集的 1-2 個分片以及來自第三個資料集的 4 個分片。

重新命名、移除和轉換型別

以下方法允許您修改資料集的欄位。這些方法對於重新命名或移除欄位以及將欄位變更為一組新的特徵非常有用。

重新命名

當您需要重新命名資料集中的欄位時，請使用 IterableDataset.rename_column()。與原始欄位相關聯的特徵實際上會移動到新的欄位名稱下，而不是僅僅原地替換原始欄位。

向 IterableDataset.rename_column() 提供原始欄位名稱和新的欄位名稱

>>> from datasets import load_dataset
>>> dataset = load_dataset('allenai/c4', 'en', streaming=True, split='train')
>>> dataset = dataset.rename_column("text", "content")

移除

當您需要移除一個或多個欄位時，請將要移除的欄位名稱傳給 IterableDataset.remove_columns()。透過提供欄位名稱列表來移除多個欄位

>>> from datasets import load_dataset
>>> dataset = load_dataset('allenai/c4', 'en', streaming=True, split='train')
>>> dataset = dataset.remove_columns('timestamp')

轉型 (Cast)

IterableDataset.cast() 會變更一個或多個欄位的特徵型別。此方法以您新的 Features 作為其引數。以下範例程式碼顯示了如何變更 ClassLabel 和 Value 的特徵型別

>>> from datasets import load_dataset
>>> dataset = load_dataset('nyu-mll/glue', 'mrpc', split='train', streaming=True)
>>> dataset.features
{'sentence1': Value('string'),
'sentence2': Value('string'),
'label': ClassLabel(names=['not_equivalent', 'equivalent']),
'idx': Value('int32')}

>>> from datasets import ClassLabel, Value
>>> new_features = dataset.features.copy()
>>> new_features["label"] = ClassLabel(names=['negative', 'positive'])
>>> new_features["idx"] = Value('int64')
>>> dataset = dataset.cast(new_features)
>>> dataset.features
{'sentence1': Value('string'),
'sentence2': Value('string'),
'label': ClassLabel(names=['negative', 'positive']),
'idx': Value('int64')}

型別轉換僅在原始特徵型別和新特徵型別相容時才有效。例如，如果原始欄位只包含 1 和 0，您可以將具有特徵型別 Value('int32') 的欄位轉換為 Value('bool')。

使用 IterableDataset.cast_column() 僅變更一個欄位的特徵型別。將欄位名稱及其新的特徵型別作為引數傳遞

>>> dataset.features
{'audio': Audio(sampling_rate=44100, mono=True)}

>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
>>> dataset.features
{'audio': Audio(sampling_rate=16000, mono=True)}

映射 (Map)

與用於一般 Dataset 的 Dataset.map() 函數類似，🤗 Datasets 提供了 IterableDataset.map() 用於處理 IterableDataset。IterableDataset.map() 在串流範例時即時應用處理。

它允許您將處理函數應用於資料集中的每個範例，無論是獨立處理還是批次處理。此函數甚至可以建立新的列和欄位。

以下範例演示了如何分詞 IterableDataset。該函數需要接受並輸出一個 dict

>>> def add_prefix(example):
...     example['text'] = 'My text: ' + example['text']
...     return example

接著，使用 IterableDataset.map() 將此函數應用於資料集

>>> from datasets import load_dataset
>>> dataset = load_dataset('allenai/c4', 'en', streaming=True, split='train')
>>> updated_dataset = dataset.map(add_prefix)
>>> list(updated_dataset.take(3))
[{'text': 'My text: Beginners BBQ Class Taking Place in Missoula!\nDo you want to get better at making...',
  'timestamp': '2019-04-25 12:57:54',
  'url': 'https://klyq.com/beginners-bbq-class-taking-place-in-missoula/'},
 {'text': 'My text: Discussion in \'Mac OS X Lion (10.7)\' started by axboi87, Jan 20, 2012.\nI\'ve go...',
  'timestamp': '2019-04-21 10:07:13',
  'url': 'https://forums.macrumors.com/threads/restore-from-larger-disk-to-smaller-disk.1311329/'},
 {'text': 'My text: Foil plaid lycra and spandex shortall with metallic slinky insets. Attached metall...',
  'timestamp': '2019-04-25 10:40:23',
  'url': 'https://awishcometrue.com/Catalogs/Clearance/Tweens/V1960-Find-A-Way'}]

讓我們看另一個範例，但這次您將使用 IterableDataset.map() 移除欄位。當您移除欄位時，它只會在範例提供給映射函數後才被移除。這允許映射函數在欄位被移除之前使用其內容。

在 IterableDataset.map() 中使用 remove_columns 引數指定要移除的欄位

>>> updated_dataset = dataset.map(add_prefix, remove_columns=["timestamp", "url"])
>>> list(updated_dataset.take(3))
[{'text': 'My text: Beginners BBQ Class Taking Place in Missoula!\nDo you want to get better at making...'},
 {'text': 'My text: Discussion in \'Mac OS X Lion (10.7)\' started by axboi87, Jan 20, 2012.\nI\'ve go...'},
 {'text': 'My text: Foil plaid lycra and spandex shortall with metallic slinky insets. Attached metall...'}]

批次處理 (Batch processing)

IterableDataset.map() 也支援處理批次範例。透過設定 batched=True 來對批次進行操作。預設批次大小為 1000，但您可以使用 batch_size 引數進行調整。這為許多有趣的應用開啟了大門，例如分詞、將長句分割成較短的區塊以及資料增強。

分詞

>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> dataset = load_dataset("allenai/c4", "en", streaming=True, split="train")
>>> tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased')
>>> def encode(examples):
...     return tokenizer(examples['text'], truncation=True, padding='max_length')
>>> dataset = dataset.map(encode, batched=True, remove_columns=["text", "timestamp", "url"])
>>> next(iter(dataset))
{'input_ids': [101, 4088, 16912, 22861, 4160, 2465, 2635, 2173, 1999, 3335, ..., 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ..., 0, 0]}

請參閱 批次映射處理 文件中批次處理的其他範例。它們對可疊代資料集的作用相同。

篩選

您可以使用 Dataset.filter() 根據判斷式函數篩選資料集中的列。它會返回符合指定條件的列

>>> from datasets import load_dataset
>>> dataset = load_dataset('HuggingFaceFW/fineweb', streaming=True, split='train')
>>> start_with_ar = dataset.filter(lambda example: example['text'].startswith('San Francisco'))
>>> next(iter(start_with_ar))
{'text': 'San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the sea...}

如果設定 with_indices=True，Dataset.filter() 也可以按索引進行篩選

>>> even_dataset = dataset.filter(lambda example, idx: idx % 2 == 0, with_indices=True)
>>> list(even_dataset.take(3))
[{'text': 'How AP reported in all formats from tornado-stricken regionsMarch 8, 2012 Whe...},
 {'text': 'Car Wash For Clara! Now is your chance to help! 2 year old Clara Woodward has...},
 {'text': 'Log In Please enter your ECode to log in. Forgotten your eCode? If you create...}]

批次

batch 方法將您的 IterableDataset 轉換為批次的可疊代物件。這在您想在訓練迴圈中使用批次，或使用需要批次輸入的框架時特別有用。

當使用 map 函數將函數應用於資料批次時，也有一個「批次處理」選項，這在上面的映射部分中有所討論。這裡描述的 batch 方法有所不同，它提供了一種從資料集建立批次的更直接方式。

您可以像這樣使用 batch 方法

from datasets import load_dataset

# Load a dataset in streaming mode
dataset = load_dataset("some_dataset", split="train", streaming=True)

# Create batches of 32 samples
batched_dataset = dataset.batch(batch_size=32)

# Iterate over the batched dataset
for batch in batched_dataset:
    print(batch)
    break

在此範例中，batched_dataset 仍然是一個 IterableDataset，但每個產生的項目現在是一個包含 32 個樣本的批次，而不是單個樣本。這種批次處理是在您疊代資料集時即時完成的，保留了 IterableDataset 記憶體效率高的特性。

batch 方法還提供了 drop_last_batch 參數。當設定為 True 時，如果最後一個批次小於指定的 batch_size，它將丟棄該批次。這在您的下游處理需要所有批次都具有相同大小的情況下可能很有用

batched_dataset = dataset.batch(batch_size=32, drop_last_batch=True)

在訓練迴圈中串流

IterableDataset 可以整合到訓練迴圈中。首先，隨機重排資料集

Pytorch
隱藏 Pytorch 內容
>>> seed, buffer_size = 42, 10_000
>>> dataset = dataset.shuffle(seed, buffer_size=buffer_size)

最後，建立一個簡單的訓練迴圈並開始訓練

>>> import torch
>>> from torch.utils.data import DataLoader
>>> from transformers import AutoModelForMaskedLM, DataCollatorForLanguageModeling
>>> from tqdm import tqdm
>>> dataset = dataset.with_format("torch")
>>> dataloader = DataLoader(dataset, collate_fn=DataCollatorForLanguageModeling(tokenizer))
>>> device = 'cuda' if torch.cuda.is_available() else 'cpu' 
>>> model = AutoModelForMaskedLM.from_pretrained("distilbert-base-uncased")
>>> model.train().to(device)
>>> optimizer = torch.optim.AdamW(params=model.parameters(), lr=1e-5)
>>> for epoch in range(3):
...     dataset.set_epoch(epoch)
...     for i, batch in enumerate(tqdm(dataloader, total=5)):
...         if i == 5:
...             break
...         batch = {k: v.to(device) for k, v in batch.items()}
...         outputs = model(**batch)
...         loss = outputs[0]
...         loss.backward()
...         optimizer.step()
...         optimizer.zero_grad()
...         if i % 10 == 0:
...             print(f"loss: {loss}")

儲存資料集檢查點並恢復疊代

如果您的訓練迴圈停止，您可能希望從停止的地方重新啟動訓練。為此，您可以儲存模型和優化器的檢查點，以及您的資料載入器。

可疊代資料集不提供對特定範例索引的隨機存取以從中恢復，但您可以使用 IterableDataset.state_dict() 和 IterableDataset.load_state_dict() 來從檢查點恢復，類似於您對模型和優化器所做的那樣

>>> iterable_dataset = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3)
>>> for idx, example in enumerate(iterable_dataset):
...     print(example)
...     if idx == 2:
...         state_dict = iterable_dataset.state_dict()
...         print("checkpoint")
...         break
>>> iterable_dataset.load_state_dict(state_dict)
>>> print(f"restart from checkpoint")
>>> for example in iterable_dataset:
...     print(example)

返回

{'a': 0}
{'a': 1}
{'a': 2}
checkpoint
restart from checkpoint
{'a': 3}
{'a': 4}
{'a': 5}

在底層，可疊代資料集會追蹤正在讀取的目前分片以及目前分片中的範例索引，並將此資訊儲存在 state_dict 中。

要從檢查點恢復，資料集會跳過所有先前讀取的分片，從目前分片重新開始。然後它會讀取該分片並跳過範例，直到達到檢查點中的確切範例。

因此，重新啟動資料集相當快速，因為它不會重新讀取已疊代過的分片。儘管如此，恢復資料集通常不是即時的，因為它必須從目前分片的開頭重新開始讀取並跳過範例，直到達到檢查點位置。

這可以與 torchdata 中的 StatefulDataLoader 一起使用

>>> from torchdata.stateful_dataloader import StatefulDataLoader
>>> iterable_dataset = load_dataset("deepmind/code_contests", streaming=True, split="train")
>>> dataloader = StatefulDataLoader(iterable_dataset, batch_size=32, num_workers=4)
>>> # checkpoint
>>> state_dict = dataloader.state_dict()  # uses iterable_dataset.state_dict() under the hood
>>> # resume from checkpoint
>>> dataloader.load_state_dict(state_dict)  # uses iterable_dataset.load_state_dict() under the hood

恢復時會精確返回檢查點儲存的位置，除非使用了 .shuffle()：隨機重排緩衝區中的範例會在恢復時丟失，緩衝區會重新填入新資料。

儲存

一旦您的可疊代資料集準備就緒，您可以將其儲存為 Parquet 格式的 Hugging Face 資料集，然後稍後使用 load_dataset() 重新使用。

透過提供您希望儲存到 Hugging Face 資料集儲存庫的名稱給 push_to_hub() 來儲存您的資料集。這會疊代資料集並逐步將資料上傳到 Hugging Face

dataset.push_to_hub("username/my_dataset")

如果資料集包含多個分片 (dataset.num_shards > 1)，您可以使用多個處理程序平行上傳它。如果您應用了 map() 或 filter() 步驟，這會特別有用，因為它們將平行執行得更快。

dataset.push_to_hub("username/my_dataset", num_proc=8)

使用 load_dataset() 函數重新載入資料集

from datasets import load_dataset
reloaded_dataset = load_dataset("username/my_dataset")

匯出 (Export)

🤗 Datasets 也支援匯出，因此您可以在其他應用程式中使用您的資料集。下表顯示了目前支援的檔案格式，您可以匯出為

檔案類型 匯出方法
CSV IterableDataset.to_csv()
JSON IterableDataset.to_json()
Parquet IterableDataset.to_parquet()
SQL IterableDataset.to_sql()
記憶體內 Python 物件 IterableDataset.to_pandas()、IterableDataset.to_polars() 或 IterableDataset.to_dict()

例如，像這樣將您的資料集匯出為 CSV 檔案

>>> dataset.to_csv("path/of/my/dataset.csv")

如果您有大型資料集，您可以為每個分片儲存一個檔案，例如

>>> 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")
在 GitHub 上更新

←處理 搭配 PyTorch 使用→
© . This site is unofficial and not affiliated with Hugging Face, Inc.