Upload aux_files/packed_cycle_dataset.py with huggingface_hub

aux_files/packed_cycle_dataset.py

@@ -1 +1,380 @@
-Gemstones Training Dataset - Worker sharded version
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+# Very loosely inspired by indexed_dataset in Fairseq, Megatron
+# https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/data/indexed_dataset.py
+
+
+import os
+import random
+import struct
+import hashlib
+
+import numpy as np
+import torch
+from torch.utils.data import IterableDataset, get_worker_info
+from litgpt.data_scheduler_utils import DataSchedulerTracker
+from typing import Optional, Sequence, Any
+
+dtypes = {
+    1: np.uint8,
+    2: np.int8,
+    3: np.int16,
+    4: np.int32,
+    5: np.int64,
+    6: np.float32,
+    7: np.float64,
+    8: np.uint16,
+}
+
+
+def code(dtype):
+    for k in dtypes:
+        if dtypes[k] == dtype:
+            return k
+    raise ValueError(dtype)
+
+
+HDR_MAGIC = b"LITPKDS"
+HDR_SIZE = 24  # bytes
+
+
+class PackedDataset(IterableDataset):
+    def __init__(
+        self,
+        filenames,
+        n_chunks,
+        block_size,
+        seed=12345,
+        shuffle=True,
+        wrap=False,
+        num_processes=1,
+        process_rank=0,
+        data_id=None,
+        return_data_id=False,
+    ):
+        self._filenames = filenames
+        self._n_chunks = n_chunks
+        self._block_size = block_size
+        self._seed = seed
+        self._shuffle = shuffle
+        self._wrap = wrap
+        self._num_processes = num_processes
+        self._process_rank = process_rank
+        self._ds_fingerprint = None
+        self._data_id = data_id  # This is human readble, correps to the full file list.
+        if return_data_id:
+            raise NotImplementedError("return_data_id is not implemented for PackedDataset")
+
+    def __iter__(self):
+        worker_info = get_worker_info()
+        num_workers = worker_info.num_workers if worker_info is not None else 1
+        worker_id = worker_info.id if worker_info is not None else 0
+        num_shards = num_workers * self._num_processes
+        shard_id = self._process_rank * num_workers + worker_id
+
+        total_num_files = len(self._filenames)
+        max_num_files = total_num_files // num_shards * num_shards
+        filenames = self._filenames[shard_id:max_num_files:num_shards]
+
+        self._ds_fingerprint = hashlib.shake_128(str(filenames).encode()).hexdigest(
+            4
+        )  # This is not human readable, corresp to the file list _this_ process is using.
+
+        print(
+            f"Rank {self._process_rank}/{self._num_processes}, worker {worker_id} has {len(filenames)}/{total_num_files} files | "
+            f"identifier={self._data_id}:{self._ds_fingerprint}"
+        )
+
+        return PackedDatasetIterator(
+            filenames=filenames,
+            n_chunks=self._n_chunks,
+            block_size=self._block_size,
+            seed=self._seed,
+            shuffle=self._shuffle,
+            wrap=self._wrap,
+            data_id=self._data_id,
+            fingerprint=self._ds_fingerprint,
+            worker_id=worker_id,
+            process_rank=self._process_rank,
+            num_processes=self._num_processes,
+        )
+
+
+class PackedDatasetBuilder(object):
+    def __init__(self, outdir, prefix, chunk_size, sep_token, dtype="auto", vocab_size=None):
+        if dtype == "auto":
+            if vocab_size is None:
+                raise ValueError("vocab_size cannot be None when dtype='auto'")
+            if vocab_size is not None and vocab_size < 65500:
+                self._dtype = np.uint16
+            else:
+                self._dtype = np.int32
+        else:
+            self._dtype = dtype
+        self._counter = 0
+        self._chunk_size = chunk_size
+        self._outdir = outdir
+        self._prefix = prefix
+        self._sep_token = sep_token
+        self._arr = np.zeros(self._chunk_size, dtype=self._dtype)
+        self._arr.fill(self._sep_token)
+        self._idx = 0
+        self._version = 1
+        self._filenames = []
+        self._total_tokens_exact = 0
+        self._filler_sep_tokens = 0
+
+    def _write_chunk(self, skip_write=False):
+        filename = f"{self._prefix}_{self._counter:010d}.bin"
+        filename = os.path.join(self._outdir, filename)
+
+        # right before we write, we can compute the number of tokens being written
+        # and update the total number of tokens
+        last_non_sep_idx = np.argwhere((self._arr != self._sep_token)).squeeze()[-1]
+        tokens_in_chunk = last_non_sep_idx + 1  # +1 for zero-indexing
+
+        if skip_write:
+            self._arr.fill(self._sep_token)
+            self._idx = 0
+            return tokens_in_chunk  # amount we are skipping
+
+        self._filler_sep_tokens += self._chunk_size - tokens_in_chunk
+        self._total_tokens_exact += tokens_in_chunk
+        # print(
+        #     f"Chunk written with {tokens_in_chunk} tokens and {self._filler_sep_tokens} filler sep tokens"
+        # )
+
+        with open(filename, "wb") as f:
+            f.write(HDR_MAGIC)
+            f.write(struct.pack("<Q", self._version))
+            f.write(struct.pack("<B", code(self._dtype)))
+            f.write(struct.pack("<Q", self._chunk_size))
+            f.write(self._arr.tobytes(order="C"))
+
+        self._filenames.append(filename)
+        self._counter += 1
+        self._arr.fill(self._sep_token)
+        self._idx = 0
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @property
+    def filenames(self):
+        return self._filenames.copy()
+
+    def add_array(self, arr):
+        while self._idx + arr.shape[0] > self._chunk_size:
+            part_len = self._chunk_size - self._idx
+            self._arr[self._idx : self._idx + part_len] = arr[:part_len]
+            self._write_chunk()
+            arr = arr[part_len:]
+
+        arr_len = arr.shape[0]
+        self._arr[self._idx : self._idx + arr_len] = arr
+        self._idx += arr_len
+
+    def write_remainder(self):
+        self._write_chunk()
+
+    def skip_write_remainder(self):
+        return self._write_chunk(skip_write=True)
+
+
+BlockIdxType = Sequence[int] | np.ndarray[Any, np.dtype[np.int64]]
+
+
+class PackedDatasetIterator:
+    def __init__(
+        self,
+        filenames,
+        n_chunks,
+        block_size,
+        seed,
+        shuffle,
+        wrap,
+        data_id=None,
+        fingerprint=None,
+        worker_id=None,
+        process_rank=None,
+        num_processes=None,
+    ):
+        self._data_id = data_id
+        self._ds_fingerprint = fingerprint
+        self._worker_id = worker_id
+        self._process_rank = process_rank
+        self._num_processes = num_processes
+
+        self._seed = seed
+        self._shuffle = shuffle
+        self._rng = np.random.default_rng(seed)  # if shuffle else None
+
+        self._wrap = wrap
+
+        # TODO: instead of filenames, we could have a single text stream
+        #       (or text file) with the sequence of all files to be
+        #       fetched/loaded.
+        self._filenames = filenames
+        self._file_idx = 0
+
+        self._n_chunks = n_chunks
+
+        self._dtype: Optional[np.dtype] = None
+        self._block_size = block_size
+        # self._n_blocks: Optional[int] = None
+
+        self._mmaps = []
+        self._buffers = []
+        self._curr_idx = 0
+
+        self._load_n_chunks()
+
+    def _read_header(self, path):
+        with open(path, "rb") as f:
+            magic = f.read(len(HDR_MAGIC))
+            assert magic == HDR_MAGIC, "File doesn't match expected format."
+            version = struct.unpack("<Q", f.read(8))
+            assert version == (1,)
+            (dtype_code,) = struct.unpack("<B", f.read(1))
+            dtype = dtypes[dtype_code]
+            (chunk_size,) = struct.unpack("<Q", f.read(8))
+        return dtype, chunk_size
+
+    def _close_mmaps(self):
+        for mmap in self._mmaps:
+            mmap._mmap.close()
+
+    def fast_forward(self, block_idx):
+        """Stub for eventual fast-forward"""
+        pass
+
+    def _load_n_chunks(self):
+        self._close_mmaps()
+        self._mmaps = []
+        self._buffers = []
+
+        if self._n_chunks > len(self._filenames[self._file_idx :]):
+            if not self._wrap:
+                raise StopIteration
+            self._file_idx = 0
+
+        # only print on the first 3 times we load chunks
+        if (self._file_idx * self._n_chunks) < (3 * self._n_chunks):
+            print(
+                f"({self._process_rank}/{self._num_processes}) will load {self._n_chunks} chunks: {self._filenames[self._file_idx:self._file_idx+self._n_chunks]}"
+            )
+
+        for i in range(self._n_chunks):
+            filename = self._filenames[self._file_idx + i]
+            if self._dtype is None:
+                self._dtype, self._chunk_size = self._read_header(filename)
+                self._n_blocks = self._chunk_size // self._block_size
+            # TODO: check header matches with previous files
+            mmap = np.memmap(filename, mode="r", order="C", offset=HDR_SIZE)
+            self._mmaps.append(mmap)
+            self._buffers.append(memoryview(mmap))  # type: ignore
+
+        self._file_idx += self._n_chunks
+        n_all_blocks = self._n_chunks * self._n_blocks
+
+        self._block_idxs: BlockIdxType = self._rng.permutation(n_all_blocks) if self._shuffle else range(n_all_blocks)
+
+        # only print on the first 3 times we load chunks
+        if (self._file_idx * self._n_chunks) < (3 * self._n_chunks):
+            print(f"({self._process_rank}/{self._num_processes}) block read order: {self._block_idxs}")
+
+        self._curr_idx = 0
+
+    def __del__(self):
+        self._close_mmaps()
+        del self._mmaps
+        del self._buffers
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._curr_idx >= len(self._block_idxs):
+            self._load_n_chunks()
+            # TODO: trigger fetching next next n_chunks if remote
+        block_idx = self._block_idxs[self._curr_idx]
+        chunk_id = block_idx // self._n_blocks
+        buffer = self._buffers[chunk_id]
+        elem_id = (block_idx % self._n_blocks) * self._block_size
+        offset = np.dtype(self._dtype).itemsize * elem_id
+        arr = np.frombuffer(buffer, dtype=self._dtype, count=self._block_size, offset=offset)
+        self._curr_idx += 1
+        return torch.from_numpy(arr.astype(np.int64))
+
+
+class CombinedDataset(IterableDataset):
+    def __init__(self, datasets, seed, data_scheduler_tracker=None, data_telemetry=False):
+        self._seed = seed
+        self._datasets = datasets
+        self._data_scheduler_tracker = data_scheduler_tracker
+        self._data_telemetry = data_telemetry
+        n_datasets = len(datasets)
+        if data_scheduler_tracker is None:
+            self._data_scheduler_tracker = DataSchedulerTracker([1 / n_datasets] * n_datasets)
+
+    def __iter__(self):
+        return CombinedDatasetIterator(self._datasets, self._seed, self._data_scheduler_tracker, self._data_telemetry)
+
+
+class CombinedDatasetIterator:
+    def __init__(self, datasets, seed, data_scheduler_tracker, data_telemetry=False):
+        self._datasets = datasets
+        self._datasets_iterators = [iter(el) for el in datasets]
+        self._num_datasets = len(datasets)
+        self._data_scheduler_tracker = data_scheduler_tracker
+        self._rng = random.Random(seed)
+        self._iter_ct = 0
+        self._data_telemetry = data_telemetry
+
+    def __next__(self):
+        if sum(self._data_scheduler_tracker.weights) == 0:
+            if self._data_scheduler_tracker.base_id is not None:
+                # if all buckets have 0 weight, return the base dataset
+                self._data_scheduler_tracker.weights[self._data_scheduler_tracker.base_id] = 100
+                return self.__next__()
+            else:
+                # if all buckets have 0 weight and no base dataset, return empty
+                return torch.tensor([])
+
+        (dataset_idx,) = self._rng.choices(range(self._num_datasets), weights=self._data_scheduler_tracker.weights, k=1)
+        dataset = self._datasets_iterators[dataset_idx]
+
+        try:
+            curr_data = next(dataset)
+            self._data_scheduler_tracker.sample_count[dataset_idx] += 1
+
+            self._iter_ct += 1
+
+            # this is the very beginning of data telemetry
+            if self._data_telemetry and self._iter_ct < 5:
+                print(
+                    f"Draw result i={self._iter_ct} for rank={dataset._process_rank}/{dataset._num_processes}, "
+                    f"worker={dataset._worker_id} | {dataset._data_id}:{dataset._ds_fingerprint}"
+                )
+            elif self._data_telemetry and self._iter_ct == 5:
+                print("Data telemetry off ...")
+
+            return curr_data
+        except Exception as e:  # which one? yea this is a problem.
+            self._data_scheduler_tracker.epoch_count[dataset_idx] += 1
+            self._datasets_iterators[dataset_idx] = iter(self._datasets[dataset_idx])
+
+            if (self._data_scheduler_tracker.max_epochs is not None) and (
+                self._data_scheduler_tracker.max_epochs[dataset_idx]
+                <= self._data_scheduler_tracker.epoch_count[dataset_idx]
+            ):
+                # if exceeds max epoch
+                self._data_scheduler_tracker.weights[dataset_idx] = 0
+                return self.__next__()
+            else:
+                dataset = self._datasets_iterators[dataset_idx]
+                curr_data = next(dataset)
+                self._data_scheduler_tracker.sample_count[dataset_idx] += 1
+
+                return curr_data