File size: 5,317 Bytes
91ac3cc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | 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
|