Datasets:

Muse-research
/

ifparse-v1.0

@@ -1,266 +1,99 @@
 ---
 language:
 - en
-license: mit
-task_categories:
-- text-generation
 tags:
-- text-generation
 - instruction-following
-- structured-outputs
 - evaluation
-- json
-- llm-eval
 - edge-ai
-- benchmark
-pretty_name: "ifparse-v1.0: Instruction-Following Parsing Benchmark"
 size_categories:
 - 1K<n<10K
 configs:
 - config_name: ifparse-all
   data_files:
-    - split: test
-      path: "data/all/*.jsonl"
 - config_name: ifparse-syslog
   data_files:
-    - split: test
-      path: "data/syslog/*.jsonl"
 - config_name: ifparse-weblog
   data_files:
-    - split: test
-      path: "data/weblog/*.jsonl"
-dataset_info:
-  features:
-    - name: id
-      dtype: string
-    - name: source_type
-      dtype: string
-    - name: raw_log
-      dtype: string
-    - name: schema
-      dtype: string
-    - name: prompt
-      dtype: string
-  splits:
-    - name: test
-      num_examples: 1000
-  download_size: null
-  dataset_size: null
----
-# ifparse-v1.0: Instruction-Following Parsing Benchmark
-> **A brutal, binary, zero-partial-credit stress test for structured extraction under real-world developer log conditions.**
-## Introduction & Summary
-**ifparse-v1.0** is a high-precision benchmark designed to answer a single, deceptively hard question:
-> *Can a language model reliably turn messy, unstructured server logs into clean, schema-compliant JSON — with no wrapper text, no markdown fences, and no filler?*
-This is not a benchmark about reasoning, knowledge, or creativity. It is a benchmark about **compliance**. In production data pipelines — log ingestion, ETL preprocessing, observability tooling, security auditing — the value of an LLM's output is not "is it roughly right," it's "did it parse." A JSON blob wrapped in ` ```json ` fences, prefixed with *"Sure! Here's the structured data you requested:"*, or missing a single required key is not a partial success. It's a **pipeline failure**.
-ifparse-v1.0 evaluates this failure mode directly, using **1,000 tasks** built from two categories of real developer telemetry:
-- **500 web log tasks** — sourced from Apache access log records (HTTP methods, status codes, byte counts, user agents, timestamps)
-- **500 syslog tasks** — sourced from Linux kernel and system log records (PIDs, facility/severity levels, service names, kernel messages)
-Every task asks the model to convert one raw, unstructured log line (or short block) into a JSON object that strictly matches a provided schema — nothing more, nothing less. Every task is graded **binary**: 0 or 1. There is no partial credit, no fuzzy string matching, no leniency for "close enough."
-As edge-AI and sub-1B parameter models proliferate into automated pipelines where no human reviews every output, **steerability under strict formatting constraints becomes a first-class capability** — arguably more important than raw benchmark intelligence. ifparse-v1.0 exists to measure exactly that, and to expose how far the current generation of compact models still has to go.
----
-## Why It Is Hard
-ifparse-v1.0 is difficult by design, and the difficulty is intentional and structural, not incidental.
-### 1. Absolute binary grading — no mercy, no averaging
-Each of the five metrics below is scored strictly as `0` or `1` per task. A response that is 95% of the way to a perfect JSON object — correct keys, correct values, but wrapped in a single pair of triple backticks — scores **zero** on `No Fences` and **zero** on the composite `Perfect Score`. There is no token-level overlap scoring, no BLEU/ROUGE softening, no "partial credit for effort." This mirrors exactly how a real `json.loads()` call in a production pipeline behaves: it either parses, or it throws.
-### 2. Pre-training habits work against the model
-Most LLMs — especially compact and instruction-tuned models distilled from chat-style corpora — have seen enormous volumes of markdown-formatted code during pre-training. The reflex to wrap *any* code-shaped output in ` ``` ` fences is deeply baked in. Suppressing this reflex on command requires genuine instruction-following precision, not just "knowing" what JSON looks like.
-### 3. RLHF habits work against the model
-Chat-tuned models are heavily reinforced toward being conversational, helpful-sounding, and hedging. This produces exactly the kind of output that breaks automated parsers: *"Certainly! Here is the JSON object you requested:"*, *"I hope this helps!"*, or *"Let me know if you need anything else."* These habits are rewarded in open-ended chat evaluation and actively punished in ifparse, creating a genuine tension the model must resolve correctly, every single time.
-### 4. Schema strictness punishes "close enough" typing
-Even when a model gets the structure, keys, and fences right, it frequently fails on **type fidelity** — returning `"status_code": "200"` instead of `"status_code": 200`, or violating enum constraints on severity/facility fields. ifparse enforces strict type casting and enum validation as part of `Schema Match`, catching a failure mode that looser evaluation harnesses routinely miss.
-### 5. Compounding failure probability
-Because `Perfect Score` requires **all four** constraints to hold simultaneously, and each constraint has its own independent failure rate, the compounded probability of a fully clean output collapses quickly for weaker models. This is exactly what the baseline results below demonstrate.
----
-## The 5 Core Evaluation Tasks
-Each task in ifparse-v1.0 is scored against five metrics. Four are independent, atomic checks; the fifth is the composite pass/fail gate.
-### 🏆 Perfect Score
-The headline metric. A task is marked `1` **only if** the model's output simultaneously satisfies `Valid JSON`, `No Fences`, `No Filler`, and `Schema Match`. This is the true measure of production-readiness: a single violation of any kind fails the entire task. This is the number that matters most for real-world deployment decisions.
-### ✅ Valid JSON
-The raw output string, after standard backtick-trimming (a permissive pre-processing step to be fair to models that only fail on fences), must parse cleanly via `json.loads()` (or an equivalent strict parser). Malformed brackets, trailing commas, unescaped quotes, or truncated output all result in a `0`.
-### 🚫 No Fences
-The **raw, untrimmed** output must not contain triple-backtick code fences (` ``` ` or ` ```json `) anywhere in the string. This metric is checked prior to any pre-processing and captures the model's raw formatting discipline — the trimming step used for `Valid JSON` does not "forgive" a fence violation here.
-### 🗣️ No Filler
-The output must contain **only** the JSON object — no prepended acknowledgments, no appended offers of further help, no explanatory preamble. Any conversational token outside the JSON payload (e.g., *"Here is the extracted data:"*, *"I've parsed the log for you!"*) results in a `0`.
-### 🧩 Schema Match
-The parsed JSON object must contain **exactly** the mandatory keys defined in the task schema (no missing keys, no hallucinated extras unless explicitly marked optional), with **correct type casting** (integers must be integers, not stringified numbers) and adherence to any **enum restrictions** (e.g., HTTP methods restricted to `GET/POST/PUT/DELETE/...`, syslog severities restricted to their defined integer range).
 ---
-## Baseline Leaderboard
-The results below establish just how unforgiving ifparse-v1.0 is, even for a capable-on-paper compact model. **LiquidAI/LFM2.5-230M** was evaluated across all 1,000 tasks with zero-shot prompting and no output post-processing beyond the standard backtick-trim step applied uniformly to all models.
-| Model Name | Perfect Score | Valid JSON | No Fences | No Filler | Schema Match |
-|---|---|---|---|---|---|
-| `LiquidAI/LFM2.5-230M` | **0.00%** | 0.00% | 36.20% | 0.00% | 0.00% |
-**Reading the result:** At 230M parameters, the model was unable to produce a single fully compliant output across 1,000 attempts. It succeeded in avoiding markdown code fences just over a third of the time, but failed **every single task** on `Valid JSON`, `No Filler`, and `Schema Match` — meaning even the outputs that avoided fences were still contaminated by conversational text, malformed structure, or type/schema violations. This is the "brutal reality" ifparse-v1.0 is built to surface: compact models that look adequate on general-purpose leaderboards can be **completely non-functional** as drop-in components in an automated structured-data pipeline.
-*(Leaderboard submissions from additional models — including larger and instruction-hardened variants — are welcome. See the repository for submission format.)*
----
-## Task Schemas & Examples
-ifparse-v1.0 tasks are drawn from two source domains, each with its own schema and constraint set. Below is a representative example of each.
-### Example 1: Syslog Task
-**Unstructured source context (`raw_log`):**
-```
-Jun 14 03:22:11 prod-worker-04 kernel: [148213.902211] CPU3: Core temperature above threshold, cpu clock throttled (total events = 12)
-```
-**Strict JSON schema constraint:**
-```json
-{
-  "type": "object",
-  "required": ["timestamp", "hostname", "process", "pid", "severity", "message"],
-  "properties": {
-    "timestamp": { "type": "string" },
-    "hostname": { "type": "string" },
-    "process": { "type": "string" },
-    "pid": { "type": ["integer", "null"] },
-    "severity": { "type": "integer", "enum": [0, 1, 2, 3, 4, 5, 6, 7] },
-    "message": { "type": "string" }
-  },
-  "additionalProperties": false
-}
-```
-**Strict compliance rules for this task:**
-- `pid` must be `null` (not the string `"null"` or omitted) when no PID is present in the raw line — kernel messages frequently lack a PID.
-- `severity` must be inferred and cast as an **integer** per standard syslog severity levels (0=Emergency … 7=Debug); a string like `"warning"` fails `Schema Match`.
-- `hostname` must be extracted exactly as written (`prod-worker-04`), with no normalization or guessing.
-- The entire response must be the raw JSON object only — no ` ```json ` fence, no leading/trailing prose.
-### Example 2: Web Log Task
-**Unstructured source context (`raw_log`):**
-```
-203.0.113.44 - - [14/Jun/2026:03:22:11 +0000] "POST /api/v2/checkout HTTP/1.1" 502 331 "-" "Mozilla/5.0 (compatible; internal-healthcheck/1.2)"
-```
-**Strict JSON schema constraint:**
-```json
-{
-  "type": "object",
-  "required": ["ip_address", "timestamp", "method", "path", "status_code", "bytes_sent", "user_agent"],
-  "properties": {
-    "ip_address": { "type": "string" },
-    "timestamp": { "type": "string" },
-    "method": { "type": "string", "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] },
-    "path": { "type": "string" },
-    "status_code": { "type": "integer" },
-    "bytes_sent": { "type": "integer" },
-    "user_agent": { "type": "string" }
-  },
-  "additionalProperties": false
-}
 ```
-**Strict compliance rules for this task:**
-- `status_code` and `bytes_sent` must be cast as **integers**, not the quoted strings that appear in the raw Apache log line.
-- `method` must exactly match one of the defined enum values — case-sensitive, no lowercase `"post"`.
-- Absent or `"-"` fields (like the referrer, which is not part of this schema) must simply be excluded — the model must not hallucinate extra keys.
-- No conversational wrapper of any kind is permitted, even a single trailing newline followed by an offer to help further.
----
-## How to Run / Evaluate
-ifparse-v1.0 is designed to be evaluated with a lightweight, dependency-free harness. The recommended flow:
-1. **Sequential inference.** Run each of the 1,000 prompts through the target model with a fixed decoding configuration (recommended: temperature `0`, or low temperature with fixed seed, for reproducibility). Do not apply any output post-processing at generation time — capture the raw string exactly as emitted.
-2. **`No Fences` check (raw string).** Run a regex search for triple-backtick sequences (`` ```(?:json)?\s*[\s\S]*?``` ``) against the **untrimmed** raw output. Presence of a match → `0` on `No Fences`.
-3. **Backtick-trim, then `Valid JSON` check.** Apply a standard, uniform trimming step (strip leading/trailing ` ``` ` or ` ```json ` markers and surrounding whitespace only — no deeper cleaning) and attempt `json.loads()` on the result. Parse failure → `0` on `Valid JSON`.
-4. **`No Filler` check.** After trimming, verify that the *entire* remaining string is consumed by a single valid JSON value — i.e., there is no non-whitespace content before the opening `{` or after the closing `}`. Any leftover text → `0` on `No Filler`.
-5. **`Schema Match` check.** Validate the parsed JSON object against the task's schema (JSON Schema `Draft 7`+ compatible validators such as Python's `jsonschema` library are recommended). Check required keys, `additionalProperties: false`, type casting, and enum membership. Any violation → `0` on `Schema Match`.
-6. **`Perfect Score` aggregation.** A task scores `1` on `Perfect Score` if and only if all four checks above returned `1`. Report each metric as a simple percentage over the full 1,000-task set (or per-subset, using the `ifparse-syslog` / `ifparse-weblog` configs, for domain-specific breakdowns).
-```python
-import json
-import re
-from jsonschema import validate, ValidationError
-def evaluate(raw_output: str, schema: dict) -> dict:
-    results = {"valid_json": 0, "no_fences": 0, "no_filler": 0, "schema_match": 0, "perfect_score": 0}
-    # 1. No Fences (checked on raw, untrimmed output)
-    if not re.search(r"```", raw_output):
-        results["no_fences"] = 1
-    # 2. Trim + Valid JSON
-    trimmed = re.sub(r"^```(?:json)?\s*|\s*```$", "", raw_output.strip())
-    try:
-        parsed = json.loads(trimmed)
-        results["valid_json"] = 1
-    except json.JSONDecodeError:
-        parsed = None
-    # 3. No Filler (entire trimmed string must be exactly the JSON value)
-    if parsed is not None and trimmed.strip() == json.dumps(parsed):
-        results["no_filler"] = 1
-    elif parsed is not None:
-        # Fallback: re-serialize check is strict; consider a whitespace-normalized compare
-        results["no_filler"] = 1 if trimmed.strip().startswith("{") and trimmed.strip().endswith("}") else 0
-    # 4. Schema Match
-    if parsed is not None:
-        try:
-            validate(instance=parsed, schema=schema)
-            results["schema_match"] = 1
-        except ValidationError:
-            pass
-    # 5. Perfect Score
-    if all([results["valid_json"], results["no_fences"], results["no_filler"], results["schema_match"]]):
-        results["perfect_score"] = 1
-    return results
-```
----
-## Closing Note
-Passing ifparse-v1.0 at a high `Perfect Score` rate is not a vanity metric — it is a direct proxy for whether a model can be trusted as an **unattended component in an automated pipeline**. For edge-AI and sub-1B parameter models in particular, where deployment scenarios often preclude a full agentic retry loop or heavy output-sanitization middleware, achieving strong steerability on this benchmark represents a genuine, practical milestone: the difference between a model that *assists* a human and a model that can *run unsupervised*.
-We encourage the community to submit evaluation results for additional models — especially instruction-hardened, structured-output-tuned, and function-calling-specialized variants — to build out a fuller picture of where the field currently stands.

 ---
+pretty_name: ifparse v1.0
 language:
 - en
 tags:
+- structured-output
+- json
 - instruction-following
+- schema-following
 - evaluation
 - edge-ai
+task_categories:
+- text-generation
 size_categories:
 - 1K<n<10K
 configs:
 - config_name: ifparse-all
   data_files:
+  - split: test
+    path: data/all/*.jsonl
 - config_name: ifparse-syslog
   data_files:
+  - split: test
+    path: data/syslog/*.jsonl
 - config_name: ifparse-weblog
   data_files:
+  - split: test
+    path: data/weblog/*.jsonl
+license: mit
 ---
+# ifparse v1.0
+IFParse is a benchmark for structured extraction from real developer logs: can a model turn a raw, unstructured log line into JSON that satisfies a fixed schema, with no code fence, no commentary, and no type errors. Scoring is binary and covers only compliance, not extraction creativity, so the signal is isolated to whether the output would actually parse in a production pipeline.
+Each prompt gives the model a single raw log line, either an Apache access log record or a Linux syslog/kernel record, and asks for one JSON object matching the associated schema. A response passes a task only if it clears every constraint simultaneously; there is no partial credit.
+This dataset is the frozen public test set: **1,000 prompts** (500 syslog, 500 weblog) with the ground-truth schema each response is validated against.
+## Dataset structure
+One row per prompt. Fields after `prompt` are the ground-truth spec the validator checks a response against; there are no gold responses, since scoring is done by a validator rather than by comparison to a reference output.
+| Field | Type | Description |
+| :---- | :--- | :---------- |
+| `id` | string | Stable identifier. |
+| `source_type` | string | `syslog` or `weblog`. |
+| `raw_log` | string | The unstructured log line shown to the model. |
+| `prompt` | string | The full request shown to the model, including formatting instructions. |
+| `schema` | string (JSON) | The JSON Schema the output must satisfy (required keys, types, enums). |
+`schema` is stored as a JSON-encoded string and should be parsed with `json.loads`.
+```python
+from datasets import load_dataset
+import json
+ds = load_dataset("Muse-research/ifparse-v1.0", "ifparse-all", split="test")
+row = ds[0]
+schema = json.loads(row["schema"])
 ```
+## Scoring
+Every response is checked against four constraints, and a fifth composite metric requires all four to pass:
+- **valid_json** — the response, after trimming any code fence, parses under `json.loads`.
+- **no_fences** — the raw, untrimmed response contains no triple-backtick fence.
+- **no_filler** — nothing outside the JSON object itself (no preamble, no closing remark).
+- **schema_match** — exactly the required keys, correct types, and correct enum values, with no invented fields.
+- **perfect_score** — all four of the above hold at once.
+A reference validator implementing these checks is in the eval repo linked above.
+## Baseline
+| Model | perfect_score | valid_json | no_fences | no_filler | schema_match |
+| :---- | :---: | :---: | :---: | :---: | :---: |
+| LiquidAI/LFM2.5-230M | 0.00% | 0.00% | 36.20% | 0.00% | 0.00% |
+At 230M parameters, the model failed valid_json, no_filler, and schema_match on every single task, and avoided code fences on only about a third of them. Community submissions from other models are welcome.
+## How the data was generated
+Raw log lines are drawn from real Apache access logs and Linux syslog/kernel output. Each line is paired with a hand-written JSON Schema covering the fields a downstream pipeline would actually need (timestamps, status codes, PIDs, severities, and similar), including required type casting and enum constraints where the source format supports them. Prompts explicitly instruct the model to return only the JSON object, with no fencing and no surrounding text, so that failures reflect formatting discipline rather than ambiguous instructions.
+## Limitations
+Only structural and formatting compliance is checked, not the semantic accuracy of extracted values beyond type and enum validity — a response can misread a field and still pass if the resulting value satisfies the schema's type and enum constraints. Pair with a separate accuracy check if field-level correctness matters for your use case.
+## Citation
+```yaml
+@article{museresearch2026ifparse,
+    author = {Muse Research},
+    title = {ifparse: A binary benchmark for structured log extraction},
+    year = {2026}
+}
+```