#!/usr/bin/env python3 """Tokenize FineWeb-Edu parquet files to byte-level .bin format. Spider-FLEXITOKENS uses byte-level vocab (272 tokens: 256 bytes + 16 specials). This script converts raw text parquet files to uint16 .bin files ready for fast loading by ByteLevelTokenizedDataset. Output format: - tokens.uint16: concatenated byte values (0-255) + special tokens (256-271) - metadata.json: {num_tokens, num_samples, seq_len, etc.} """ import os import sys import json import glob import argparse from pathlib import Path import numpy as np import pyarrow.parquet as pq from tqdm import tqdm # Sentinel tokens BOS_ID = 257 EOS_ID = 258 PAD_ID = 256 def tokenize_text(text: str, max_bytes: int = 2048) -> list: """Convert text to byte-level token sequence with BOS/EOS.""" byte_ids = list(text.encode('utf-8'))[:max_bytes] return [BOS_ID] + byte_ids + [EOS_ID] def process_parquet(parquet_path: str, output_dir: str, seq_len: int = 2048, max_samples: int = 0): """Process a single parquet file to tokenized .bin.""" print(f"Processing: {parquet_path}") output_path = os.path.join(output_dir, os.path.basename(parquet_path).replace('.parquet', '.bin')) tokens = [] num_samples = 0 try: pf = pq.ParquetFile(parquet_path) for batch in tqdm(pf.iter_batches(batch_size=1000, columns=["text"]), desc=os.path.basename(parquet_path)): texts = batch["text"].to_pylist() for text in texts: if not text: continue token_ids = tokenize_text(text, max_bytes=seq_len - 2) # -2 for BOS/EOS tokens.extend(token_ids) num_samples += 1 if max_samples > 0 and num_samples >= max_samples: break if max_samples > 0 and num_samples >= max_samples: break except Exception as e: print(f"Error processing {parquet_path}: {e}") return 0, 0 if tokens: arr = np.array(tokens, dtype=np.uint16) arr.tofile(output_path) print(f" Saved: {output_path} ({arr.nbytes / 1024**2:.1f} MB, {len(tokens):,} tokens)") return len(tokens), num_samples return 0, 0 def stream_from_huggingface(output_dir, seq_len=2048, num_shards=50, samples_per_shard=50000): """Stream FineWeb-Edu from HuggingFace and tokenize to .bin shards.""" from datasets import load_dataset from tqdm import tqdm os.makedirs(output_dir, exist_ok=True) print(f"Streaming FineWeb-Edu from HuggingFace (10BT sample)") print(f"Output: {output_dir}") ds = load_dataset("HuggingFaceFW/fineweb-edu", "sample/10BT", split="train", streaming=True) total_tokens = 0 total_samples = 0 shard_tokens = [] shard_count = 0 for sample in tqdm(ds, desc="Tokenizing"): text = sample.get("text", "") if not text: continue token_ids = tokenize_text(text, max_bytes=seq_len - 2) shard_tokens.extend(token_ids) total_samples += 1 if len(shard_tokens) >= samples_per_shard * seq_len: shard_count += 1 arr = np.array(shard_tokens, dtype=np.uint16) shard_path = os.path.join(output_dir, f"shard_{shard_count:04d}.bin") arr.tofile(shard_path) print(f" Shard {shard_count}: {shard_path} ({arr.nbytes / 1024**2:.1f} MB, {len(shard_tokens):,} tokens, {total_samples:,} samples)") total_tokens += len(shard_tokens) shard_tokens = [] if shard_count >= num_shards: break if shard_tokens: shard_count += 1 arr = np.array(shard_tokens, dtype=np.uint16) shard_path = os.path.join(output_dir, f"shard_{shard_count:04d}.bin") arr.tofile(shard_path) print(f" Shard {shard_count}: {shard_path} ({arr.nbytes / 1024**2:.1f} MB, {len(shard_tokens):,} tokens)") total_tokens += len(shard_tokens) metadata = { "source": "HuggingFaceFW/fineweb-edu sample/10BT", "seq_len": seq_len, "vocab_size": 272, "dtype": "uint16", "total_samples": total_samples, "total_tokens": total_tokens, "num_shards": shard_count, "token_format": "BOS + UTF-8 bytes + EOS (byte-level, 272 vocab)", } with open(os.path.join(output_dir, "metadata.json"), 'w') as f: json.dump(metadata, f, indent=2) print(f"\nDone! Total: {total_samples:,} samples, {total_tokens:,} tokens, {shard_count} shards") print(f"Metadata saved to {output_dir}/metadata.json") def main(): parser = argparse.ArgumentParser() parser.add_argument("--input_dir", type=str, default="", help="Input directory with parquet files (local mode)") parser.add_argument("--output_dir", type=str, default="/home/lamcodealong/fineweb_bytelevel", help="Output directory for tokenized .bin files") parser.add_argument("--seq_len", type=int, default=2048, help="Max sequence length (including BOS/EOS)") parser.add_argument("--max_samples", type=int, default=0, help="Max samples per file (0=all, local mode only)") parser.add_argument("--max_files", type=int, default=0, help="Max number of parquet files to process (0=all, local mode only)") parser.add_argument("--num_shards", type=int, default=50, help="Number of output shards (HuggingFace mode)") parser.add_argument("--samples_per_shard", type=int, default=50000, help="Approx samples per shard (HuggingFace mode)") parser.add_argument("--from_hf", action="store_true", help="Stream from HuggingFace instead of local parquet files") args = parser.parse_args() if args.from_hf or not args.input_dir: stream_from_huggingface(args.output_dir, args.seq_len, args.num_shards, args.samples_per_shard) return os.makedirs(args.output_dir, exist_ok=True) parquet_files = sorted(glob.glob(os.path.join(args.input_dir, "*.parquet"))) if args.max_files > 0: parquet_files = parquet_files[:args.max_files] print(f"Found {len(parquet_files)} parquet files") print(f"Output: {args.output_dir}") total_tokens = 0 total_samples = 0 for pq_file in parquet_files: n_tokens, n_samples = process_parquet( pq_file, args.output_dir, args.seq_len, args.max_samples ) total_tokens += n_tokens total_samples += n_samples metadata = { "input_dir": args.input_dir, "seq_len": args.seq_len, "vocab_size": 272, "dtype": "uint16", "total_samples": total_samples, "total_tokens": total_tokens, "token_format": "BOS + UTF-8 bytes + EOS (byte-level, 272 vocab)", } with open(os.path.join(args.output_dir, "metadata.json"), 'w') as f: json.dump(metadata, f, indent=2) print(f"\nDone! Total: {total_samples:,} samples, {total_tokens:,} tokens") print(f"Metadata saved to {args.output_dir}/metadata.json") if __name__ == "__main__": main()