| """Tokenize -> concatenate -> fixed-length pack -> binary shard, the |
| standard "packed sequences" strategy for LM pretraining (used by |
| nanoGPT/GPT-NeoX-style data prep): every document's tokens are |
| concatenated into one long stream (documents separated by EOS, not |
| padding), then sliced into fixed-length blocks. This means every training |
| example is fully utilized -- no padding waste the way per-document |
| batching with CausalCollator would have for variable-length documents. |
| |
| Output format: raw token-id shards written as flat binary files (uint16 |
| if vocab fits, else uint32), one small JSON sidecar per shard describing |
| how to interpret the bytes. This is intentionally NOT a database or a |
| fancy container format -- for pretraining-scale corpora, sequential |
| memory-mapped reads of flat arrays is the fastest and simplest thing that |
| works, and is what real large-scale pretraining pipelines actually do. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| from collections.abc import Iterable, Iterator |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
|
|
| def pack_token_stream( |
| documents: Iterable[list[int]], |
| seq_len: int, |
| eos_id: int, |
| drop_last_partial: bool = True, |
| ) -> Iterator[list[int]]: |
| """Concatenate tokenized documents (inserting eos_id between them) and |
| yield fixed-length seq_len chunks as they become available -- streaming, |
| so the full corpus is never held in memory at once. |
| |
| drop_last_partial=True (default): the final <seq_len leftover tokens at |
| the very end of the whole stream are discarded rather than padded -- |
| standard practice (e.g. nanoGPT's data prep) since the loss from |
| dropping a partial remainder is negligible at real corpus scale, and it |
| keeps every yielded sequence a uniform, pad-free length. |
| """ |
| if seq_len <= 0: |
| raise ValueError(f"seq_len ({seq_len}) must be positive") |
| buffer: list[int] = [] |
| for doc_ids in documents: |
| buffer.extend(doc_ids) |
| buffer.append(eos_id) |
| while len(buffer) >= seq_len: |
| yield buffer[:seq_len] |
| buffer = buffer[seq_len:] |
| if buffer and not drop_last_partial: |
| yield buffer |
|
|
|
|
| @dataclass |
| class ShardWriter: |
| """Streams packed sequences to disk as fixed-size binary shards, so a |
| corpus far larger than RAM can be written without ever materializing |
| the whole thing in memory. Use as a context manager. |
| """ |
| output_dir: str | Path |
| seq_len: int |
| vocab_size: int |
| sequences_per_shard: int = 50_000 |
| shard_prefix: str = "shard" |
|
|
| def __post_init__(self) -> None: |
| self.output_dir = Path(self.output_dir) |
| self.output_dir.mkdir(parents=True, exist_ok=True) |
| self.dtype = np.uint16 if self.vocab_size <= 65_536 else np.uint32 |
| self._shard_idx = 0 |
| self._buffer: list[list[int]] = [] |
| self._shard_paths: list[Path] = [] |
| self._total_sequences = 0 |
|
|
| def __enter__(self) -> "ShardWriter": |
| return self |
|
|
| def __exit__(self, *exc) -> None: |
| self.close() |
|
|
| def add(self, sequence: list[int]) -> None: |
| if len(sequence) != self.seq_len: |
| raise ValueError( |
| f"sequence length {len(sequence)} != configured seq_len {self.seq_len}" |
| ) |
| self._buffer.append(sequence) |
| self._total_sequences += 1 |
| if len(self._buffer) >= self.sequences_per_shard: |
| self._flush() |
|
|
| def _flush(self) -> None: |
| if not self._buffer: |
| return |
| arr = np.array(self._buffer, dtype=self.dtype) |
| path = self.output_dir / f"{self.shard_prefix}_{self._shard_idx:05d}.bin" |
| arr.tofile(path) |
| self._shard_paths.append(path) |
| self._shard_idx += 1 |
| self._buffer = [] |
|
|
| def close(self) -> dict: |
| self._flush() |
| meta = { |
| "seq_len": self.seq_len, |
| "vocab_size": self.vocab_size, |
| "dtype": np.dtype(self.dtype).name, |
| "num_shards": len(self._shard_paths), |
| "total_sequences": self._total_sequences, |
| "shard_files": [p.name for p in self._shard_paths], |
| } |
| (self.output_dir / "meta.json").write_text(json.dumps(meta, indent=2)) |
| return meta |
|
|
|
|
| def build_shards_from_texts( |
| texts: Iterable[str], |
| tokenizer, |
| output_dir: str | Path, |
| context_length: int, |
| sequences_per_shard: int = 50_000, |
| ) -> dict: |
| """End-to-end: raw cleaned document strings -> tokenized -> packed -> |
| written to shards, ready for PackedDataset. `tokenizer` must implement |
| `.encode(text)` returning a list of ints and have |
| `.eos_id`/`.vocab_size` (matches |
| brain.tokenizer.tokenizer.BrainTokenizer's interface). |
| |
| context_length is the model's actual context length. Each stored |
| sequence is context_length + 1 tokens -- PackedDataset splits that into |
| an input_ids/labels pair of exactly context_length each via a |
| next-token shift ([:-1] / [1:]). Requesting seq_len=context_length |
| directly here would silently hand the model context_length - 1 usable |
| tokens per example after shifting, which is why this wrapper adds the |
| 1 rather than leaving it to the caller to remember. |
| """ |
| def token_docs() -> Iterator[list[int]]: |
| for text in texts: |
| yield tokenizer.encode(text, add_special_tokens=False) |
|
|
| stored_seq_len = context_length + 1 |
| with ShardWriter(output_dir, stored_seq_len, tokenizer.vocab_size, sequences_per_shard) as writer: |
| for seq in pack_token_stream(token_docs(), stored_seq_len, tokenizer.eos_id): |
| writer.add(seq) |
| return writer.close() |
|
|
