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
11.5 kB
| # 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 `/tmp` file outside the workspace and was never passed to any executed dataset code. | |
| - `-I`: isolated mode (ignores user site-packages and env vars). | |
| - `preexec_fn` resource 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`, `maxtasksperchild` recycling), 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 wrong `is_prime(9)`, a duplicate-removal bug, a `RuntimeError: 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 stripped `PYTHONHASHSEED`, 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: | |
| 1. **Pattern E** — explicit assert blocks in the instruction ("Your code should pass the following assertions: ```python assert f(...) == ...```"). Each assert parsed with `ast.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. | |
| 2. **Pattern A** — `` `fname(args)` `` calls in the instruction followed within 220 chars by `` == `lit` `` / "returns `lit`" / "-> `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. | |
| 3. **Pattern C** — "given `x = lit` and `y = lit` … returns `lit`" with strict arity match against the solution's single def. 714 rows. | |
| 4. **Pattern F** — single-def arity-1 "input … is `lit` … should return `lit`". 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.jsonl` is 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 (tagged `reasoning_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 in `code` (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`+`tests` executed 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=false` everywhere. | |
| - **Not claimed**: exhaustiveness of derived tests (they encode instruction-stated examples only); semantic-level dedup; network isolation of the sandbox. | |