Datasets:

Zhanli-Li
/

DataWorld-Bench

@@ -19,44 +19,37 @@ size_categories:
 <div align="center">
   <img src="assets/data-world-wordmark.svg" alt="DataWorld logo" width="480">
   <p><strong>Scaling Data Environments from Scratch</strong></p>
 </div>
 # DataWorld-Bench
-**A 100-task benchmark for agentic, evidence-grounded data analysis.**
-Each task drops an agent into a self-contained business world, hands it a
-multi-system pile of raw data, and asks for a conclusion that a strict LLM judge
-then grades against a task-specific rubric.
 The repository is laid out in the **harbor task format**: every task is a
 self-contained directory that can be built, run and verified on its own, with no
 shared state between tasks and no top-level dataset configuration.
-> **Code, task-generation pipeline and evaluation harness:**
-> **<https://github.com/Zhanli-Li/Data-World>**
-## Repository layout
 ```
 DataWorld-Bench/
-├── README.md
 ├── sample_manifest.json                          # metadata for the 100 tasks
 └── dataworld-pXXXXXX-<cause|consequence>-<1|2>/  # × 100 task directories
 ```
-- `pXXXXXX` is the id of the source world, `cause` / `consequence` is the task
-  kind (every world in this benchmark contributes exactly one of each), and the
-  trailing `1` / `2` is the variant index within that kind.
-- `sample_manifest.json` is a single flat JSON object describing the corpus:
-  name, status, size, and a `tasks` map with one entry per task directory.
-- A directory of task directories *is* the dataset — nothing else has to be
-  configured to point harbor (or any other harness) at this repository.
-## Task layout
 ```
 dataworld-pXXXXXX-<cause|consequence>-<1|2>/
-├── instruction.md            # the problem statement, data mapping, answer path
 ├── task.toml                 # harbor schema 1.1: timeouts, resources, artifacts
 ├── environment/
 │   ├── Dockerfile            # image recipe + COPY data/
@@ -70,196 +63,53 @@ dataworld-pXXXXXX-<cause|consequence>-<1|2>/
     └── judge.env             # judge credentials/endpoint (placeholders here)
 ```
-Each task carries **its own copy of the world's data**; nothing is mounted from
-a sibling task. There are no hidden files in a task directory, and the two files
-that would give the answer away (`WORLD.md`, `dag.json`) are deliberately absent
-from the corpus and asserted absent inside the image.
-### instruction.md
-Roughly 0.6–1.4 KB. It is the requester's own description of the
-business situation (what they think went wrong, which systems they got the
-numbers from, what decision the answer has to support) followed by two fixed
-lines found in all 100 tasks: a note that paths written as `env/…` in the text
-correspond to the files mounted at `/app/data/…`, and the answer path
-`/app/answer.txt`.
-Nothing in the instruction states the expected conclusion — the target node
-lives in `tests/rubric.json`, which the agent never sees.
-### environment/data/ — the world's files
-The data mirrors several independent systems of one synthetic business. Each
-task has **4–12 top-level subsystems** (mean ≈ 7), named after that world's
-systems; **237 distinct subsystem names** occur across the corpus, for example:
-```
-dataworld-p000014-cause-1/environment/data/
-├── master/     employees, ingredients, menu items, stations, suppliers, tables
-├── erp/        supplier_performance_monthly
-├── pos/        order_items, orders, reservations_daily, substitutions
-├── wms/        inventory_daily
-├── kds/        prep_batches, tickets
-├── hr/         attendance_log, shift_schedule
-├── feedback/   comment_cards_ocr, customer_reviews, quality_scores
-└── in_world/   kitchen_layout, standard_recipes
-```
-```
-dataworld-p000384-cause-1/environment/data/
-├── core_txn/   transactions_2018H1 … 2024H2, default_events, charge_off_records
-├── aml/        alerts, alert_transaction_links, cases, rule_configurations,
-│               rule_tuning_history, sar_filings, case_narratives/shard-00…10
-├── credit/     credit_assessments_scd2, credit_model_versions
-└── grc/        (governance/risk/compliance records)
-```
-Per task: **1.2 MB – 6.1 GB** (median ≈ 85 MB) and **8 – 10.6k files**
-(median ≈ 31); the whole repository is ≈ **50.2k files / 50.7 GB**, dominated by
-this raw data.
-| file type | what it usually holds |
-|---|---|
-| `.csv` / `.tsv` | the bulk of the tabular data — transactions, ledgers, master data, rosters, rule configurations, metric tables |
-| `.jsonl` | event streams and link tables — tickets, orders, alerts, substitutions, record-to-record links |
-| `.parquet` | the larger fact tables (e.g. daily inventory snapshots, multi-year transaction extracts) |
-| `.xlsx` | spreadsheets that arrive as attachments — planning sheets, audit workpapers |
-| `.txt` / `.md` / `.pdf` / `.html` | free-text evidence — policies, meeting notes, OCR'd cards, incident reports, web captures |
-| `.dat` + `.hdr` | binary sensor/telemetry recordings with sidecar header files |
-| `.hl7` | clinical messages (healthcare worlds) |
-| `.geojson` / `.log` / `.gz` | spatial layers, application logs, compressed exports |
-The counts are skewed by small documents; the bytes sit mostly in the tabular
-and binary files.
-### task.toml
-harbor `schema_version = "1.1"`. All 100 tasks use the same resource envelope:
-| key | value |
-|---|---|
-| `[agent]` | `timeout_sec = 28800.0` (8 h), `user = "agent"` |
-| `[verifier]` | `timeout_sec = 1200.0`, `user = "verifier"` |
-| `[environment]` | `cpus = 8`, `memory_mb = 16384`, `storage_mb = 10240`, `build_timeout_sec = 600.0`, `allow_internet = true` |
-| `[task]` | `name`, `description`, `authors`, `keywords` |
-| `[metadata]` | `category`, `difficulty`, `difficulty_explanation`, and the world/DAG shape: `world`, `dag_nodes`, `dag_edges`, `dag_category_id`, `dag_category_name` |
-`artifacts` at the top of the file is the run contract — what the platform
-collects into the trial directory after the verifier finishes:
-```
-/app/answer.txt                 # written by the agent
-/logs/verifier/reward.txt       # the scalar reward
-/logs/verifier/details.json     # per-criterion verdicts + diagnostics
-/logs/artifacts/                # everything the verifier chose to keep
-/logs/agent/trajectory.json     # the agent's own trajectory
-```
-### tests/rubric.json
-One rubric per task, four scalars plus a list of criteria:
-```json
-{
-  "world": "p000014",
-  "task_id": "cause_1",
-  "task_kind": "cause",
-  "target_node": "<the node of the world's causal graph this task asks about>",
-  "criteria": [
-    {"id": "dc-1", "section": "data_computation", "points": 4,
-     "criterion": "<a concrete computation a correct analysis must carry out>"},
-    {"id": "dc-8", "section": "data_computation", "points": -2,
-     "criterion": "<a plausible-looking path that leads to a wrong number>"}
-  ]
-}
-```
-- `section` is either `data_computation` (did you compute the right thing from
-  the right files) or `insight_discovery` (did you reach the right conclusion).
-- Positive `points` are what a correct analysis must establish; negative
-  `points` are wrong conclusions, or traps that a careless analysis falls into.
-- Across the corpus: **12–32 criteria per task** (mean ≈ 17.5), of which
-  **4–13 are negative**; the positive criteria of a rubric sum to 17–54 points
-  and the negative ones to −24 … −8.
 ## Scoring
-The judge returns **one verdict per criterion**:
-- positive criterion — `satisfied` earns its points, `not_satisfied` earns 0;
-- negative criterion — `triggered` deducts its points;
-- a conclusion the report never mentions neither earns nor loses points.
-The raw score is then normalized against that task's own reachable bounds:
 ```
 reward = 100 * (raw - lo) / (hi - lo)        # in [0, 100]
 ```
-where `hi` is the total of the positive criteria and `lo` the total of the
-negative ones. So **all positive criteria satisfied = 100**, **all negative
-criteria triggered = 0**.
-Two edge cases matter when you aggregate results:
-- **A missing or empty `/app/answer.txt`** is treated as a blank submission:
-  reward is forced to `0` (the rubric floor) regardless of the rubric's negative
-  share.
-- **A grading-infrastructure failure** (judge unreachable, unparseable verdicts)
-  is *not* expressed through the score. `details.json` then carries a
-  `judge_error` key and the reward is written as `0`. Since `0` is also a
-  legitimate score, **detect failures via `judge_error`, never via the value** —
-  otherwise a broken judge silently reads as a task the model failed.
-Earlier reported results used a `[-1, 1]` normalization; convert with
-`r_[-1,1] = reward / 50 - 1`.
 ## Running a task
-Install `docker`, then for each task:
-1. build the image from `environment/Dockerfile` — it builds on the public
-   `quay.io/jupyter/scipy-notebook` image (see below), `COPY data/ /app/data/`,
-   creates the `agent` and `verifier` users declared in `task.toml`, and asserts
-   that no ground-truth material is present in the image;
-   the container is meant to be started and then driven with `docker exec`;
-2. run the agent as the `agent` user; it must leave its report at
-   `/app/answer.txt`;
-3. run `tests/test.sh` as the `verifier` user — it sources `tests/judge.env`,
-   grades `/app/answer.txt` and writes `reward.txt` + `details.json`.
-`tests/judge.env` selects the judge gateway and model through ordinary
-environment variables, so the same task directory works against any endpoint
-that speaks the OpenAI-compatible or Anthropic Messages protocol:
-```
-ANTHROPIC_BASE_URL   # gateway base URL
-ANTHROPIC_AUTH_TOKEN # gateway token
-ANTHROPIC_MODEL      # judge model id
-```
-The file ships with placeholders (`<your-judge-token>`, `<judge-gateway>`,
-`<judge-model-path-or-id>`) — fill in your own endpoint and token before running.
-`environment/Dockerfile` needs no such placeholders. It builds from
-`quay.io/jupyter/scipy-notebook`, pinned to a dated tag: a public Python
-(conda-forge) environment that already ships the data-science stack these tasks
-use — pandas, numpy, scipy, statsmodels, scikit-learn, matplotlib, h5py,
-openpyxl, pytables, dask — and pulls the remaining analysis packages (pyarrow,
-pypdf, pillow) from public PyPI on top. Any image carrying `python3`/`pip` can be
-substituted: the apt and pip steps probe for existence first and skip whatever is
-already installed.
-`judge.py` prefers `JUDGE_*` over `ANTHROPIC_*` when both are set, streams the
-request (so a long judgment is never killed by a total-time timeout) and falls
-back to `judge_error` rather than crashing. The full evaluation harness lives in
-[Data-World](https://github.com/Zhanli-Li/Data-World).
 ## License
 Released under the **Apache License 2.0** — see [`LICENSE`](LICENSE).
-## Citation
-If you use DataWorld-Bench, please link
-<https://github.com/Zhanli-Li/Data-World> and this dataset card.

 <div align="center">
   <img src="assets/data-world-wordmark.svg" alt="DataWorld logo" width="480">
   <p><strong>Scaling Data Environments from Scratch</strong></p>
+  <p>Specify the world behind the files. Generate the data. Ground the supervision.</p>
+  <p>
+    <a href="https://zhanli-li.github.io/Data-World/"><img src="https://img.shields.io/badge/Project%20Page-579187?style=flat-square" alt="Project Page"></a>
+    <a href="https://huggingface.co/collections/Zhanli-Li/dataworld"><img src="https://img.shields.io/badge/Hugging%20Face-FFD21E?style=flat-square&logo=huggingface&logoColor=black" alt="Hugging Face Collection"></a>
+    <a href="https://arxiv.org/abs/2610.21656"><img src="https://img.shields.io/badge/Paper-arXiv-6686A6?style=flat-square" alt="Paper on arXiv"></a>
+    <a href="https://github.com/Zhanli-Li/Data-World"><img src="https://img.shields.io/badge/Code-GitHub-181717?style=flat-square&logo=github&logoColor=white" alt="Code on GitHub"></a>
+  </p>
 </div>
 # DataWorld-Bench
+**A 100-task benchmark for agentic, evidence-grounded data analysis.** Each task
+drops an agent into a self-contained business world, hands it a multi-system pile
+of raw data, and asks for a conclusion that a strict LLM judge then grades against
+a task-specific rubric.
+## Format
 The repository is laid out in the **harbor task format**: every task is a
 self-contained directory that can be built, run and verified on its own, with no
 shared state between tasks and no top-level dataset configuration.
 ```
 DataWorld-Bench/
 ├── sample_manifest.json                          # metadata for the 100 tasks
 └── dataworld-pXXXXXX-<cause|consequence>-<1|2>/  # × 100 task directories
 ```
 ```
 dataworld-pXXXXXX-<cause|consequence>-<1|2>/
+├── instruction.md            # problem statement, data mapping, answer path
 ├── task.toml                 # harbor schema 1.1: timeouts, resources, artifacts
 ├── environment/
 │   ├── Dockerfile            # image recipe + COPY data/
     └── judge.env             # judge credentials/endpoint (placeholders here)
 ```
+- `pXXXXXX` is the id of the source world, `cause` / `consequence` is the task
+  kind (every world contributes exactly one of each), and the trailing `1` / `2`
+  is the variant index within that kind.
+- Each task carries **its own copy of the world's data** — 4–12 subsystems
+  (mean ≈ 7), 1.2 MB – 6.1 GB (median ≈ 85 MB) and 8 – 10.6k files
+  (median ≈ 31); the whole repository is ≈ 50.2k files / 50.7 GB.
+- The two files that would give the answer away (`WORLD.md`, `dag.json`) are absent
+  from the corpus and asserted absent inside the image.
+`task.toml` is `schema_version = "1.1"` with one resource envelope for all 100
+tasks: `[agent] timeout_sec = 28800.0` (8 h), `[verifier] timeout_sec = 1200.0`,
+`[environment] cpus = 8`, `memory_mb = 16384`, `storage_mb = 10240`,
+`allow_internet = true`.
 ## Scoring
+The judge returns one verdict per rubric criterion — `satisfied` /
+`not_satisfied` for positive points, `triggered` for negative ones — and the raw
+score is normalized against that task's own reachable bounds:
 ```
 reward = 100 * (raw - lo) / (hi - lo)        # in [0, 100]
 ```
+So all positive criteria satisfied = **100**, all negative criteria triggered = **0**.
+Two edge cases matter when aggregating: a missing or empty `/app/answer.txt` is a
+blank submission and scores `0`; a grading-infrastructure failure *also* writes `0`
+but carries a `judge_error` key in `details.json` — **detect failures via
+`judge_error`, never via the value**.
 ## Running a task
+Build the image from `environment/Dockerfile`, run the agent as user `agent` (its
+report must land at `/app/answer.txt`), then run `tests/test.sh` as user
+`verifier`. `tests/judge.env` selects the judge through ordinary environment
+variables (`ANTHROPIC_BASE_URL` / `ANTHROPIC_AUTH_TOKEN` / `ANTHROPIC_MODEL`, or
+the `JUDGE_*` equivalents); it ships with placeholders. The Dockerfile builds on
+the public `quay.io/jupyter/scipy-notebook` image, pinned to a dated tag, and needs
+no configuration.
+## Links
+- Project page — <https://zhanli-li.github.io/Data-World/>
+- Paper — <https://arxiv.org/abs/2610.21656>
+- Code, data generation pipeline and evaluation harness — <https://github.com/Zhanli-Li/Data-World>
+- Full collection — <https://huggingface.co/collections/Zhanli-Li/dataworld>
 ## License
 Released under the **Apache License 2.0** — see [`LICENSE`](LICENSE).