|
|
--- |
|
|
task_categories: |
|
|
- text-generation |
|
|
--- |
|
|
|
|
|
# Comma v0.1 Training Dataset (1 Billion Token Sample) |
|
|
|
|
|
This is a 1 billion token subset of the [Comma v0.1 Training Set](https://huggingface.co/datasets/common-pile/comma_v0.1_training_dataset) intended |
|
|
as a convenience for small deep learning experiments. It is similar in spirit to the [1 billion token RedPajama sample](https://huggingface.co/datasets/togethercomputer/RedPajama-Data-1T-Sample) |
|
|
which is no longer functioning with HuggingFace transformers due to involving the execution of arbitrary code at load time. |
|
|
|
|
|
## Method |
|
|
|
|
|
The subset was created using a single item batch version of the following script which I no longer have: |
|
|
|
|
|
```python |
|
|
import os |
|
|
import json |
|
|
import random |
|
|
import requests |
|
|
from datasets import load_dataset |
|
|
from transformers import AutoTokenizer |
|
|
from argparse import ArgumentParser |
|
|
|
|
|
parser = ArgumentParser() |
|
|
parser.add_argument("--tokens", default=10**9, type=int, |
|
|
help="The number of tokens to subset.") |
|
|
args = parser.parse_args() |
|
|
|
|
|
tokenizer = AutoTokenizer.from_pretrained("common-pile/comma-v0.1-1t") |
|
|
dataset = load_dataset("common-pile/comma_v0.1_training_dataset") |
|
|
|
|
|
used = set() |
|
|
token_count = 0 |
|
|
split = {"train":[]} |
|
|
if os.path.exists("subset_resume.json"): |
|
|
with open("subset_resume.json") as infile: |
|
|
data = json.load(infile) |
|
|
spans = set(data["used"]) |
|
|
token_count = data["token_count"] |
|
|
split = data["split"] |
|
|
|
|
|
milestone = 10 ** 6 |
|
|
while token_count < args.tokens: |
|
|
choices = set() |
|
|
for i in range(64): |
|
|
choice = random.randrange(dataset["train"].num_rows) |
|
|
while choice in used: |
|
|
choice = random.randrange(dataset["train"].num_rows) |
|
|
used.add(choice) |
|
|
choices.add(choice) |
|
|
assert len(choices) == 64 |
|
|
items = [] |
|
|
for choice in choices: |
|
|
items.append(dataset["train"][choice]) |
|
|
texts = [item["text"] for item in items] |
|
|
token_count += sum([len(i) for i in tokenizer(texts)["input_ids"]]) |
|
|
split["train"].extend(items) |
|
|
if token_count > milestone: |
|
|
with open("subset_resume.json", "w") as outfile: |
|
|
serial_used = list(used) |
|
|
json.dump({"used":serial_used, "token_count":token_count, "split":split}, outfile) |
|
|
milestone += 10 ** 6 |
|
|
print(token_count, f"{(token_count / args.tokens) * 100}%") |
|
|
|
|
|
with open(f"subset_{args.tokens}.json", "w") as outfile: |
|
|
json.dump(split, outfile) |
|
|
``` |
|
|
|
|
|
Feel free to modify and use this script to create subsets of other datasets. |
|
|
|
|
|
The dataset was sharded using the following script: |
|
|
|
|
|
```python |
|
|
import json |
|
|
import gzip |
|
|
import math |
|
|
from pathlib import Path |
|
|
|
|
|
def shard_dataset(input_file, output_dir, num_shards=4): |
|
|
""" |
|
|
Shard a JSON dataset into multiple gzipped JSON lines files. |
|
|
|
|
|
Args: |
|
|
input_file (str): Path to the input JSON file |
|
|
output_dir (str): Directory where shards will be saved |
|
|
num_shards (int): Number of shards to create |
|
|
""" |
|
|
# Create output directory if it doesn't exist |
|
|
Path(output_dir).mkdir(parents=True, exist_ok=True) |
|
|
|
|
|
# Load the dataset |
|
|
print(f"Loading dataset from {input_file}...") |
|
|
with open(input_file, 'r') as f: |
|
|
data = json.load(f) |
|
|
|
|
|
# Extract the training examples |
|
|
train_examples = data["train"] |
|
|
total_examples = len(train_examples) |
|
|
examples_per_shard = math.ceil(total_examples / num_shards) |
|
|
|
|
|
print(f"Found {total_examples} examples, splitting into {num_shards} shards") |
|
|
|
|
|
# Create each shard |
|
|
for shard_idx in range(num_shards): |
|
|
# Calculate start and end indices for this shard |
|
|
start_idx = shard_idx * examples_per_shard |
|
|
end_idx = min((shard_idx + 1) * examples_per_shard, total_examples) |
|
|
|
|
|
# Format the filename with zero-padding |
|
|
filename = f"train-{shard_idx:05d}-of-{num_shards:05d}.jsonl.gz" |
|
|
filepath = Path(output_dir) / filename |
|
|
|
|
|
print(f"Creating shard {shard_idx+1}/{num_shards}: {filename}") |
|
|
|
|
|
# Write the shard as gzipped JSON lines |
|
|
with gzip.open(filepath, 'wt', encoding='utf-8') as f: |
|
|
for i in range(start_idx, end_idx): |
|
|
# Write each example as a JSON line |
|
|
json_line = json.dumps(train_examples[i]) |
|
|
f.write(json_line + '\n') |
|
|
|
|
|
print(f"Finished creating {num_shards} shards in {output_dir}") |
|
|
|
|
|
if __name__ == "__main__": |
|
|
# Configuration - update these paths as needed |
|
|
input_json_file = "1B_sample/train.json" # Update this path |
|
|
output_directory = "1B_sample/sharded_dataset" # Update this if needed |
|
|
|
|
|
# Shard the dataset into 4 parts |
|
|
shard_dataset(input_json_file, output_directory, num_shards=4) |
|
|
``` |
