|
|
--- |
|
|
configs: |
|
|
- config_name: default |
|
|
data_files: |
|
|
- split: train |
|
|
path: "*.parquet" |
|
|
license: odc-by |
|
|
--- |
|
|
Gemstones Training Dataset - Sequential 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: sequential |
|
|
|
|
|
This version of the dataset approximates the order of the dataset _as if_ a model was being trained |
|
|
on a single gpu without data parallelism. In reality, specific subsets of the data were loaded by the distributed |
|
|
workers (GPUs) passed through a 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 linearized recreation assumes a single worker is reading every row of the dataset and so at a microbatch size of 8 over packed sequences of 2048 tokens, 21247488 steps worth of "training" is required to reach ~350B tokens. |
|
|
|
|
|
In this setup, a single worker received the total dataset represented by 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 the single 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. |
|
|
|
|
|
**Note**: the fact that a single worker receives all files in this version means that the sets of 4 files loaded at |
|
|
a time whose contents (blocks of tokens) are read in a shuffled order, does not exactly match any one of the |
|
|
Gemstones model sets. However, the key is that the synchronization argument above still holds and so analyses at a coarser granularity than ~8.6B tokens should be sound. |
|
|
|
|
|
The `train_mock_data_order_file.py` performs these operations and writes the resulting data order out to files. |
|
|
Each shard named like |
|
|
`ordered_dataset_shard_{shard}-of-{total_shards}.parquet` where the total number of shards is arbitrary, but chosen to be 256 for |
|
|
portability, represents a contiguous subset of the approximated total ordering of the rows int the training dataset. |
|
|
|
