---
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}
}
```