docs/split_protocol.md

Code-ATLAS split protocol

Objective

Create per-language held-out code for stable next-token loss while preventing the same repository, code clone, or algorithmic problem from appearing in both train and evaluation.

ATLAS isolates, for each natural language, min(20M tokens, 20% of available tokens) from MADLAD-400 and also evaluates on the external parallel FLORES set. Code-ATLAS will preserve that loss-test token target, but randomize over grouped repository components instead of individual sequences.

Required order of operations

1. Freeze every upstream artifact revision and capture its source metadata.
2. Normalize language labels without discarding the original label.
3. Apply the license policy and quality filters.
4. Compute exact content hashes across all sources.
5. Form near-duplicate file clusters across all sources and languages.
6. Form repository lineage components from forks, origin metadata, shared commit history when available, and high file-set similarity.
7. Attach task artifacts to an underlying problem family (for example HumanEval task ID or CodeNet problem ID), independent of programming language.
8. Construct a union graph whose edges are repository lineage, exact duplicate, near duplicate, or problem-family membership. A connected component is atomic.
9. Deterministically assign atomic components with frozen salt code-atlas-v1, minimizing relative target error jointly across language token vectors. Fill test quotas first and validation quotas second; never split a component.
10. Run a post-split contamination scan before publishing IDs or training.

Test surfaces

Held-out repository loss

Freeze one Code-ATLAS reference tokenizer and a byte/file-span manifest before splitting. For language l, let U_l be unique post-filter, post-dedup reference tokens. Target loss-test_l = min(20,000,000, 0.20 * U_l), matching ATLAS, and target loss-val_l = min(2,000,000, 0.10 * U_l) for checkpoint selection. Training gets the remainder. Group-boundary overshoot or undershoot is allowed and reported. Require at least three independent repository-lineage components or mark that language unsupported for three-way loss evaluation.

The frozen span manifest makes every model see identical text even if it uses a different tokenizer. Report bits per UTF-8 byte or ATLAS's cited vocabulary-insensitive loss, not raw tokenizer cross-entropy. Cap a single repo lineage at 1% of a language loss sample and bootstrap confidence intervals by repo-lineage ID.

Parallel semantic loss

Reserve complete problem families across languages. This is the code analogue of ATLAS's external parallel test, but it must never share an underlying task with parallel_aux training records.

Functional evaluation

Keep at least one executable benchmark artifact entirely untouched. Functional scores are secondary diagnostics; held-out loss is the primary scaling-law response.

For functional task corpora, create a cross-language problem_family_id before splitting, then assign complete families 70/10/20 to task-train/dev/test. All translations, solutions, tests, mutations, and same-problem judge submissions move together. Bootstrap reported scores by problem family, not translated row.

Temporal loss

Maintain a separately named post-cut loss-future panel. Its repository families must first appear after a preregistered cutoff according to trusted forge/archive time, with no earlier fork/clone ancestor, and must survive deduplication against pre-cut data. Never average loss-future into the ATLAS-comparable IID test.

Scaling-law fit holdouts

These are distinct from corpus splits. Reproduce ATLAS's fit tests: random 20% of run observations, top 20% of training-token horizons, selected scales at roughly 660M and 8B parameters, largest-compute observations, and unseen mixture configurations. ATLAS does not state a percentage for the largest-compute holdout; use its released run IDs if available or preregister a new rule and label it as a Code-ATLAS clarification. C=6ND applies to dense decoders; otherwise report measured FLOPs.

Non-negotiable leakage rules

• Never split by file alone.
• Never split translated rows of the same task across partitions.
• Never count repeated task translations as independent unique-code volume.
• Never duplicate a Nebius repository once per task row.
• Never allow a benchmark used for training to retain its standard benchmark name in reported evaluation results.
• Never assign a split before global cross-source deduplication.