README.md

metadata

license: mit
task_categories:
  - text-generation
tags:
  - code
  - benchmarks
  - combinatorial-optimization
  - llm-agents

FrontierCO: Benchmark Dataset for Frontier Combinatorial Optimization

Paper: CO-Bench: Benchmarking Language Model Agents in Algorithm Search for Combinatorial Optimization | Code: CO-Bench GitHub Repository

Overview

FrontierCO is a curated benchmark suite for evaluating ML-based solvers on large-scale and real-world Combinatorial Optimization (CO) problems. The benchmark spans 8 classical CO problems across 5 application domains, providing both training and evaluation instances specifically designed to test the frontier of ML and LLM capabilities in solving NP-hard problems.

Code for evaluating agent: https://github.com/sunnweiwei/CO-Bench?tab=readme-ov-file#evaluation-on-frontierco

Code for running classical solver, generating training data, evaluating neural solver: https://github.com/sunnweiwei/FrontierCO

---

Dataset Structure

Each subdirectory corresponds to a specific CO task:

FrontierCO/
├── CFLP/
│   ├── easy_test_instances/
│   ├── hard_test_instances/
│   ├── valid_instances/
│   └── config.py
├── CPMP/
├── CVRP/
├── FJSP/
├── MIS/
├── MDS/
├── STP/
├── TSP/
└── ...

Each task folder contains:

• easy_test_instances/: Benchmark instances that are solvable by SOTA human-designed solvers.
• hard_test_instances/: Instances that remain computationally intensive or lack known optimal solutions.
• valid_instances/ (if applicable): Additional instances for validation or development.
• config.py: Metadata about instance format, solver settings, and reference solutions.

---

Tasks Covered

The benchmark currently includes the following problems:

• MIS – Maximum Independent Set
• MDS – Minimum Dominating Set
• TSP – Traveling Salesman Problem
• CVRP – Capacitated Vehicle Routing Problem
• CFLP – Capacitated Facility Location Problem
• CPMP – Capacitated p-Median Problem
• FJSP – Flexible Job-shop Scheduling Problem
• STP – Steiner Tree Problem

Each task includes:

• Easy and hard test sets with varying difficulty and practical relevance
• Training and validation instances where applicable, generated using problem-specific generators
• Reference results for classical and ML-based solvers

---

Data Sources

Instances are sourced from a mix of:

• Public repositories (e.g., TSPLib, CVRPLib)
• DIMACS and PACE Challenges
• Synthetic instance generators used in prior ML and optimization research
• Manual curation from recent SOTA solver evaluation benchmarks

For tasks lacking open benchmarks, we include high-quality synthetic instances aligned with real-world difficulty distributions.

---

Usage

To use this dataset, clone the repository and select the task of interest. Each config.py file documents the format and how to parse or evaluate the instances.

git clone https://huggingface.co/datasets/CO-Bench/FrontierCO
cd FrontierCO/CFLP

Load a data instance

from config import load_data
instance = load_data('easy_test_instances/i1000_1.plc')
print(instance)

Generate a solution

# Your solution generation code goes here.
# For example:
solution = my_solver_func(**instance)

Evaluate a solution

from config import eval_func
score = eval_func(**instance, **solution)
print("Evaluation score:", score)

Using Agents on Custom Problems

Step 1: Include a concise description and a solve template. For example:

problem_description = '''The Traveling Salesman Problem (TSP) is a classic combinatorial optimization problem where, given a set of cities with known pairwise distances, the objective is to find the shortest possible tour that visits each city exactly once and returns to the starting city. More formally, given a complete graph G = (V, E) with vertices V representing cities and edges E with weights representing distances, we seek to find a Hamiltonian cycle (a closed path visiting each vertex exactly once) of minimum total weight.

Implement in Solve Function

def solve(**kwargs):
    """
    Solve a TSP instance.

    Args:
        - nodes (list): List of (x, y) coordinates representing cities in the TSP problem
                      Format: [(x1, y1), (x2, y2), ..., (xn, yn)]

    Returns:
        dict: Solution information with:
            - 'tour' (list): List of node indices representing the solution path
                           Format: [0, 3, 1, ...] where numbers are indices into the nodes list
    """

    return {
        'tour': [],
    }
'''

Step 2: Define the agent

from agents import GreedyRefine
agent = GreedyRefine(
    problem_description=problem_description,
    timeout=10,
    model='openai/o3-mini')

Step 3: Define the evaluate function and run the loop. Use the evaluate function to get results on the data, and iteratively improve the solution based on feedback:

evaluate = ...  # Define evaluate() to return score (float) and feedback (str)
# Run for 64 iterations
for it in range(64):
    code = agent.step()
    dev_score, dev_feedback = evaluate(code) # Define evaluate() to return score (float) and feedback (str)
    agent.feedback(dev_score, dev_feedback)

# Get the final soltuion
code = agent.finalize()
print(code)

Docker environment for sandboxed agent execution and solution evaluation: coming soon.

---

Citation

If you use FrontierCO in your research or applications, please cite the following paper:

@misc{feng2025comprehensive,
  title={A Comprehensive Evaluation of Contemporary ML-Based Solvers for Combinatorial Optimization},
  author={Shengyu Feng and Weiwei Sun and Shanda Li and Ameet Talwalkar and Yiming Yang},
  year={2025},
}

---

License

This dataset is released under the MIT License. Refer to LICENSE file for details.

---