| from __future__ import annotations |
|
|
| import math |
| import glob |
| from bisect import bisect_right |
| from collections.abc import Sequence |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
|
|
| class PackedTokenDataset: |
| """Read fixed-length Hugging Face causal-LM samples from uint16 streams. |
| |
| Labels intentionally mirror ``input_ids`` because causal language-model |
| heads such as ``LlamaForCausalLM`` perform the one-token label shift inside |
| their loss function. |
| """ |
|
|
| def __init__( |
| self, |
| path: str | Path | Sequence[str | Path], |
| sequence_length: int, |
| ) -> None: |
| if sequence_length <= 0: |
| raise ValueError("sequence_length must be positive") |
| raw_paths = [path] if isinstance(path, (str, Path)) else list(path) |
| resolved: set[Path] = set() |
| for raw_path in raw_paths: |
| value = str(raw_path) |
| matches = [Path(item) for item in glob.glob(value)] |
| if matches: |
| resolved.update(item.resolve() for item in matches if item.is_file()) |
| else: |
| candidate = Path(raw_path) |
| if candidate.is_file(): |
| resolved.add(candidate.resolve()) |
| self.paths = sorted(resolved) |
| if not self.paths: |
| raise FileNotFoundError(f"No token binaries found for: {raw_paths}") |
| self.path = self.paths[0] |
| self.sequence_length = sequence_length |
| self.token_streams = [ |
| np.memmap(item, mode="r", dtype=np.uint16) for item in self.paths |
| ] |
| sequence_counts = [ |
| max(0, (len(tokens) - 1) // self.sequence_length) |
| for tokens in self.token_streams |
| ] |
| self.sequence_offsets: list[int] = [] |
| running_total = 0 |
| for count in sequence_counts: |
| running_total += count |
| self.sequence_offsets.append(running_total) |
| self.num_sequences = running_total |
| if self.num_sequences == 0: |
| raise ValueError( |
| f"{self.paths} need at least {self.sequence_length + 1} tokens" |
| ) |
| self._affine_cache: dict[int, tuple[int, int]] = {} |
|
|
| def __len__(self) -> int: |
| return self.num_sequences |
|
|
| def sequence(self, index: int) -> np.ndarray: |
| if not 0 <= index < self.num_sequences: |
| raise IndexError(index) |
| stream_index = bisect_right(self.sequence_offsets, index) |
| previous_offset = ( |
| self.sequence_offsets[stream_index - 1] if stream_index > 0 else 0 |
| ) |
| local_index = index - previous_offset |
| start = local_index * self.sequence_length |
| return np.asarray( |
| self.token_streams[stream_index][ |
| start : start + self.sequence_length + 1 |
| ], |
| dtype=np.int64, |
| ) |
|
|
| def _affine_parameters(self, epoch: int, seed: int) -> tuple[int, int]: |
| cache_key = (seed << 32) ^ epoch |
| if cache_key in self._affine_cache: |
| return self._affine_cache[cache_key] |
| rng = np.random.default_rng(seed + epoch * 1_000_003) |
| multiplier = int(rng.integers(1, max(self.num_sequences, 2))) |
| while math.gcd(multiplier, self.num_sequences) != 1: |
| multiplier += 1 |
| if multiplier >= self.num_sequences: |
| multiplier = 1 |
| offset = int(rng.integers(0, self.num_sequences)) |
| self._affine_cache[cache_key] = (multiplier, offset) |
| return multiplier, offset |
|
|
| def training_batch( |
| self, |
| *, |
| micro_step: int, |
| batch_size: int, |
| rank: int, |
| world_size: int, |
| seed: int, |
| sample_offset: int = 0, |
| device: torch.device, |
| ) -> tuple[torch.Tensor, torch.Tensor]: |
| if sample_offset < 0: |
| raise ValueError("sample_offset must be non-negative") |
| global_batch_size = batch_size * world_size |
| first_ordinal = ( |
| sample_offset |
| + micro_step * global_batch_size |
| + rank * batch_size |
| ) |
| rows: list[np.ndarray] = [] |
| for local_index in range(batch_size): |
| ordinal = first_ordinal + local_index |
| epoch, position = divmod(ordinal, self.num_sequences) |
| multiplier, offset = self._affine_parameters(epoch, seed) |
| sequence_index = (multiplier * position + offset) % self.num_sequences |
| rows.append(self.sequence(sequence_index)) |
| return self._to_tensors(rows, device) |
|
|
| def evaluation_batch( |
| self, |
| *, |
| batch_index: int, |
| batch_size: int, |
| rank: int, |
| world_size: int, |
| device: torch.device, |
| ) -> tuple[torch.Tensor, torch.Tensor]: |
| first = (batch_index * world_size + rank) * batch_size |
| rows = [ |
| self.sequence((first + offset) % self.num_sequences) |
| for offset in range(batch_size) |
| ] |
| return self._to_tensors(rows, device) |
|
|
| @staticmethod |
| def _to_tensors( |
| rows: list[np.ndarray], device: torch.device |
| ) -> tuple[torch.Tensor, torch.Tensor]: |
| batch = torch.from_numpy(np.stack(rows, axis=0)) |
| inputs = batch[:, :-1].to(device=device, dtype=torch.long, non_blocking=True) |
| labels = inputs.clone() |
| return inputs, labels |
|
|
