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