tuandunghcmut/travelplanner-benchmark-normalized

TravelPlanner Benchmark (Normalized)

Normalized, typed, parquet-first packaging of the TravelPlanner benchmark for planning-centric agent evaluation.

• Upstream dataset: osunlp/TravelPlanner
• Upstream code: OSU-NLP-Group/TravelPlanner
• Paper: TravelPlanner: A Benchmark for Real-World Planning with Language Agents

1) What is included

This dataset repo contains:

1. benchmark config (train/validation/test) in typed parquet.
2. reference_entries config: flattened reference-info entries (attractions/restaurants/accommodations/flights/self-driving/taxi).
3. metadata files under metadata/:

• dataset_statistics.json
• parse_errors.parquet

2) Split sizes

• Train: 45
• Validation: 180
• Test: 1000

Total: 1225

3) Benchmark data schema (config: benchmark)

Columns:

• sample_id (int64)
• split (string)
• org, dest (string)
• days (int64)
• visiting_city_number (int64, nullable on test)
• dates (list)
• people_number (int64, nullable on test)
• local_constraint (struct, nullable on test)
  • house_rule (string)
  • cuisine (list)
  • room_type (string)
  • transportation (string)
• budget (int64, nullable on test)
• query (string)
• level (easy|medium|hard)
• reference_information (list)
  • description (string)
  • content (string)
• annotated_query_metadata (struct, only train)
• annotated_plan_days (list, only train)
• raw_* columns to preserve exact original serialized strings for reproducibility.

4) Ground truth / supervision availability

• Train: has annotated_plan (normalized into annotated_plan_days).
• Validation: does not provide annotated plan in upstream release.
• Test: does not provide annotated plan and omits several constraint fields.

5) Input/Output convention of the benchmark

Typical model input:

• query
• reference_information

Typical submission format (for evaluator):

{"idx": 1, "query": "...", "plan": [{...day entries...}]}

Reference example in upstream:

• postprocess/example_evaluation.jsonl

6) Evaluation metrics (from upstream code)

Evaluator source:

• evaluation/eval.py
• evaluation/commonsense_constraint.py
• evaluation/hard_constraint.py

Main reported metrics:

• Delivery Rate
• Commonsense Constraint Micro Pass Rate
• Commonsense Constraint Macro Pass Rate
• Hard Constraint Micro Pass Rate
• Hard Constraint Macro Pass Rate
• Final Pass Rate

6.1 High-level definitions

• Delivery Rate = fraction of samples with non-empty generated plan.
• Commonsense Micro = passed commonsense checks / total applicable commonsense checks.
• Commonsense Macro = fraction of samples passing all commonsense checks.
• Hard Micro = passed hard checks / total applicable hard checks.
• Hard Macro = fraction of samples passing all hard checks.
• Final Pass Rate = fraction of samples passing all commonsense + hard checks.

6.2 Pseudocode

for each sample i:
  plan_i = submission[i].plan

  if plan_i is empty:
    commonsense_i = None
    hard_i = None
  else:
    commonsense_i = eval_commonsense(query_i, plan_i)

    if commonsense_i passes preconditions:
      hard_i = eval_hard(query_i, plan_i)
    else:
      hard_i = None

aggregate pass/fail counts across constraints
compute micro and macro rates
compute final pass (all commonsense + all hard)

Note: upstream evaluator uses split-specific fixed denominators for headline reporting.

7) How this normalized release differs from upstream

Upstream columns such as date, local_constraint, annotated_plan, and reference_information are serialized Python literals stored as strings.

This normalized release parses them into typed nested columns while preserving raw originals via raw_* columns.

8) Load examples

8.1 Load normalized benchmark

from datasets import load_dataset

ds = load_dataset("tuandunghcmut/travelplanner-benchmark-normalized", "benchmark")
print(ds)
print(ds["train"][0].keys())

8.2 Load flattened reference entries

from datasets import load_dataset

ref = load_dataset("tuandunghcmut/travelplanner-benchmark-normalized", "reference_entries", split="train")
print(ref[0])

9) Suggested usage patterns

• Agent planning experiments using query + reference_information.
• Error analysis with per-constraint failure categories from evaluator output.
• Building retrieval/planning pipelines with flattened reference_entries.
• Constructing fine-tuning examples from train annotated_plan_days.

10) Reproducibility and provenance

• Source benchmark commit (code): 72d34bc (captured from local clone of upstream repo).
• Source dataset release: osunlp/TravelPlanner (train.csv/validation.csv/test.csv).
• Transformation scripts are included in this project under scripts/.

11) License, citation, and attribution

This normalized packaging follows upstream dataset license: CC-BY-4.0.

Please cite the original paper:

@inproceedings{xie2024travelplanner,
  title={TravelPlanner: A Benchmark for Real-World Planning with Language Agents},
  author={Xie, Jian and Zhang, Kai and Chen, Jiangjie and Zhu, Tinghui and Lou, Renze and Tian, Yuandong and Xiao, Yanghua and Su, Yu},
  booktitle={Forty-first International Conference on Machine Learning},
  year={2024}
}

12) Limitations

• The benchmark is primarily constraint-based; it does not directly score style/fluency quality.
• Validation/test do not expose full ground-truth plans.
• Some evaluation behavior depends on strict output formatting and parser robustness.