Tokenized_Multi_Code-IR

#!/usr/bin/env python3
"""
tokenize_for_training.py — Tokenize and chunk ir_dataset.parquet into a
HuggingFace dataset ready for continued_pretrain.py.
Pipeline position: AFTER build_ir_dataset.py, BEFORE continued_pretrain.py
Input
-----
  Parquet file produced by build_ir_dataset.py with columns:
    source_code, llvm_ir, language, ir_type, source_dataset, est_tokens
Processing
----------
  1. Assemble one text string per record:
       sltrans    → <source>\\n{code}\\n</source>\\n<llvm_ir>\\n{ir}\\n</llvm_ir>
       stack_llvm → {llvm_ir}  (unpaired IR, no source)
       others     → {source_code}  (peS2o, TheStack, OpenWebMath)
  2. Tokenize each string without truncation, append an EOS token as a
     document separator.
  3. Concatenate all token sequences into one stream, split into
     fixed-length blocks of --block-size tokens.
  4. Emit records with input_ids / attention_mask / labels columns.
     labels == input_ids (the Trainer shifts internally for causal LM loss).
Output
------
  Arrow dataset saved with save_to_disk(), optionally pushed to the Hub.
  Load locally:  datasets.load_from_disk("./tokenized_dataset")
  Load from Hub: datasets.load_dataset("your-org/your-dataset")
  NOTE: continued_pretrain.py uses load_dataset(...), so either push to Hub
  or replace that call with load_from_disk() for a purely local workflow.
Usage
-----
  python tokenize_for_training.py \\
      --input ir_dataset.parquet \\
      --model bigcode/starcoderbase-1b \\
      --output ./tokenized_dataset
  python tokenize_for_training.py \\
      --input ir_dataset.parquet \\
      --model codellama/CodeLlama-7b-hf \\
      --output ./tokenized_dataset \\
      --validation-split 0.05 \\
      --push-to-hub your-org/dataset-name \\
      --token YOUR_HF_TOKEN
"""

from __future__ import annotations

import argparse
import sys
from pathlib import Path

from itertools import chain

from datasets import Dataset, DatasetDict
from transformers import AutoTokenizer

# Special tokens the IRCoder paper adds to every model's vocabulary.
_IR_SPECIAL_TOKENS = ["<source_to_llvm>", "<llvm_to_source>"]
_PAD_TOKEN = "<|pad|>"

# Records per batch during the group_texts step.  Larger batches waste fewer
# tokens at chunk boundaries.
_GROUP_BATCH_SIZE = 5_000


# ── tokenizer setup ────────────────────────────────────────────────────────────

def build_tokenizer(model_name: str, block_size: int | None, token: str | None) -> AutoTokenizer:
    """Load tokenizer and register the IRCoder special tokens."""
    tok = AutoTokenizer.from_pretrained(
        model_name,
        padding_side="left",
        truncation_side="right",
        trust_remote_code=True,
        token=token,
    )

    tokens_to_add: dict = {}

    if tok.pad_token is None:
        tokens_to_add["pad_token"] = _PAD_TOKEN

    extra = [t for t in _IR_SPECIAL_TOKENS if t not in tok.get_vocab()]
    existing_extra = list(tok.extra_special_tokens or [])
    new_extra = [t for t in extra if t not in existing_extra]
    if new_extra:
        tokens_to_add["additional_special_tokens"] = existing_extra + new_extra

    if tokens_to_add:
        tok.add_special_tokens(tokens_to_add)

    if block_size is not None:
        tok.model_max_length = block_size
    elif tok.model_max_length > 1_000_000:
        # HuggingFace sets model_max_length to a huge sentinel when the tokenizer
        # config doesn't specify a context length. Fall back to the value used by
        # the IRCoder paper for all StarCoder/DeepSeek/CodeLlama models.
        tok.model_max_length = 4096
        print(f"  WARNING: tokenizer did not report a context length; defaulting "
              f"to {tok.model_max_length}. Pass --block-size to override.")

    return tok


# ── text assembly ──────────────────────────────────────────────────────────────

def _assemble_text_batch(batch: dict) -> dict:
    """Derive a single 'text' string for each record."""
    texts: list[str | None] = []
    for src, ir, source in zip(
        batch["source_code"], batch["llvm_ir"], batch["source_dataset"]
    ):
        if source == "sltrans":
            if src and ir:
                texts.append(
                    f"<source>\n{src}\n</source>\n<llvm_ir>\n{ir}\n</llvm_ir>"
                )
            else:
                texts.append(None)
        elif source == "stack_llvm":
            texts.append(str(ir) if ir else None)
        else:
            texts.append(str(src) if src else None)
    return {"text": texts}


def _is_valid(example: dict) -> bool:
    t = example["text"]
    return t is not None and t != ""


# ── tokenisation ───────────────────────────────────────────────────────────────

def _tokenize_batch(batch: dict, tokenizer: AutoTokenizer) -> dict:
    """Tokenize text without truncation; append EOS as a document separator."""
    eos = tokenizer.eos_token_id
    if eos is None:
        raise ValueError(
            f"Tokenizer for {tokenizer.name_or_path!r} has no eos_token_id. "
            "Set one explicitly before running this script."
        )

    encoded = tokenizer(
        batch["text"],
        add_special_tokens=False,
        truncation=False,
        padding=False,
    )
    return {
        "input_ids":      [ids + [eos] for ids in encoded["input_ids"]],
        "attention_mask": [am  + [1]   for am  in encoded["attention_mask"]],
    }


# ── chunking ───────────────────────────────────────────────────────────────────

def _group_texts(batch: dict, block_size: int) -> dict:
    """Concatenate token sequences and split into fixed-length blocks."""
    all_ids = list(chain.from_iterable(batch["input_ids"]))
    total = (len(all_ids) // block_size) * block_size
    if total == 0:
        return {"input_ids": [], "attention_mask": [], "labels": []}

    num_blocks = total // block_size
    ids_list = [all_ids[i : i + block_size] for i in range(0, total, block_size)]
    am_row = [1] * block_size

    return {
        "input_ids": ids_list,
        "attention_mask": [am_row] * num_blocks,
        "labels": ids_list,
    }


# ── main ───────────────────────────────────────────────────────────────────────

def main() -> None:
    ap = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    ap.add_argument(
        "--input", default="ir_dataset.parquet",
        help="Parquet file from build_ir_dataset.py (default: ir_dataset.parquet)",
    )
    ap.add_argument(
        "--model", required=True,
        help="HuggingFace model name — selects the tokenizer "
             "(e.g. bigcode/starcoderbase-1b)",
    )
    ap.add_argument(
        "--output", default="./tokenized_dataset",
        help="Directory for the Arrow dataset (default: ./tokenized_dataset)",
    )
    ap.add_argument(
        "--block-size", type=int, default=None,
        help="Token block length. Defaults to the tokenizer's model_max_length "
             "(4096 for StarCoder/DeepSeek/CodeLlama, 2048 for CodeGen).",
    )
    ap.add_argument(
        "--num-workers", type=int, default=1,
        help="Parallel workers for dataset.map (default: 1). "
             "Increase on Linux; keep at 1 on Windows to avoid spawn issues.",
    )
    ap.add_argument(
        "--validation-split", type=float, default=0.0,
        help="Fraction of blocks to hold out as validation (default: 0 = no split). "
             "The training script can also split at runtime via "
             "--validation_split_percentage.",
    )
    ap.add_argument(
        "--push-to-hub", default=None, metavar="HUB_DATASET_ID",
        help="Push the finished dataset to the Hub (e.g. your-org/dataset-name).",
    )
    ap.add_argument(
        "--token", default=None,
        help="HuggingFace token (required for gated models and Hub push).",
    )
    args = ap.parse_args()

    in_path = Path(args.input)
    if not in_path.exists():
        print(f"ERROR: input file not found: {in_path}", file=sys.stderr)
        sys.exit(1)

    # ── tokenizer ─────────────────────────────────────────────────────────────
    print(f"Model / tokenizer  : {args.model}")
    tokenizer = build_tokenizer(args.model, args.block_size, args.token)
    block_size = tokenizer.model_max_length
    print(f"Block size         : {block_size} tokens")
    print(f"Vocab size (final) : {len(tokenizer)}")
    print(f"EOS token          : {tokenizer.eos_token!r}  (id={tokenizer.eos_token_id})")
    print()

    # ── load ──────────────────────────────────────────────────────────────────
    print(f"[1/4] Loading {in_path.resolve()} ...")
    ds: Dataset = Dataset.from_parquet(str(in_path))
    print(f"      {len(ds):,} records loaded")

    # ── assemble text ─────────────────────────────────────────────────────────
    print("\n[2/4] Assembling text column ...")
    ds = ds.map(
        _assemble_text_batch,
        batched=True,
        num_proc=args.num_workers,
        remove_columns=ds.column_names,
        desc="assemble",
    )
    before = len(ds)
    ds = ds.filter(_is_valid, num_proc=args.num_workers, desc="filter-empty")
    dropped = before - len(ds)
    print(f"      {len(ds):,} records with text  ({dropped:,} dropped — empty/null fields)")

    # ── tokenize ──────────────────────────────────────────────────────────────
    print("\n[3/4] Tokenizing (no truncation, EOS appended) ...")
    ds = ds.map(
        _tokenize_batch,
        fn_kwargs={"tokenizer": tokenizer},
        batched=True,
        batch_size=1_000,
        writer_batch_size=500,
        num_proc=args.num_workers,
        remove_columns=["text"],
        desc="tokenize",
    )

    # ── chunk ─────────────────────────────────────────────────────────────────
    print(f"\n[4/4] Chunking into {block_size}-token blocks ...")
    ds = ds.map(
        _group_texts,
        fn_kwargs={"block_size": block_size},
        batched=True,
        batch_size=_GROUP_BATCH_SIZE,
        num_proc=args.num_workers,
        desc="chunk",
    )
    total_tokens = len(ds) * block_size
    print(f"      {len(ds):,} blocks  ({total_tokens:,} tokens)")
    if len(ds) == 0:
        print("ERROR: chunking produced 0 blocks. Check that --block-size is set "
              "correctly and that the input dataset is non-empty.", file=sys.stderr)
        sys.exit(1)
    if "labels" not in ds.column_names:
        ds = ds.add_column("labels", ds["input_ids"])

    # ── optional validation split ─────────────────────────────────────────────
    out_ds: Dataset | DatasetDict
    if args.validation_split > 0.0:
        split = ds.train_test_split(
            test_size=args.validation_split, seed=42, shuffle=True
        )
        out_ds = DatasetDict({"train": split["train"], "validation": split["test"]})
        print(
            f"\n      train      : {len(split['train']):,} blocks"
            f"\n      validation : {len(split['test']):,} blocks"
        )
    else:
        out_ds = ds

    # ── save ──────────────────────────────────────────────────────────────────
    out_dir = Path(args.output)
    out_dir.mkdir(parents=True, exist_ok=True)
    print(f"\nSaving parquet to {out_dir.resolve()} ...")

    splits: dict[str, Dataset] = (
        dict(out_ds.items()) if isinstance(out_ds, DatasetDict) else {"train": out_ds}
    )
    for split_name, split_ds in splits.items():
        dest = out_dir / f"{split_name}.parquet"
        split_ds.to_parquet(str(dest))
        print(f"  Wrote {dest.name}  ({len(split_ds):,} blocks)")

    if args.push_to_hub:
        print(f"\nPushing to Hub: {args.push_to_hub} ...")
        out_ds.push_to_hub(args.push_to_hub, token=args.token)
        print("Pushed.")

    # ── summary ───────────────────────────────────────────────────────────────
    print()
    print("=" * 60)
    print("TOKENIZATION COMPLETE")
    print("=" * 60)
    for split_name, split_ds in splits.items():
        print(
            f"  {split_name:<12} {len(split_ds):>10,} blocks"
            f"  ({len(split_ds) * block_size:,} tokens)"
        )

    schema_ds = next(iter(splits.values()))
    print(f"\nDataset schema : {list(schema_ds.column_names)}")
    print(f"Output         : {out_dir.resolve()}")
    if args.push_to_hub:
        print(f"Hub            : {args.push_to_hub}")
    print()
    print("Pass to continued_pretrain.py with:")
    print(f"  --dataset_name {str(out_dir.resolve())!r}")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""
	tokenize_for_training.py — Tokenize and chunk ir_dataset.parquet into a
	HuggingFace dataset ready for continued_pretrain.py.

	Pipeline position: AFTER build_ir_dataset.py, BEFORE continued_pretrain.py

	Input
	-----
	Parquet file produced by build_ir_dataset.py with columns:
	source_code, llvm_ir, language, ir_type, source_dataset, est_tokens

	Processing
	----------
	1. Assemble one text string per record:
	sltrans → <source>\\n{code}\\n</source>\\n<llvm_ir>\\n{ir}\\n</llvm_ir>
	stack_llvm → {llvm_ir} (unpaired IR, no source)
	others → {source_code} (peS2o, TheStack, OpenWebMath)
	2. Tokenize each string without truncation, append an EOS token as a
	document separator.
	3. Concatenate all token sequences into one stream, split into
	fixed-length blocks of --block-size tokens.
	4. Emit records with input_ids / attention_mask / labels columns.
	labels == input_ids (the Trainer shifts internally for causal LM loss).

	Output
	------
	Arrow dataset saved with save_to_disk(), optionally pushed to the Hub.
	Load locally: datasets.load_from_disk("./tokenized_dataset")
	Load from Hub: datasets.load_dataset("your-org/your-dataset")

	NOTE: continued_pretrain.py uses load_dataset(...), so either push to Hub
	or replace that call with load_from_disk() for a purely local workflow.

	Usage
	-----
	python tokenize_for_training.py \\
	--input ir_dataset.parquet \\
	--model bigcode/starcoderbase-1b \\
	--output ./tokenized_dataset

	python tokenize_for_training.py \\
	--input ir_dataset.parquet \\
	--model codellama/CodeLlama-7b-hf \\
	--output ./tokenized_dataset \\
	--validation-split 0.05 \\
	--push-to-hub your-org/dataset-name \\
	--token YOUR_HF_TOKEN
	"""

	from __future__ import annotations

	import argparse
	import sys
	from pathlib import Path

	from itertools import chain

	from datasets import Dataset, DatasetDict
	from transformers import AutoTokenizer

	# Special tokens the IRCoder paper adds to every model's vocabulary.
	_IR_SPECIAL_TOKENS = ["<source_to_llvm>", "<llvm_to_source>"]
	_PAD_TOKEN = "<\|pad\|>"

	# Records per batch during the group_texts step. Larger batches waste fewer
	# tokens at chunk boundaries.
	_GROUP_BATCH_SIZE = 5_000


	# ── tokenizer setup ────────────────────────────────────────────────────────────

	def build_tokenizer(model_name: str, block_size: int \| None, token: str \| None) -> AutoTokenizer:
	"""Load tokenizer and register the IRCoder special tokens."""
	tok = AutoTokenizer.from_pretrained(
	model_name,
	padding_side="left",
	truncation_side="right",
	trust_remote_code=True,
	token=token,
	)

	tokens_to_add: dict = {}

	if tok.pad_token is None:
	tokens_to_add["pad_token"] = _PAD_TOKEN

	extra = [t for t in _IR_SPECIAL_TOKENS if t not in tok.get_vocab()]
	existing_extra = list(tok.extra_special_tokens or [])
	new_extra = [t for t in extra if t not in existing_extra]
	if new_extra:
	tokens_to_add["additional_special_tokens"] = existing_extra + new_extra

	if tokens_to_add:
	tok.add_special_tokens(tokens_to_add)

	if block_size is not None:
	tok.model_max_length = block_size
	elif tok.model_max_length > 1_000_000:
	# HuggingFace sets model_max_length to a huge sentinel when the tokenizer
	# config doesn't specify a context length. Fall back to the value used by
	# the IRCoder paper for all StarCoder/DeepSeek/CodeLlama models.
	tok.model_max_length = 4096
	print(f" WARNING: tokenizer did not report a context length; defaulting "
	f"to {tok.model_max_length}. Pass --block-size to override.")

	return tok


	# ── text assembly ──────────────────────────────────────────────────────────────

	def _assemble_text_batch(batch: dict) -> dict:
	"""Derive a single 'text' string for each record."""
	texts: list[str \| None] = []
	for src, ir, source in zip(
	batch["source_code"], batch["llvm_ir"], batch["source_dataset"]
	):
	if source == "sltrans":
	if src and ir:
	texts.append(
	f"<source>\n{src}\n</source>\n<llvm_ir>\n{ir}\n</llvm_ir>"
	)
	else:
	texts.append(None)
	elif source == "stack_llvm":
	texts.append(str(ir) if ir else None)
	else:
	texts.append(str(src) if src else None)
	return {"text": texts}


	def _is_valid(example: dict) -> bool:
	t = example["text"]
	return t is not None and t != ""


	# ── tokenisation ───────────────────────────────────────────────────────────────

	def _tokenize_batch(batch: dict, tokenizer: AutoTokenizer) -> dict:
	"""Tokenize text without truncation; append EOS as a document separator."""
	eos = tokenizer.eos_token_id
	if eos is None:
	raise ValueError(
	f"Tokenizer for {tokenizer.name_or_path!r} has no eos_token_id. "
	"Set one explicitly before running this script."
	)

	encoded = tokenizer(
	batch["text"],
	add_special_tokens=False,
	truncation=False,
	padding=False,
	)
	return {
	"input_ids": [ids + [eos] for ids in encoded["input_ids"]],
	"attention_mask": [am + [1] for am in encoded["attention_mask"]],
	}


	# ── chunking ───────────────────────────────────────────────────────────────────

	def _group_texts(batch: dict, block_size: int) -> dict:
	"""Concatenate token sequences and split into fixed-length blocks."""
	all_ids = list(chain.from_iterable(batch["input_ids"]))
	total = (len(all_ids) // block_size) * block_size
	if total == 0:
	return {"input_ids": [], "attention_mask": [], "labels": []}

	num_blocks = total // block_size
	ids_list = [all_ids[i : i + block_size] for i in range(0, total, block_size)]
	am_row = [1] * block_size

	return {
	"input_ids": ids_list,
	"attention_mask": [am_row] * num_blocks,
	"labels": ids_list,
	}


	# ── main ───────────────────────────────────────────────────────────────────────

	def main() -> None:
	ap = argparse.ArgumentParser(
	description=__doc__,
	formatter_class=argparse.RawDescriptionHelpFormatter,
	)
	ap.add_argument(
	"--input", default="ir_dataset.parquet",
	help="Parquet file from build_ir_dataset.py (default: ir_dataset.parquet)",
	)
	ap.add_argument(
	"--model", required=True,
	help="HuggingFace model name — selects the tokenizer "
	"(e.g. bigcode/starcoderbase-1b)",
	)
	ap.add_argument(
	"--output", default="./tokenized_dataset",
	help="Directory for the Arrow dataset (default: ./tokenized_dataset)",
	)
	ap.add_argument(
	"--block-size", type=int, default=None,
	help="Token block length. Defaults to the tokenizer's model_max_length "
	"(4096 for StarCoder/DeepSeek/CodeLlama, 2048 for CodeGen).",
	)
	ap.add_argument(
	"--num-workers", type=int, default=1,
	help="Parallel workers for dataset.map (default: 1). "
	"Increase on Linux; keep at 1 on Windows to avoid spawn issues.",
	)
	ap.add_argument(
	"--validation-split", type=float, default=0.0,
	help="Fraction of blocks to hold out as validation (default: 0 = no split). "
	"The training script can also split at runtime via "
	"--validation_split_percentage.",
	)
	ap.add_argument(
	"--push-to-hub", default=None, metavar="HUB_DATASET_ID",
	help="Push the finished dataset to the Hub (e.g. your-org/dataset-name).",
	)
	ap.add_argument(
	"--token", default=None,
	help="HuggingFace token (required for gated models and Hub push).",
	)
	args = ap.parse_args()

	in_path = Path(args.input)
	if not in_path.exists():
	print(f"ERROR: input file not found: {in_path}", file=sys.stderr)
	sys.exit(1)

	# ── tokenizer ─────────────────────────────────────────────────────────────
	print(f"Model / tokenizer : {args.model}")
	tokenizer = build_tokenizer(args.model, args.block_size, args.token)
	block_size = tokenizer.model_max_length
	print(f"Block size : {block_size} tokens")
	print(f"Vocab size (final) : {len(tokenizer)}")
	print(f"EOS token : {tokenizer.eos_token!r} (id={tokenizer.eos_token_id})")
	print()

	# ── load ──────────────────────────────────────────────────────────────────
	print(f"[1/4] Loading {in_path.resolve()} ...")
	ds: Dataset = Dataset.from_parquet(str(in_path))
	print(f" {len(ds):,} records loaded")

	# ── assemble text ─────────────────────────────────────────────────────────
	print("\n[2/4] Assembling text column ...")
	ds = ds.map(
	_assemble_text_batch,
	batched=True,
	num_proc=args.num_workers,
	remove_columns=ds.column_names,
	desc="assemble",
	)
	before = len(ds)
	ds = ds.filter(_is_valid, num_proc=args.num_workers, desc="filter-empty")
	dropped = before - len(ds)
	print(f" {len(ds):,} records with text ({dropped:,} dropped — empty/null fields)")

	# ── tokenize ──────────────────────────────────────────────────────────────
	print("\n[3/4] Tokenizing (no truncation, EOS appended) ...")
	ds = ds.map(
	_tokenize_batch,
	fn_kwargs={"tokenizer": tokenizer},
	batched=True,
	batch_size=1_000,
	writer_batch_size=500,
	num_proc=args.num_workers,
	remove_columns=["text"],
	desc="tokenize",
	)

	# ── chunk ─────────────────────────────────────────────────────────────────
	print(f"\n[4/4] Chunking into {block_size}-token blocks ...")
	ds = ds.map(
	_group_texts,
	fn_kwargs={"block_size": block_size},
	batched=True,
	batch_size=_GROUP_BATCH_SIZE,
	num_proc=args.num_workers,
	desc="chunk",
	)
	total_tokens = len(ds) * block_size
	print(f" {len(ds):,} blocks ({total_tokens:,} tokens)")
	if len(ds) == 0:
	print("ERROR: chunking produced 0 blocks. Check that --block-size is set "
	"correctly and that the input dataset is non-empty.", file=sys.stderr)
	sys.exit(1)
	if "labels" not in ds.column_names:
	ds = ds.add_column("labels", ds["input_ids"])

	# ── optional validation split ─────────────────────────────────────────────
	out_ds: Dataset \| DatasetDict
	if args.validation_split > 0.0:
	split = ds.train_test_split(
	test_size=args.validation_split, seed=42, shuffle=True
	)
	out_ds = DatasetDict({"train": split["train"], "validation": split["test"]})
	print(
	f"\n train : {len(split['train']):,} blocks"
	f"\n validation : {len(split['test']):,} blocks"
	)
	else:
	out_ds = ds

	# ── save ──────────────────────────────────────────────────────────────────
	out_dir = Path(args.output)
	out_dir.mkdir(parents=True, exist_ok=True)
	print(f"\nSaving parquet to {out_dir.resolve()} ...")

	splits: dict[str, Dataset] = (
	dict(out_ds.items()) if isinstance(out_ds, DatasetDict) else {"train": out_ds}
	)
	for split_name, split_ds in splits.items():
	dest = out_dir / f"{split_name}.parquet"
	split_ds.to_parquet(str(dest))
	print(f" Wrote {dest.name} ({len(split_ds):,} blocks)")

	if args.push_to_hub:
	print(f"\nPushing to Hub: {args.push_to_hub} ...")
	out_ds.push_to_hub(args.push_to_hub, token=args.token)
	print("Pushed.")

	# ── summary ───────────────────────────────────────────────────────────────
	print()
	print("=" * 60)
	print("TOKENIZATION COMPLETE")
	print("=" * 60)
	for split_name, split_ds in splits.items():
	print(
	f" {split_name:<12} {len(split_ds):>10,} blocks"
	f" ({len(split_ds) * block_size:,} tokens)"
	)

	schema_ds = next(iter(splits.values()))
	print(f"\nDataset schema : {list(schema_ds.column_names)}")
	print(f"Output : {out_dir.resolve()}")
	if args.push_to_hub:
	print(f"Hub : {args.push_to_hub}")
	print()
	print("Pass to continued_pretrain.py with:")
	print(f" --dataset_name {str(out_dir.resolve())!r}")


	if __name__ == "__main__":
	main()