configs:
- config_name: default
data_files:
- split: train
path: '*.parquet'
license: odc-by
Gemstones Training Dataset - Parallel workers sharded version
This data is a reprocessed version of the first 1B rows of the Dolma v1.7 dataset (https://huggingface.co/datasets/allenai/dolma).
The data is encoded using the Pythia tokenizer: https://huggingface.co/EleutherAI/pythia-160m
Disclaimer: this is an approximation of the dataset used to train the Gemstones model suite. Due to the randomized and sharded nature of the distributed training code, the only way to perfectly reproduce the training batches across the gpus is to run the training code. This repo is the result of an attempt to simulate the way in which the training code loaded the data and stream it out to a portable file format for use in downstream analyses of the model suite.
Loading
This data should be loadable using load_dataset in the standard manner to auto-download the data.
Alternately, the dataset can be cloned using git to materialize the files locally, and then loaded
using the default parquet builder as described here: https://huggingface.co/docs/datasets/en/loading#parquet
Sharding format: worker parallel
This version of the dataset approximates the specific subsets of the data that each of the distributed workers (GPUs) would have individually loaded and passed through the local copy of the model during dataparallel training. Since the Gemstones suite of models was trained on a variety of topologies (the 50M models were trained on 8 nodes while the 2B models used 64 nodes) the distributed reading format was chosen such that different topologies would read the data in similar orders.
Specifically, a round-robin reading order ensured that while an 8 node set of workers would each be responsible for more
data than individual workers in a larger 64 node configuration, the first files read by the smaller
configuration would be the same as the first files read by the workers in the larger configuration.
Eg. if workers 1 and 2 in a 2 worker job got files [A,B] and [C,D], then workers 1, 2, 3, and 4 in a larger 4 worker job would receive files [A], [B], [C], [D] respectively. This way, periodically, all models would be guaranteed to
have seen all of the same rows of the dataset during training. The sync granularity is determined by the largest configuration, so 64 nodes = 512 gpus, loading 4 raw files at a time each containing 2048 x 2049 = ~4M tokens, means synchronization every 512 x 4 x 2048 x 2049 = ~8.6B tokens.
This recreation assumes the ~1B Gemstones model sizes which were trained on 32 nodes * 8 gpus per node = 256 worker shards at a microbatch size of 8 over packed sequences of 2048 tokens. They were trained for 82998 steps at a batch size of ~4M tokens to reach ~350B tokens.
The 256 workers each received a slice of the total dataset represented by a subset of
the thousands of raw training format files (for reference, this format is defined by the packed_cycle_dataset.py file in this repo).
The raw files were first shuffled globally, and then each worker's slice was defined by this round-robin
strided indexing of the shuffled filelist: filenames[shard_id:max_num_files:num_shards]. Then, each worker
loaded 4 files at a time, and shuffled the "blocks" of 2048 tokens each in a temporary buffer so
that the contents of the 4 packed files were not read in the exact order in which the tokens appeared in them.
The train_mock_data_order_file.py uses a pool of cpu workers
to mimic a distributed set of gpus, and passes their process ids into the dataset implementation
so that each worker in the pool receives its subset of the data and loads it as it would have during training.
Then, the subsets of data are wrapped in dataloaders and read in microbatches before being written out
to the parquet file format.
Each shard named like worker_{worker_rank}-of-{total_num_workers}_ordered_dataset.parquet represents the ordered microbatches that one of the 256 gpus would
have drawn and passed through its copy of the model during training.