Datasets:
Download reports/verification_report.md from dsfasdfaserwer/Dataset: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/datasets/dsfasdfaserwer/Dataset/resolve/main/reports/verification_report.md
- Command line
-
hf download hf://datasets/dsfasdfaserwer/Dataset/reports/verification_report.md
-
curl -L -o verification_report.md https://huggingface.co/datasets/dsfasdfaserwer/Dataset/resolve/main/reports/verification_report.md
Verification Report — Dataset #1 (bigcode/self-oss-instruct-sc2-exec-filter-50k)
Date: 2026-10-03 · Environment: sandboxed Linux workspace, Python 3.11.2, 2 CPUs
1. Sandbox design (security & isolation, per §18)
Every candidate row's code was treated as untrusted and executed as follows:
- Fresh
tempfile.mkdtemp()working directory per row; removed after execution. subprocess.run([sys.executable, "-I", "-u", "run_tests.py"], env={"PATH": "/usr/bin:/bin:/usr/local/bin"}, stdin=DEVNULL).- Empty environment: no
HF_TOKEN, no home-dir variables, no credentials reachable by dataset code. The Hugging Face token lived only in an ephemeral/tmpfile outside the workspace and was never passed to any executed dataset code. -I: isolated mode (ignores user site-packages and env vars).
- Empty environment: no
preexec_fnresource limits:RLIMIT_CPU=10s,RLIMIT_AS=2GB,RLIMIT_NPROC=64,RLIMIT_FSIZE=8MB,RLIMIT_CORE=0.- Wall-clock timeout 8–12 s per row (
subprocess.TimeoutExpired→ kill → fail). - 2 parallel workers (
multiprocessing.Pool,maxtasksperchildrecycling), incremental append-only result logs (resumable; no retry loops — per §10 each row executed once per stage, plus at most 2 adjudication re-runs for failures). - Residual risk (documented): no network namespace was available; mitigated by the source's own upstream Docker execution filtering, small function-level payloads, and rlimits. One row (
check_and_create_dir('/home/user/my_directory')) attempted an absolute-path write outside its temp cwd; it was detected by non-deterministic re-verification and dropped (state-dependent test = also a quality defect).
2. Verification stages actually performed (by us)
| Stage | What ran | Rows | Passed | Failed |
|---|---|---|---|---|
| Parse & compile (AST) | ast.parse on every extracted code block |
50,661 | 49,687 solution-clean | 974 syntax-error blocks |
| Core execution | solution + released test block (or inline module-level asserts) | 1,059 | 1,046 (98.8%) | 13 |
| Repair re-execution | 7 fixture/bug repairs (Case A) | 7 | 7 | 0 |
| Derived execution | solution + tests extracted from instruction examples | 11,269 | 10,672 (94.7%) | 597 |
| Inline-split re-execution | 111 inline-assert rows; asserts extracted from code into tests, re-verified |
111 | 100 kept split | 11 kept inline (extraction unsafe) |
| Final artifact re-verification | exact shipped code + tests fields after all transformations |
10,315 | 10,308 | 7 (all randomness/state-dependent → dropped) |
| Post-drop invariant | shipped dataset = 100% execution-verified artifacts | 10,275 | 10,275 (100%) | 0 |
Dataset #2 stages (ise-uiuc/Magicoder-OSS-Instruct-75K, python subset)
| Stage | What ran | Rows | Passed | Failed |
|---|---|---|---|---|
| Parse & compile (AST) | every python-subset row parsed; code blocks AST-validated | 38,284 | 27,711 gate-pass | dep/no-solution/dup/syntax rejections |
| Sandbox execution | solution + derived/inline/released tests | 1,338 | 746 (55.8%) | 592 (369 assertion, 82 file-not-found, 63 name, 21 type, 16 attribute, 5 import, 3 timeout, 33 other) |
| Inline-split re-execution | module-level asserts extracted into tests where AST-safe |
69 kept | re-verified | — |
| Determinism double-run | every candidate final artifact executed twice; inconsistent → dropped | 675 | 673 | 2 flaky dropped |
| Final invariant | shipped Magicoder records | 673 | 673 (100%) | 0 |
Failure taxonomy
- Core 13 failures: 6 solution-contradicts-own-test →
rejected_incorrect(incl. a genuinely wrongis_prime(9), a duplicate-removal bug, aRuntimeError: dictionary keys changed during iteration); 7 FileNotFound → repaired with fixtures built from instruction-described file contents →accepted_after_fix. - Derived 597 failures: 437 AssertionError (solution inconsistent with the instruction's stated example, or conservative mis-extraction), 35 FileNotFound (file-based tasks without derivable fixtures), 34 NameError (instruction function name ≠ solution def), 27 TypeError, 63 other, 1 ImportError → all
rejected_unverifiable(we do not claim they are incorrect when the derivation itself could be the failing part — honest labeling). - Final re-verification 7 failures: flaky (
random-dependent asserts, set-ordering under strippedPYTHONHASHSEED, file-mtime ordering, pre-existing-directory state) →rejected_low_quality(non-deterministic tests are poor training signal).
3. Derived-test extraction (method & why it is sound)
Rows without released tests were accepted only when high-confidence tests could be extracted from the instruction itself:
- Pattern E — explicit assert blocks in the instruction ("Your code should pass the following assertions:
python assert f(...) == ..."). Each assert parsed withast.parse; kept only if every referenced name is a solution-defined function, a safe builtin, a safe stdlib module (auto-imported), or a literal assignment inside the same block. 9,467 rows. - Pattern A —
`fname(args)`calls in the instruction followed within 220 chars by== `lit`/ "returnslit" / "->lit"; args parsed via balanced-paren scan +ast.literal_eval; chained calls rejected; arity-checked against the solution signature; "either/or" ambiguity skipped. 866 rows. - Pattern C — "given
x = litandy = lit… returnslit" with strict arity match against the solution's single def. 714 rows. - Pattern F — single-def arity-1 "input … is
lit… should returnlit". 314 rows.
Every extracted literal passed ast.literal_eval (no arbitrary code from instruction text is ever executed beyond these validated asserts). Extraction is precision-first: ambiguous cases were skipped, and failed derivations reject the row rather than being retried or loosened (a mis-extraction almost always fails against the solution, i.e., errors degrade to rejection, not to false acceptance). Each record's verification.verification_method states exactly which mechanism applied.
Pattern G (added for Dataset #2, Magicoder-style problems): problems there commonly declare variables in a code block ("given the list of fields: python fields = [...]") and then state "the function call f(fields, "age") should return int". Pattern G collects assignment preludes from instruction code blocks (values must be literals or AST-validated safe expressions), then accepts calls whose arguments reference only prelude variables, whitelisted builtins, or a narrow safe-module set (math, datetime, statistics, string, fractions, decimal); expected values undergo the same AST safety validation (no lambdas/comprehensions/imports/arbitrary calls; arity-checked against the solution signature). Emitted tests = prelude assignments + assert statements. 604 Magicoder records were accepted via Patterns A/C/F/G-derived tests, 69 via inline module-level asserts.
4. Benchmark-contamination screening (§3 hard rule)
Screening corpora (downloaded for screening only — never added to the dataset):
- HumanEval (openai/openai_humaneval): 164 prompts
- MBPP (google-research-datasets/mbpp): full test 500 + full train 374 + validation 90 + sanitized 43 = 1,007 texts
- BigCodeBench v0.1.4 (bigcode/bigcodebench): 1,140 complete prompts
- DS-1000 (xlangai/DS-1000): 1,000 problem texts
Method: content-token containment + character-8-gram Jaccard with LSH candidate generation; boilerplate stopwords removed to avoid generic-phrasing false positives. Policy: when in doubt, exclude — both the auto-reject band and the manual-review band were excluded.
Results over the 11,725-row accepted pool (Dataset #1):
- HumanEval/MBPP screen: 842 auto-reject + 563 review-band → 1,405 rejected_benchmark (typical hits: instruction ≡ MBPP task "two lists share a common element", "largest prime factor", "longest increasing subsequence length", "gcd of two positive integers", "difference between sum of squares and square of sum").
- BigCodeBench/DS-1000 screen: 2 auto-reject + 3 review-band → 5 rejected_benchmark.
- Dataset #2 (Magicoder) 746-row passed pool: 71 rejected_benchmark (e.g. "find all prime numbers up to a given n" ≡ MBPP task; review-band folded into rejections under the same when-in-doubt policy).
- Total excluded for benchmark overlap across both datasets: 1,481.
- Not screened: LiveCodeBench (recent contest problems; our sources are OSS-function-derived — different provenance class; documented as residual risk), SWE-bench family (repo-level issues; structurally absent from these sources).
5. Token accounting (§12)
- Tokenizer:
tiktoken o200k_base(target training model unspecified; o200k_base used as a modern model-agnostic proxy — documented choice, not an estimate by character count). - Counted: the complete serialized JSON record (instruction + reasoning + code + tests + documentation + verification + quality + provenance).
- Result (Dataset #1): min 728 · p50 1,009 · mean 1,038 · p95 1,328 · max 2,675.
- Result (Dataset #2): min 891 · p50 1,159 · max 2,391.
- Combined repository: 0 records > 16,000 tokens;
over_16k/train.jsonlis intentionally empty.
6. Manual review (§8 individual assessment)
A stratified random sample of 40 accepted records (Dataset #1) and 20 accepted records (Dataset #2) was read end-to-end (instruction ↔ reasoning ↔ code ↔ tests ↔ documentation consistency). Findings:
- No fabricated or inconsistent reasoning observed; extracted rationales match the verified code.
- 2 systemic issues found and fixed globally: (a) instruction↔solution function-name mismatch → 33 rows dropped (
rejected_low_quality); (b) transition-sentence residue in reasoning/documentation ("Here is the implementation:") → cleaned in 4,943 records; 129 thin rationales replaced with factual AST-based summaries (taggedreasoning_generated_factual_summary_from_code; no fake monologue). - Minor, accepted-and-documented observations: 1 record retains a module-level demo
print(executes harmlessly); 2 records have loose spec naming ("extended Euclidean" implemented as plain Euclid; out-of-range behavior via IndexError instead of explicit raise) — both fully consistent with their stated tests. - Dataset #2 sample: consistent with gates; several solutions retain upstream demo blocks (
# Test the function ... print(...)) which execute harmlessly during verification and remain visible incode(no hidden behavior); Pattern-G prelude tests faithfully reproduce the problem's stated example values.
7. What we claim vs. what we don't (§22)
- VERIFIED_BY_US: every accepted record's
code+testsexecuted and passed in our sandbox (twice: at selection and post-transformation); all token counts; dedup; contamination screens; repairs. - DOCUMENTED (creators): upstream Docker execution filtering; OSS seed grounding (MultiPL-T/The Stack); pipeline peer-reviewed (NeurIPS'24).
- UNKNOWN: whether upstream decontamination (MBPP/DS-1000 scripts) was applied to the released file — mitigated by our own screening; per-row human review — none exists, so
human_verified=falseeverywhere. - Not claimed: exhaustiveness of derived tests (they encode instruction-stated examples only); semantic-level dedup; network isolation of the sandbox.