verify.py

#!/usr/bin/env python3
"""Verify the private published dataset from fresh Hub downloads."""

from __future__ import annotations

import argparse
import hashlib
import json
import re
import shutil
import tempfile
import urllib.request
from collections import Counter
from pathlib import Path
from typing import Any

from datasets import DownloadMode, load_dataset
from huggingface_hub import HfApi, hf_hub_download

from build import (
    HUMANEVAL_REPO,
    HUMANEVAL_REVISION,
    MBPP_CONFIG,
    MBPP_REPO,
    MBPP_REVISION,
    REPO_ID,
    SOURCE_SHA256,
    SOURCE_URL,
    contamination_hits,
    distribution,
    lexical_tokens,
    load_token,
    make_benchmark_indexes,
    normalize_text,
    normalized_pair,
    sha256_file,
)

DATASETS_CACHE = Path.home() / ".cache" / "huggingface" / "datasets"


def assert_messages(row: dict[str, Any]) -> None:
    messages = row["messages"]
    assert isinstance(messages, list), "messages must be a list, not serialized JSON"
    assert len(messages) == 2, "each row must have exactly two messages"
    assert [message["role"] for message in messages] == ["user", "assistant"]
    assert all(isinstance(message, dict) for message in messages)
    assert all(isinstance(message["content"], str) for message in messages)
    assert row["output"].strip(), "output must not be empty or whitespace-only"
    assert messages[1]["content"] == row["output"]
    expected_user = (
        row["instruction"]
        if not row["input"].strip()
        else f"{row['instruction']}\n\n{row['input']}"
    )
    assert messages[0]["content"] == expected_user


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def assert_card_counts(card: str, stats: dict[str, Any]) -> None:
    audit = stats["source_audit"]
    rejects = stats["rejections"]
    splits = stats["splits"]
    overlap = stats["benchmark_overlap_before_filtering"]
    expected_lines = [
        f"| Source rows | {audit['rows']} |",
        f"| Non-empty `input` rows | {audit['input_nonempty']} |",
        f"| Empty `output` rows | {audit['output_empty']} |",
        f"| Exact duplicate instruction rows | {audit['duplicate_instruction_rows_exact']} |",
        f"| Aggressively normalized duplicate instruction rows | {audit['duplicate_instruction_rows_normalized']} |",
        f"| Exact `output == instruction` rows | {audit['output_equals_instruction_exact']} |",
        f"| Normalized `output == instruction` rows | {audit['output_equals_instruction_normalized']} |",
        f"| HumanEval | {stats['benchmarks']['HumanEval']['test_items']} | {overlap['HumanEval']['exact_normalized_rows']} | {overlap['HumanEval']['13gram_rows']} |",
        f"| MBPP (`full`, `test`, field `text`) | {stats['benchmarks']['MBPP']['test_items']} | {overlap['MBPP']['exact_normalized_rows']} | {overlap['MBPP']['13gram_rows']} |",
        f"| Empty output | {rejects['empty_output']} |",
        f"| Benchmark contamination (union) | {rejects['benchmark_contamination_union']} |",
        f"| Duplicate normalized `(instruction, input)` | {rejects['duplicate_normalized_pair']} |",
        f"| Train/test signature purge from train | {rejects['train_test_overlap_from_train']} |",
        f"| **Total removed** | **{rejects['total']}** |",
        f"| train | {splits['train']} |",
        f"| test | {splits['test']} |",
        f"| total | {splits['total']} |",
    ]
    for line in expected_lines:
        assert line in card, f"dataset card is missing measured line: {line}"


def verify(repo_id: str) -> dict[str, Any]:
    token = load_token()
    api = HfApi(token=token)
    info = api.dataset_info(repo_id)
    assert info.private, "Hub repository must be private"
    revision = info.sha

    if DATASETS_CACHE.exists():
        shutil.rmtree(DATASETS_CACHE)
    published = load_dataset(
        repo_id,
        token=token,
        revision=revision,
        download_mode=DownloadMode.FORCE_REDOWNLOAD,
    )
    assert set(published.keys()) == {"train", "test"}
    assert set(published["train"].column_names) == {
        "messages",
        "instruction",
        "input",
        "output",
    }

    remote_paths: dict[str, Path] = {}
    for filename in (
        "data/train.parquet",
        "data/test.parquet",
        "stats.json",
        "README.md",
        "dataset_card.md",
        "rejections.jsonl",
        "validation_report.json",
        "build.py",
        "verify.py",
    ):
        remote_paths[filename] = Path(
            hf_hub_download(
                repo_id,
                filename,
                repo_type="dataset",
                token=token,
                revision=revision,
                force_download=True,
            )
        )

    stats = json.loads(remote_paths["stats.json"].read_text(encoding="utf-8"))
    card = remote_paths["README.md"].read_text(encoding="utf-8")
    assert card == remote_paths["dataset_card.md"].read_text(encoding="utf-8")

    train = published["train"]
    test = published["test"]
    assert len(train) == stats["splits"]["train"]
    assert len(test) == stats["splits"]["test"]
    assert len(train) + len(test) == stats["splits"]["total"]

    for split in (train, test):
        for row in split:
            assert_messages(row)

    train_signatures = {
        normalized_pair(row["instruction"], row["input"]) for row in train
    }
    test_signatures = {
        normalized_pair(row["instruction"], row["input"]) for row in test
    }
    train_test_overlap = train_signatures & test_signatures
    assert not train_test_overlap, "aggressive train/test overlap is not zero"
    train_instruction_signatures = {
        normalize_text(row["instruction"]) for row in train
    }
    test_instruction_signatures = {
        normalize_text(row["instruction"]) for row in test
    }
    train_test_instruction_overlap = (
        train_instruction_signatures & test_instruction_signatures
    )
    assert not train_test_instruction_overlap, (
        "aggressively normalized instruction overlap across train/test is not zero"
    )
    all_rows = list(train) + list(test)
    assert len(train_signatures) == len(train)
    assert len(test_signatures) == len(test)

    humaneval = load_dataset(
        HUMANEVAL_REPO,
        split="test",
        revision=HUMANEVAL_REVISION,
        download_mode=DownloadMode.FORCE_REDOWNLOAD,
    )
    mbpp = load_dataset(
        MBPP_REPO,
        MBPP_CONFIG,
        split="test",
        revision=MBPP_REVISION,
        download_mode=DownloadMode.FORCE_REDOWNLOAD,
    )
    benchmark_items = [
        {"benchmark": "HumanEval", "item_id": str(row["task_id"]), "text": row["prompt"]}
        for row in humaneval
    ] + [
        {"benchmark": "MBPP", "item_id": str(row["task_id"]), "text": row["text"]}
        for row in mbpp
    ]
    exact_index, ngram_index = make_benchmark_indexes(benchmark_items)
    post_filter_counts: Counter[tuple[str, str]] = Counter()
    residual_hits: list[dict[str, Any]] = []
    for row in all_rows:
        hits = contamination_hits(row["instruction"], exact_index, ngram_index)
        for hit in hits:
            post_filter_counts[(hit["benchmark"], hit["criterion"])] += 1
            residual_hits.append(
                {
                    "instruction": row["instruction"],
                    "hit": hit,
                }
            )
    assert not residual_hits, f"benchmark contamination remains: {residual_hits[:3]}"

    with tempfile.TemporaryDirectory(prefix="codealpaca-verify-source-") as temporary:
        source_path = Path(temporary) / "source.parquet"
        with urllib.request.urlopen(SOURCE_URL) as response, source_path.open("wb") as handle:
            shutil.copyfileobj(response, handle)
        source = load_dataset(
            "parquet",
            data_files=str(source_path),
            split="train",
            download_mode=DownloadMode.FORCE_REDOWNLOAD,
        )
        assert sha256(source_path) == SOURCE_SHA256 == stats["source"]["sha256"]
    source_instructions = list(source["instruction"])
    source_inputs = list(source["input"])
    source_outputs = list(source["output"])
    measured_source_audit = {
        "rows": len(source),
        "input_nonempty": sum(bool(value.strip()) for value in source_inputs),
        "output_empty": sum(not bool(value.strip()) for value in source_outputs),
        "duplicate_instruction_rows_exact": len(source_instructions)
        - len(set(source_instructions)),
        "duplicate_instruction_rows_normalized": len(source_instructions)
        - len({normalize_text(value) for value in source_instructions}),
        "output_equals_instruction_exact": sum(
            output == instruction
            for instruction, output in zip(source_instructions, source_outputs)
        ),
        "output_equals_instruction_normalized": sum(
            normalize_text(output) == normalize_text(instruction)
            for instruction, output in zip(source_instructions, source_outputs)
        ),
    }
    assert measured_source_audit == stats["source_audit"]
    assert len(humaneval) == stats["benchmarks"]["HumanEval"]["test_items"]
    assert len(mbpp) == stats["benchmarks"]["MBPP"]["test_items"]

    measured_before_filtering: dict[str, dict[str, set[int]]] = {
        benchmark: {"exact_normalized": set(), "13gram": set()}
        for benchmark in ("HumanEval", "MBPP")
    }
    for source_index, instruction in enumerate(source_instructions):
        for hit in contamination_hits(instruction, exact_index, ngram_index):
            measured_before_filtering[hit["benchmark"]][hit["criterion"]].add(
                source_index
            )
    for benchmark in ("HumanEval", "MBPP"):
        exact_rows = measured_before_filtering[benchmark]["exact_normalized"]
        gram_rows = measured_before_filtering[benchmark]["13gram"]
        assert stats["benchmark_overlap_before_filtering"][benchmark] == {
            "exact_normalized_rows": len(exact_rows),
            "13gram_rows": len(gram_rows),
            "union_rows": len(exact_rows | gram_rows),
        }

    rejection_lines = [
        json.loads(line)
        for line in remote_paths["rejections.jsonl"].read_text(encoding="utf-8").splitlines()
        if line
    ]
    rejection_counts = Counter(row["reason"] for row in rejection_lines)
    assert rejection_counts["empty_output"] == stats["rejections"]["empty_output"]
    assert (
        rejection_counts["benchmark_contamination"]
        == stats["rejections"]["benchmark_contamination_union"]
    )
    assert (
        rejection_counts["duplicate_normalized_pair"]
        == stats["rejections"]["duplicate_normalized_pair"]
    )
    assert (
        rejection_counts["train_test_overlap_from_train"]
        == stats["rejections"]["train_test_overlap_from_train"]
    )
    assert len(rejection_lines) == stats["rejections"]["total"]
    assert len(source) - len(all_rows) == stats["rejections"]["total"]
    measured_rejection_rate = round(
        100 * stats["rejections"]["total"] / len(source), 6
    )
    assert measured_rejection_rate == stats["rejection_rate_percent"]
    measured_test_fraction = round(100 * len(test) / len(all_rows), 6)
    assert measured_test_fraction == stats["splits"]["test_fraction_percent"]

    assert stats["diversity"]["rows_with_nonempty_input"] == sum(
        bool(row["input"].strip()) for row in all_rows
    )
    assert stats["diversity"]["unique_instruction_exact"] == len(
        {row["instruction"] for row in all_rows}
    )
    assert stats["diversity"]["unique_instruction_normalized"] == len(
        {normalize_text(row["instruction"]) for row in all_rows}
    )
    assert stats["diversity"]["unique_normalized_pairs"] == len(
        {
            normalized_pair(row["instruction"], row["input"])
            for row in all_rows
        }
    )
    assert stats["lengths"]["user_tokens"] == distribution(
        [len(lexical_tokens(row["messages"][0]["content"])) for row in all_rows]
    )
    assert stats["lengths"]["assistant_tokens"] == distribution(
        [len(lexical_tokens(row["messages"][1]["content"])) for row in all_rows]
    )
    assert stats["post_build_checks"]["train_test_normalized_pair_overlap"] == 0

    for filename in ("data/train.parquet", "data/test.parquet", "rejections.jsonl"):
        assert sha256(remote_paths[filename]) == stats["files"][filename]["sha256"]
        assert remote_paths[filename].stat().st_size == stats["files"][filename]["bytes"]

    assert_card_counts(card, stats)
    validation_report = json.loads(
        remote_paths["validation_report.json"].read_text(encoding="utf-8")
    )
    assert validation_report["status"] == "passed"
    assert validation_report["rejections_by_reason"] == stats["rejections"]

    result = {
        "status": "passed",
        "repo_id": repo_id,
        "revision": revision,
        "private": info.private,
        "fresh_dataset_cache_removed": True,
        "splits": {"train": len(train), "test": len(test)},
        "train_test_aggressive_overlap": len(train_test_overlap),
        "train_test_normalized_instruction_overlap": len(
            train_test_instruction_overlap
        ),
        "benchmark_overlap_after_filtering": {
            "HumanEval": {"exact_normalized_rows": 0, "13gram_rows": 0},
            "MBPP": {"exact_normalized_rows": 0, "13gram_rows": 0},
        },
        "typed_messages": True,
        "strict_user_assistant_alternation": True,
        "nonempty_outputs": True,
        "card_counts_match_remote_data": True,
        "source_audit_matches_fresh_source": True,
        "prefilter_overlap_counts_match_fresh_source": True,
        "remote_hashes_match_stats": True,
    }
    print(json.dumps(result, indent=2))
    return result


def instantiate_sft_trainer(repo_id: str) -> None:
    """Optional smoke test requiring TRL, Torch, and a model checkpoint."""
    from trl import SFTConfig, SFTTrainer

    token = load_token()
    dataset = load_dataset(repo_id, token=token, split="train[:2]")
    output_dir = Path(__file__).resolve().parent / ".sft-smoke-output"
    trainer = SFTTrainer(
        model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
        train_dataset=dataset,
        args=SFTConfig(
            output_dir=str(output_dir),
            max_length=256,
            use_cpu=True,
            report_to="none",
        ),
    )
    assert trainer.train_dataset is not None
    print("SFTTrainer construction: passed")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--repo-id", default=REPO_ID)
    parser.add_argument("--sft-smoke", action="store_true")
    args = parser.parse_args()
    verify(args.repo_id)
    if args.sft_smoke:
        instantiate_sft_trainer(args.repo_id)


if __name__ == "__main__":
    main()