Upload folder using huggingface_hub

README.md

@@ -1,3 +1,209 @@
----
-license: apache-2.0
----
+# Benchmark Problems
+
+## Overview
+
+This benchmark is adapted from [**ReEvo**](https://ai4co.github.io/reevo/)[1], which originally consists of six types of combinatorial optimization problems (COPs). We have extended the benchmark by adding a cooperative driving problem that involves complex simulation environments using [SUMO](https://eclipse.dev/sumo/).
+
+## Table of Contents
+
+1. [Types of Functions to Evolve](#types-of-functions-to-evolve)
+2. [Problem Details](#problem-details)
+3. [How to Customize Your Own Benchmark](#how-to-customize-your-own-benchmark)
+4. [References](#references)
+
+## Types of Functions to Evolve
+
+The functions to evolve are categorized into three groups:
+
+### Classical Metaheuristics (ACO / GA / GLS)
+- **Ant Colony Optimization (ACO)**[2]: Evolve ACO heuristic components, such as the computation of desirability and pheromone guidance.
+- **Guided Local Search (GLS)**[3]: Evolve the penalty heuristic that guides perturbations during GLS.
+- **Genetic Algorithm (GA)**[4]: Evolve GA-related operators and heuristics (the domain-specific logic within the GA pipeline, as defined by the problem wrapper).
+
+### Attention Reshaping in Neural Combinatorial Optimization (POMO / LEHD)
+- **Policy Optimization with Multiple Optima (POMO)**[5]: A reinforcement learning training and inference framework for neural constructive solvers that exploits symmetry and uses multiple rollouts from different starting conditions to stabilize and improve solution quality. We evolve attention reshaping heuristics inserted into the neural solver (not the model weights). For POMO settings, download checkpoints from the [official repository](https://github.com/yd-kwon/POMO) and place them in the corresponding directories (e.g., place `checkpoint-3100.pt` for TSP at `problems/tsp_pomo/checkpoints/checkpoint-3100.pt`).
+
+- **Neural Combinatorial Optimization with Light Encoder, Heavy Decoder (LEHD)**[6]: This approach shifts modeling capacity into the decoder while keeping the encoder lightweight, aiming for better generalization and scaling in constructive routing solvers. We evolve attention reshaping heuristics. For LEHD settings, download checkpoints and data from the [official repository](https://github.com/CIAM-Group/NCO_code/tree/main/single_objective/LEHD) and place them in the corresponding directories.
+
+### Direct Solution Construction Heuristics
+We can evolve functions that directly construct solutions. For example:
+- For online bin packing problems, evolve the function that generates priority scores for each bin; the solver then selects the bin with the highest priority.
+- For cooperative driving problems, evolve the function that generates actions for all drivers.
+
+
+## Problem Details
+
+The benchmark problems are stored at `[project_root]/problems`. Detailed descriptions of each problem are provided below.
+
+### Traveling Salesman Problems (TSPs)
+The Traveling Salesman Problem (TSP) is a classic optimization challenge that seeks the shortest possible route for a salesman to visit each city in a list exactly once and return to the origin city.
+
+- **TSP via Ant Colony Optimization (`tsp_aco`)**: Find the shortest path that visits all given nodes and returns to the starting node. ACO implementations are adapted from [DeepACO](https://github.com/henry-yeh/DeepACO)[2].
+- **TSP via Guided Local Search (`tsp_gls`)**: Use Guided Local Search (GLS)[3] to find the shortest path.
+- **TSP via LEHD (`tsp_lehd`)**: Use LEHD[6] to find the shortest path.
+- **TSP via POMO (`tsp_pomo`)**: Use POMO[5] to find the shortest path.
+- **TSP via Constructive Routing Solvers (`tsp_constructive`)**: Evolve functions that directly construct solutions for TSP.
+
+### Capacitated Vehicle Routing Problems (CVRPs)
+The Capacitated Vehicle Routing Problem (CVRP) extends the TSP by adding constraints on vehicle capacity. Each vehicle can carry a limited load, and the objective is to minimize the total distance traveled while delivering goods to various locations.
+
+- **CVRP via Ant Colony Optimization (`cvpr_aco`)**: Solve CVRP using Ant Colony Optimization (ACO)[2].
+- **CVRP via LEHD (`cvpr_lehd`)**: Solve CVRP using LEHD[6].
+- **CVRP via POMO (`cvpr_pomo`)**: Solve CVRP using POMO[5].
+
+### Bin Packing Problems (BPPs)
+The Bin Packing Problem requires packing objects of different volumes into a finite number of bins or containers of fixed volume to minimize the number of bins used. This problem is widely applicable in manufacturing, shipping, and storage optimization.
+
+- **BPP via Ant Colony Optimization (`bpp_offline_aco`)**
+- **Online BPP (`bpp_online`) via Priority Score Heuristics**
+
+### Orienteering Problems (OPs)
+In the Orienteering Problem (OP), the goal is to maximize the total score collected by visiting nodes while subject to a maximum tour length constraint.
+
+- **OP for Routing Problems via Ant Colony Optimization (`op_aco`)**
+
+### Multiple Knapsack Problems (MKPs)
+The Multiple Knapsack Problem (MKP) involves distributing a set of items, each with a given weight and value, among multiple knapsacks to maximize the total value without exceeding the capacity of any knapsack.
+
+- **MKP via Ant Colony Optimization (`mkp_aco`)**: Solve MKP using Ant Colony Optimization (ACO)[2].
+
+### Decap Placement Problem (DPPs)
+The Decap Placement Problem (DPP) is a critical hardware design optimization issue that involves finding the optimal placement of decoupling capacitors (decap) within a power distribution network (PDN) to enhance power integrity (PI). Decoupling capacitors are hardware components that help reduce power noise and ensure a stable power supply to operating integrated circuits in hardware devices such as CPUs, GPUs, and AI accelerators.
+
+- **Decap Placement Problem (DPP) for Electronic Design Automation (EDA) Problems via Genetic Algorithm (GA)[4] (`dpp_ga`)**
+
+### Cooperative Driving Problem (CDPs)
+The Cooperative Driving Problem (CDP) is a complex optimization challenge that involves optimizing the driving behavior of multiple vehicles on a road segment.
+
+- **Cooperative Driving Problem (CDP) (`driving`)**: Evolve functions that directly construct driving actions for each time step.
+
+
+
+
+## How to Customize Your Own Benchmark
+
+### Command line arguments requirements (same for all problems)
+Command line arguments:
+1. `root_dir`: the project root directory; knowing project root can help you to load data; default: current working directory (os.getcwd());
+    Eval script need this to load dataset since eval script may be generated and stored in a different location to support parallelism;
+2. `file_output_prefix`: the output file prefix: this prefix can be used to save output files during evaluation for inspection purposes; 
+    we use prefix since you may want more than just a folder name; say you may want to add solution id to the output filename;
+    file will be saved by: `with open(f"{file_output_prefix}<filename>", 'w'):\n...`;
+    absolute path is recommended;
+    default: '', which means just save to current working directory;
+3. `mode`: train or val; default: val;
+4. `problem_size`; default: 50 (Note: this value differs for each problem!);
+
+
+### How to run
+You can manually run the script this way:
+```
+python eval.py \
+    --root_dir=<path_to_project_root> \
+    --file_output_prefix=<path_to_output_file> \
+    --mode=val \
+    --problem_size=50
+```
+
+`Evaluator` class will run eval script like this:
+```
+subprocess.run([
+                'python', 'script.py',
+                '--root_dir', '/path/to/project',
+                '--file_output_prefix', '/path/to/outputs/exp1_',
+            ], 
+            text=True,
+            timeout=self.timeout_seconds,  # timeout seconds
+            cwd=os.getcwd(),
+            env=env,  # python env
+            stdout=f, 
+            stderr=f
+            )
+```
+Note:
+Evaluator won't specify `mode` and `problem_size`; 
+Since evaluator is intended for general purpose, we assume it does not know any problem detail.
+This makes it easier for you to add new problems - you don't need to modify the `Evaluator` class.
+
+
+### Output requirements (same for all problems)
+Eval script should print out `metrics`,`features`, and `score`;
+1. `metrics`: a dict that map test name (str) to metrics (Dict),
+     or a dict that maps performance index name to values; 
+    `metrics` dict is used for user and AI agent inspection;
+    It's optional but we strongly recommend you to prepare a detailed metrics for each problem; as this can help LLM to better understand the solution performance!
+2. `features`: a tuple of ints that represents the features of the solution; 
+    `features` tuple is used for solution storage in the solution database; 
+    Features is generally generated from metrics, possibly with some added feature; 
+    but Evaluator will not assume any conversion method; you need to specify it yourself.
+    Features could be set to `None` if you don't want to specify feature; in that case MAP-Elite will be disabled;
+3. `score`: a float that represents the score of the solution;
+    `score` is used for as the fitness score.
+    It's required. It's usually generated from metrics; but Evaluator will not assume any conversion method; you need to specify it yourself.
+
+Example:
+Assume the following variables are generated during eval script:
+```
+metrics = {
+    "critical_ttc_count": 28, 
+    "collisions": 0, 
+    "emergencyStops": 0, 
+    "emergencyBraking": 4, 
+    "teleports": 0, 
+    "avg_speed": 12.51, 
+    "speed_variance": 16.22
+}
+features = (2, 0, 1, 4)
+score = 12.34
+```
+
+Then stdout should be:
+```
+...
+__SANDBOX_RESULT__
+
+__METRICS_START__
+<print(repr(metrics))>
+__METRICS_END__
+
+__FEATURES_START__
+<print(repr(features))>
+__FEATURES_END__
+
+__SCORE_START__
+<print(repr(score))>
+__SCORE_END__
+
+__SANDBOX_SUCCESS__
+```
+
+### Dynamic solution function loading
+Solution function scripts will be generated on the fly and loaded dynamically.
+To enable parallelism, we will save different solution script to different files. Hence `Evaluator` will need to load the solution script dynamically.
+Keep the line below unchanged:
+```
+import seed_solution as solution_module
+```
+Say, one solution script is generated as `solution_0905.py`;
+Then the above line will be replaced by:
+```
+import solution_0905 as solution_module
+```
+and the new eval script will be saved locally and got run.
+
+
+
+
+## References
+
+[1] Ye, H., Wang, J., Cao, Z., Berto, F., Hua, C., Kim, H., Park, J., & Song, G. (2024). Reevo: Large language models as hyper-heuristics with reflective evolution. *Advances in Neural Information Processing Systems*, 37, 43571–43608.
+
+[2] Ye, H., Wang, J., Cao, Z., Liang, H., & Li, Y. (2023). DeepACO: Neural-enhanced ant systems for combinatorial optimization. *Advances in Neural Information Processing Systems*, 36, 43706–43728.
+
+[3] Voudouris, C., & Tsang, E. (1999). Guided local search and its application to the traveling salesman problem. *European Journal of Operational Research*, 113(2), 469–499.
+
+[4] Park, H., Kim, H., Kim, H., Park, J., Choi, S., Kim, J., Son, K., Suh, H., Kim, T., Ahn, J., & Kim, J. (2023, October). Versatile genetic algorithm-bayesian optimization (GA-BO) bi-level optimization for decoupling capacitor placement. In *2023 IEEE 32nd Conference on Electrical Performance of Electronic Packaging and Systems (EPEPS)* (pp. 1–3). IEEE.
+
+[5] Kwon, Y. D., Choo, J., Kim, B., Yoon, I., Gwon, Y., & Min, S. (2020). POMO: Policy optimization with multiple optima for reinforcement learning. *Advances in Neural Information Processing Systems*, 33, 21188–21198.
+
+[6] Luo, F., Lin, X., Liu, F., Zhang, Q., & Wang, Z. (2023). Neural combinatorial optimization with heavy decoder: Toward large scale generalization. *Advances in Neural Information Processing Systems*, 36, 8845–8864.

bpp_offline_aco/dataset/test1000_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64ea8870b7858c3ff824a3661ff98e78affb55316ef0e31e37760b9e6fd0422b
+size 512268

bpp_offline_aco/dataset/test120_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe96e289874e9808c037af6e78831dd9e92484efb9e4da5696ec071dc8b9dbae
+size 61708

bpp_offline_aco/dataset/test500_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5002d16ca7f59f3f46257176f416e5d7856ddf4be0655660acf2b6f64d8143d3
+size 256268

bpp_offline_aco/dataset/train500_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f19298b958c2bde265a3226ff21ef4daa7c35a90aed4598a17637ee4c5016638
+size 20268

bpp_offline_aco/dataset/val1000_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e3a8b7361f8a2642f6d82ba0fab970c1365f659a54b3ebe737eb5727dcf9f8c
+size 512268

bpp_offline_aco/dataset/val120_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0986f1708f6dc0d9dd48fc49c40597ed6623fece7f6ee6c14f54ddc6cf763c9d
+size 61708

bpp_offline_aco/dataset/val500_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4652c48c92c8b9d71d328313f7835aa86be9146ef5817478feb95a2f08dbc2a3
+size 256268

bpp_offline_aco/eval.py

@@ -0,0 +1,393 @@
+# Evaluation script for BPP-Offline-ACO problem
+import os
+import sys
+import traceback
+from math import floor
+import argparse
+from typing import NamedTuple, Tuple, List, Annotated, Dict, Any
+import numpy as np
+import numpy.typing as npt
+import seed_solution as solution_module  # Note: solution module script is generated and saved on the fly
+
+
+# =====Load function to evolve=====
+problem = "bpp_offline_aco"
+heuristics = getattr(solution_module, "heuristics")  # Get function to evolve
+
+
+# =====Configuration and Parameters=====
+IntArray = npt.NDArray[np.int_]
+FloatArray = npt.NDArray[np.float64]
+
+class BPPInstance(NamedTuple):
+    n: int
+    capacity: int
+    demands: npt.NDArray[np.int_]
+
+DEMAND_LOW = 20
+DEMAND_HIGH = 100
+CAPACITY = 150
+
+dataset_conf = {
+    'train': (500,),
+    'val':   (120, 500),  # 120, 500, 1000
+    'test':  (120, 500),  # 120, 500, 1000
+}
+
+
+# =====Utility Functions=====
+def load_dataset(fp) -> list[BPPInstance]:
+    data = np.load(fp)
+    demands = data['demands']
+    instances = []
+    n = demands.shape[1]
+    for demand in demands:
+        instance = BPPInstance(n, CAPACITY, demand)
+        instances.append(instance)
+    return instances
+
+def organize_path(path: IntArray) -> Tuple[int, IntArray]:
+    order = {}
+    result = np.zeros_like(path)
+    for i, v in enumerate(path):
+        if v in order:
+            result[i] = order[v]
+        else:
+            result[i] = order[v] = len(order)
+    return len(order), result
+
+def calculate_path_cost_fitness(vacancies: IntArray, capacity: int) -> Tuple[int, float]:
+    occupied = (capacity - vacancies[vacancies!=capacity]).astype(float)
+    cost = len(occupied)
+    result = ((occupied/capacity)**2).sum().item()/cost
+    return cost, result
+
+def calculate_path_fitness(vacancies: List[int], capacity: int) -> float:
+    occupied = capacity - np.array(vacancies, dtype=float)
+    result = ((occupied/capacity)**2).sum().item()/len(vacancies)
+    return result
+
+def greedy_sample(prob: FloatArray) -> int:
+    return prob.argmax().item()
+
+def random_sample(prob: FloatArray) -> int:
+    # not used, `random_sample_discrete_distribution` is a faster implementation
+    sampled = np.random.choice(prob.size, p=prob/prob.sum())
+    return sampled
+
+def random_sample_discrete_distribution(prob: FloatArray) -> int:
+    # prob_exp = np.exp(prob-prob.max())
+    # prob_exp[prob==0] = 0
+    # np.random.choice is somehow slow
+    cumprob = np.cumsum(prob)
+    sampled = np.searchsorted(cumprob, next(uniform_generator)*cumprob[-1]).item()
+    return sampled if sampled<len(cumprob) else len(cumprob)-1
+
+def uniform_number_generator(batch_size = 500):
+    # it's also slow to generate random numbers one by one
+    while 1:
+        numbers = np.random.random(batch_size)
+        for n in numbers:
+            yield n.item()
+
+uniform_generator = uniform_number_generator()
+
+
+# =====ACO class=====
+class ACO(object):
+    def __init__(self,
+                 demand: IntArray,   # (n, )
+                 heuristic: FloatArray,   # (n, n)
+                 capacity: int,
+                 n_ants=20, 
+                 decay=0.95,
+                 alpha=1,
+                 beta=1,
+                 greedy = False
+                 ):
+        
+        self.problem_size = len(demand)
+        self.capacity = capacity
+        self.demand = demand
+        assert self.demand.max() <= self.capacity
+        
+        self.n_ants = n_ants
+        self.decay = decay
+        self.alpha = alpha
+        self.beta = beta
+        
+        self.pheromone: FloatArray = np.ones((self.problem_size, self.problem_size)) # problem_size x self.problem_size
+        heuristic[heuristic > 1e6] = 1e6
+        heuristic[heuristic < 1e-6] = 1e-6
+        heuristic = heuristic/heuristic.max() # normalize
+        heuristic[heuristic < 1e-6] = 1e-6
+        self.heuristic: FloatArray = heuristic # problem_size x self.problem_size
+
+        self.shortest_path: IntArray = np.arange(self.problem_size)
+        self.best_cost = self.problem_size
+
+        self._ordinal: IntArray = np.arange(self.problem_size, dtype=int) # for indexing
+        self.greedy_mode = greedy
+    
+    def run(self, iterations: int) -> Tuple[int, IntArray]:
+        for _ in range(iterations):
+            prob = self.pheromone**self.alpha * self.heuristic**self.beta
+            paths, costs, fitnesses = self.gen_paths(self.n_ants, prob)
+            best_index = costs.argmin()
+            best_cost = costs[best_index].item()
+            if best_cost < self.best_cost:
+                self.shortest_path = paths[best_index]
+                self.best_cost = best_cost
+            self.update_pheronome(paths, fitnesses)
+        assert self.is_valid_path(self.shortest_path)
+        # cost, path = organize_path(self.shortest_path)
+        # assert cost >= np.ceil(np.sum(self.demand).astype(float)/self.capacity).item()
+        return organize_path(self.shortest_path)
+
+    def sample_only(self, count: int) -> Tuple[int, IntArray]:
+        self.greedy_mode = True
+        paths, costs, _ = self.gen_paths(count, self.heuristic)
+        best_index = costs.argmin()
+        best_path = paths[best_index]
+        assert self.is_valid_path(best_path)
+        return organize_path(best_path)
+
+    def update_pheronome(self, paths: List[IntArray], fitnesses: FloatArray):
+        delta_phe = np.zeros_like(self.pheromone) # problem_size x problem_size
+        for path, f in zip(paths, fitnesses):
+            delta_phe[path[:, None]==path[None, :]] += f / self.n_ants
+        self.pheromone *= self.decay
+        self.pheromone += delta_phe
+
+    def gen_paths(self, count: int, prob: FloatArray) -> Tuple[List[IntArray], IntArray, FloatArray]:
+        paths, costs, fitnesses = [], [], []
+        for _ in range(count):
+            path, cost, fitness = self.sample_path(prob)
+            paths.append(path)
+            costs.append(cost)
+            fitnesses.append(fitness)
+        return paths, np.array(costs, dtype=int), np.array(fitnesses, dtype=float)
+    
+    def sample_path(self, prob: FloatArray
+                    ) -> Tuple[
+                        Annotated[IntArray, "sampled path"], 
+                        Annotated[int, "used bins"], 
+                        Annotated[float, "fitness"]]:
+        
+        if self.greedy_mode:
+            sample_func = greedy_sample
+        else:
+            sample_func = random_sample_discrete_distribution
+    
+        path = np.ones(self.problem_size, dtype=int)*-1 # x=path[i] => put item i in bin x
+        valid_items = np.ones(self.problem_size, dtype=bool)
+        current_bin = item_count = 0
+        vacancies = []
+        bin_vacancy = self.capacity
+        bin_items = np.zeros_like(valid_items)
+
+        for _ in range(self.problem_size):
+            mask = np.bitwise_and(self.demand <= bin_vacancy, valid_items)
+            if not np.any(mask): # no valid item
+                # move to the next bin
+                vacancies.append(bin_vacancy)
+                bin_vacancy, item_count = self.capacity, 0
+                current_bin += 1
+                bin_items[:] = False
+                # uniformly select one
+                selected = self.random_select(valid_items)
+            else:
+                if item_count == 0:
+                    selected = self.random_select(mask)
+                else:
+                    item_prob = (prob[bin_items].sum(0)/item_count+1e-5) * mask
+                    selected = sample_func(item_prob)
+            
+            # put item in this bin
+            bin_items[selected] = True
+            bin_vacancy -= self.demand[selected]
+            valid_items[selected] = False
+            path[selected] = current_bin
+            item_count += 1
+        
+        vacancies.append(bin_vacancy)
+        fitness = calculate_path_fitness(vacancies, self.capacity)
+        return path, len(vacancies), fitness
+    
+    def random_select(self, mask: npt.NDArray[np.bool_]) -> int:
+        valid = self._ordinal[mask]
+        return valid[floor(next(uniform_generator)*len(valid))].item()
+        # return valid[np.random.randint(0, len(valid))].item()
+    
+    def is_valid_path(self, path: IntArray) -> bool:
+        # not used
+        if path.shape[0] != self.problem_size:
+            return False
+        bins, path = organize_path(path)
+        occupied = np.zeros(bins, dtype=int)
+        for i, v in enumerate(path):
+            if v<0:
+                return False
+            occupied[v] += self.demand[i]
+            if occupied[v] > self.capacity:
+                return False
+        return True
+
+
+# =====Evaluation function=====
+N_ITERATIONS = 15
+N_ANTS = 20
+SAMPLE_COUNT = 200
+
+def evaluate_heuristic(inst: BPPInstance, mode = 'sample'):
+    heu = heuristics(inst.demands.copy(), inst.capacity) # normalized in ACO
+    assert tuple(heu.shape) == (inst.n, inst.n)
+    assert 0 < heu.max() < np.inf
+    aco = ACO(inst.demands, heu.astype(float), capacity = inst.capacity, n_ants=N_ANTS, greedy=False)
+    if mode == 'sample':
+        obj, _ = aco.sample_only(SAMPLE_COUNT)
+    else:
+        obj, _ = aco.run(N_ITERATIONS)
+    return obj
+
+
+# =====Helper functions=====
+def get_feature(metrics: Dict[int, float]) -> Tuple[int, ...]:
+    """
+    Convert the metrics dict to a feature vector
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (tuple): a tuple of discretized scores sorted by problem size
+    """
+    scores = metrics.values()
+    features = tuple([int(x) for x in scores])
+    return features
+    
+def get_score(metrics: Dict[int, float]) -> float:
+    """
+    Convert the metrics dict to a score
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (float): a score
+    """
+    return sum(metrics.values()) / len(metrics)
+
+
+# =====Main function=====
+if __name__ == "__main__":
+    # -----Parse command line arguments (same for all problems)-----
+    parser = argparse.ArgumentParser(description='Evaluation script.')
+    parser.add_argument(
+        '--root_dir',
+        type=str,
+        default=os.getcwd(),
+        help='Project root directory for loading data (default: current working directory)'
+    )
+    parser.add_argument(
+        '--file_output_prefix',
+        type=str,
+        default='',
+        help='Output file prefix for saving evaluation results. '
+             'Absolute path recommended. Files saved as {prefix}filename '
+             '(default: empty string, saves to current directory)')
+    parser.add_argument(
+        '--mode',
+        type=str,
+        default='val',
+        choices=['train', 'val'],
+        help='Execution mode: train or val (default: val)'
+    )
+    parser.add_argument(
+        '--problem_size',
+        type=int,
+        default=50,  # Customize this to your needs
+        help='Problem size parameter'
+    )
+    # Parse arguments
+    args = parser.parse_args()
+    root_dir = args.root_dir
+    file_output_prefix = args.file_output_prefix
+    mode = args.mode
+    problem_size = args.problem_size
+    method = 'aco'
+    # Print parsed arguments for verification
+    print(f"root_dir: {root_dir}")
+    print(f"file_output_prefix: {file_output_prefix}")
+    print(f"mode: {mode}")
+    #print(f"problem_size: {problem_size}")
+    
+    # -----Run the evaluation-----
+    # Run two instances: 120, 500; execution time: 125s
+    try:
+        basepath = os.path.join(root_dir, "problems", problem)
+        
+        if not os.path.isfile(os.path.join(basepath, f"dataset/train{dataset_conf['train'][0]}_dataset.npz")):
+            raise ValueError("Dataset does not exist. Please generate it first.")
+        
+        if mode == 'train':
+            dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npz")
+            dataset = load_dataset(dataset_path)
+            n_instances = len(dataset)
+
+            print(f"[*] Dataset loaded: {dataset_path} with {n_instances} instances.")
+            
+            objs = []
+            for i, instance in enumerate(dataset):
+                obj = evaluate_heuristic(instance, mode=method)
+                print(f"[*] Instance {i}: {obj}")
+                objs.append(obj)
+            
+            print("[*] Average:")
+            print(np.mean(objs))
+
+        else: # mood == 'val'
+            metrics = {}
+            for problem_size in dataset_conf['val']:
+                dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npz")
+                dataset = load_dataset(dataset_path)
+                n_instances = dataset[0].n
+                print(f"[*] Evaluating {dataset_path}")
+
+                objs = []
+                for i, instance in enumerate(dataset):
+                    obj = evaluate_heuristic(instance, mode=method)
+                    objs.append(obj)
+                
+                print(f"[*] Average for problem size {problem_size}: {np.mean(objs)}")
+                metrics[problem_size] = float(np.mean(objs))
+                
+        if metrics:
+            features = get_feature(metrics)
+            score = get_score(metrics)
+        else:
+            features = None
+            score = None
+
+        # -----Print results to stdout (same for all problems)-----
+        print('__SANDBOX_RESULT__')        
+        print('__METRICS_START__')
+        print(repr(metrics))
+        print('__METRICS_END__')
+        
+        print('__FEATURES_START__')
+        print(repr(features))
+        print('__FEATURES_END__')
+        
+        print('__SCORE_START__')
+        print(repr(score))
+        print('__SCORE_END__')
+        
+        print('__SANDBOX_SUCCESS__')
+        
+    except Exception as e:
+        print('__SANDBOX_ERROR__:')
+        print(f'Error type: {type(e).__name__}')
+        print(f'Error message: {str(e)}')
+        print('Full traceback:')
+        traceback.print_exc()

bpp_offline_aco/evaluation_description.txt

@@ -0,0 +1,397 @@
+The evaluation script for the problem is described below.
+
+```python
+# Evaluation script for BPP-Offline-ACO problem
+import os
+import sys
+import traceback
+from math import floor
+import argparse
+from typing import NamedTuple, Tuple, List, Annotated, Dict, Any
+import numpy as np
+import numpy.typing as npt
+import seed_solution as solution_module  # Note: solution module script is generated and saved on the fly
+
+
+# =====Load function to evolve=====
+problem = "bpp_offline_aco"
+heuristics = getattr(solution_module, "heuristics")  # Get function to evolve
+
+
+# =====Configuration and Parameters=====
+IntArray = npt.NDArray[np.int_]
+FloatArray = npt.NDArray[np.float_]
+
+class BPPInstance(NamedTuple):
+    n: int
+    capacity: int
+    demands: npt.NDArray[np.int_]
+
+DEMAND_LOW = 20
+DEMAND_HIGH = 100
+CAPACITY = 150
+
+dataset_conf = {
+    'train': (500,),
+    'val':   (120, 500),  # 120, 500, 1000
+    'test':  (120, 500),  # 120, 500, 1000
+}
+
+
+# =====Utility Functions=====
+def load_dataset(fp) -> list[BPPInstance]:
+    data = np.load(fp)
+    demands = data['demands']
+    instances = []
+    n = demands.shape[1]
+    for demand in demands:
+        instance = BPPInstance(n, CAPACITY, demand)
+        instances.append(instance)
+    return instances
+
+def organize_path(path: IntArray) -> Tuple[int, IntArray]:
+    order = {}
+    result = np.zeros_like(path)
+    for i, v in enumerate(path):
+        if v in order:
+            result[i] = order[v]
+        else:
+            result[i] = order[v] = len(order)
+    return len(order), result
+
+def calculate_path_cost_fitness(vacancies: IntArray, capacity: int) -> Tuple[int, float]:
+    occupied = (capacity - vacancies[vacancies!=capacity]).astype(float)
+    cost = len(occupied)
+    result = ((occupied/capacity)**2).sum().item()/cost
+    return cost, result
+
+def calculate_path_fitness(vacancies: List[int], capacity: int) -> float:
+    occupied = capacity - np.array(vacancies, dtype=float)
+    result = ((occupied/capacity)**2).sum().item()/len(vacancies)
+    return result
+
+def greedy_sample(prob: FloatArray) -> int:
+    return prob.argmax().item()
+
+def random_sample(prob: FloatArray) -> int:
+    # not used, `random_sample_discrete_distribution` is a faster implementation
+    sampled = np.random.choice(prob.size, p=prob/prob.sum())
+    return sampled
+
+def random_sample_discrete_distribution(prob: FloatArray) -> int:
+    # prob_exp = np.exp(prob-prob.max())
+    # prob_exp[prob==0] = 0
+    # np.random.choice is somehow slow
+    cumprob = np.cumsum(prob)
+    sampled = np.searchsorted(cumprob, next(uniform_generator)*cumprob[-1]).item()
+    return sampled if sampled<len(cumprob) else len(cumprob)-1
+
+def uniform_number_generator(batch_size = 500):
+    # it's also slow to generate random numbers one by one
+    while 1:
+        numbers = np.random.random(batch_size)
+        for n in numbers:
+            yield n.item()
+
+uniform_generator = uniform_number_generator()
+
+
+# =====ACO class=====
+class ACO(object):
+    def __init__(self,
+                 demand: IntArray,   # (n, )
+                 heuristic: FloatArray,   # (n, n)
+                 capacity: int,
+                 n_ants=20, 
+                 decay=0.95,
+                 alpha=1,
+                 beta=1,
+                 greedy = False
+                 ):
+        
+        self.problem_size = len(demand)
+        self.capacity = capacity
+        self.demand = demand
+        assert self.demand.max() <= self.capacity
+        
+        self.n_ants = n_ants
+        self.decay = decay
+        self.alpha = alpha
+        self.beta = beta
+        
+        self.pheromone: FloatArray = np.ones((self.problem_size, self.problem_size)) # problem_size x self.problem_size
+        heuristic[heuristic > 1e6] = 1e6
+        heuristic[heuristic < 1e-6] = 1e-6
+        heuristic = heuristic/heuristic.max() # normalize
+        heuristic[heuristic < 1e-6] = 1e-6
+        self.heuristic: FloatArray = heuristic # problem_size x self.problem_size
+
+        self.shortest_path: IntArray = np.arange(self.problem_size)
+        self.best_cost = self.problem_size
+
+        self._ordinal: IntArray = np.arange(self.problem_size, dtype=int) # for indexing
+        self.greedy_mode = greedy
+    
+    def run(self, iterations: int) -> Tuple[int, IntArray]:
+        for _ in range(iterations):
+            prob = self.pheromone**self.alpha * self.heuristic**self.beta
+            paths, costs, fitnesses = self.gen_paths(self.n_ants, prob)
+            best_index = costs.argmin()
+            best_cost = costs[best_index].item()
+            if best_cost < self.best_cost:
+                self.shortest_path = paths[best_index]
+                self.best_cost = best_cost
+            self.update_pheronome(paths, fitnesses)
+        assert self.is_valid_path(self.shortest_path)
+        # cost, path = organize_path(self.shortest_path)
+        # assert cost >= np.ceil(np.sum(self.demand).astype(float)/self.capacity).item()
+        return organize_path(self.shortest_path)
+
+    def sample_only(self, count: int) -> Tuple[int, IntArray]:
+        self.greedy_mode = True
+        paths, costs, _ = self.gen_paths(count, self.heuristic)
+        best_index = costs.argmin()
+        best_path = paths[best_index]
+        assert self.is_valid_path(best_path)
+        return organize_path(best_path)
+
+    def update_pheronome(self, paths: List[IntArray], fitnesses: FloatArray):
+        delta_phe = np.zeros_like(self.pheromone) # problem_size x problem_size
+        for path, f in zip(paths, fitnesses):
+            delta_phe[path[:, None]==path[None, :]] += f / self.n_ants
+        self.pheromone *= self.decay
+        self.pheromone += delta_phe
+
+    def gen_paths(self, count: int, prob: FloatArray) -> Tuple[List[IntArray], IntArray, FloatArray]:
+        paths, costs, fitnesses = [], [], []
+        for _ in range(count):
+            path, cost, fitness = self.sample_path(prob)
+            paths.append(path)
+            costs.append(cost)
+            fitnesses.append(fitness)
+        return paths, np.array(costs, dtype=int), np.array(fitnesses, dtype=float)
+    
+    def sample_path(self, prob: FloatArray
+                    ) -> Tuple[
+                        Annotated[IntArray, "sampled path"], 
+                        Annotated[int, "used bins"], 
+                        Annotated[float, "fitness"]]:
+        
+        if self.greedy_mode:
+            sample_func = greedy_sample
+        else:
+            sample_func = random_sample_discrete_distribution
+    
+        path = np.ones(self.problem_size, dtype=int)*-1 # x=path[i] => put item i in bin x
+        valid_items = np.ones(self.problem_size, dtype=bool)
+        current_bin = item_count = 0
+        vacancies = []
+        bin_vacancy = self.capacity
+        bin_items = np.zeros_like(valid_items)
+
+        for _ in range(self.problem_size):
+            mask = np.bitwise_and(self.demand <= bin_vacancy, valid_items)
+            if not np.any(mask): # no valid item
+                # move to the next bin
+                vacancies.append(bin_vacancy)
+                bin_vacancy, item_count = self.capacity, 0
+                current_bin += 1
+                bin_items[:] = False
+                # uniformly select one
+                selected = self.random_select(valid_items)
+            else:
+                if item_count == 0:
+                    selected = self.random_select(mask)
+                else:
+                    item_prob = (prob[bin_items].sum(0)/item_count+1e-5) * mask
+                    selected = sample_func(item_prob)
+            
+            # put item in this bin
+            bin_items[selected] = True
+            bin_vacancy -= self.demand[selected]
+            valid_items[selected] = False
+            path[selected] = current_bin
+            item_count += 1
+        
+        vacancies.append(bin_vacancy)
+        fitness = calculate_path_fitness(vacancies, self.capacity)
+        return path, len(vacancies), fitness
+    
+    def random_select(self, mask: npt.NDArray[np.bool_]) -> int:
+        valid = self._ordinal[mask]
+        return valid[floor(next(uniform_generator)*len(valid))].item()
+        # return valid[np.random.randint(0, len(valid))].item()
+    
+    def is_valid_path(self, path: IntArray) -> bool:
+        # not used
+        if path.shape[0] != self.problem_size:
+            return False
+        bins, path = organize_path(path)
+        occupied = np.zeros(bins, dtype=int)
+        for i, v in enumerate(path):
+            if v<0:
+                return False
+            occupied[v] += self.demand[i]
+            if occupied[v] > self.capacity:
+                return False
+        return True
+
+
+# =====Evaluation function=====
+N_ITERATIONS = 15
+N_ANTS = 20
+SAMPLE_COUNT = 200
+
+def evaluate_heuristic(inst: BPPInstance, mode = 'sample'):
+    heu = heuristics(inst.demands.copy(), inst.capacity) # normalized in ACO
+    assert tuple(heu.shape) == (inst.n, inst.n)
+    assert 0 < heu.max() < np.inf
+    aco = ACO(inst.demands, heu.astype(float), capacity = inst.capacity, n_ants=N_ANTS, greedy=False)
+    if mode == 'sample':
+        obj, _ = aco.sample_only(SAMPLE_COUNT)
+    else:
+        obj, _ = aco.run(N_ITERATIONS)
+    return obj
+
+
+# =====Helper functions=====
+def get_feature(metrics: Dict[int, float]) -> Tuple[int, ...]:
+    """
+    Convert the metrics dict to a feature vector
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (tuple): a tuple of discretized scores sorted by problem size
+    """
+    scores = metrics.values()
+    features = tuple([int(x) for x in scores])
+    return features
+    
+def get_score(metrics: Dict[int, float]) -> float:
+    """
+    Convert the metrics dict to a score
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (float): a score
+    """
+    return sum(metrics.values()) / len(metrics)
+
+
+# =====Main function=====
+if __name__ == "__main__":
+    # -----Parse command line arguments (same for all problems)-----
+    parser = argparse.ArgumentParser(description='Evaluation script.')
+    parser.add_argument(
+        '--root_dir',
+        type=str,
+        default=os.getcwd(),
+        help='Project root directory for loading data (default: current working directory)'
+    )
+    parser.add_argument(
+        '--file_output_prefix',
+        type=str,
+        default='',
+        help='Output file prefix for saving evaluation results. '
+             'Absolute path recommended. Files saved as {prefix}filename '
+             '(default: empty string, saves to current directory)')
+    parser.add_argument(
+        '--mode',
+        type=str,
+        default='val',
+        choices=['train', 'val'],
+        help='Execution mode: train or val (default: val)'
+    )
+    parser.add_argument(
+        '--problem_size',
+        type=int,
+        default=50,  # Customize this to your needs
+        help='Problem size parameter'
+    )
+    # Parse arguments
+    args = parser.parse_args()
+    root_dir = args.root_dir
+    file_output_prefix = args.file_output_prefix
+    mode = args.mode
+    problem_size = args.problem_size
+    method = 'aco'
+    # Print parsed arguments for verification
+    print(f"root_dir: {root_dir}")
+    print(f"file_output_prefix: {file_output_prefix}")
+    print(f"mode: {mode}")
+    #print(f"problem_size: {problem_size}")
+    
+    # -----Run the evaluation-----
+    # Run two instances: 120, 500; execution time: 125s
+    try:
+        basepath = os.path.join(root_dir, "problems", problem)
+        
+        if not os.path.isfile(os.path.join(basepath, f"dataset/train{dataset_conf['train'][0]}_dataset.npz")):
+            raise ValueError("Dataset does not exist. Please generate it first.")
+        
+        if mode == 'train':
+            dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npz")
+            dataset = load_dataset(dataset_path)
+            n_instances = len(dataset)
+
+            print(f"[*] Dataset loaded: {dataset_path} with {n_instances} instances.")
+            
+            objs = []
+            for i, instance in enumerate(dataset):
+                obj = evaluate_heuristic(instance, mode=method)
+                print(f"[*] Instance {i}: {obj}")
+                objs.append(obj)
+            
+            print("[*] Average:")
+            print(np.mean(objs))
+
+        else: # mood == 'val'
+            metrics = {}
+            for problem_size in dataset_conf['val']:
+                dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npz")
+                dataset = load_dataset(dataset_path)
+                n_instances = dataset[0].n
+                print(f"[*] Evaluating {dataset_path}")
+
+                objs = []
+                for i, instance in enumerate(dataset):
+                    obj = evaluate_heuristic(instance, mode=method)
+                    objs.append(obj)
+                
+                print(f"[*] Average for {problem_size}: {np.mean(objs)}")
+                metrics[problem_size] = np.mean(objs)
+                
+        if metrics:
+            features = get_feature(metrics)
+            score = get_score(metrics)
+        else:
+            features = None
+            score = None
+
+        # -----Print results to stdout (same for all problems)-----
+        print('__SANDBOX_RESULT__')        
+        print('__METRICS_START__')
+        print(repr(metrics))
+        print('__METRICS_END__')
+        
+        print('__FEATURES_START__')
+        print(repr(features))
+        print('__FEATURES_END__')
+        
+        print('__SCORE_START__')
+        print(repr(score))
+        print('__SCORE_END__')
+        
+        print('__SANDBOX_SUCCESS__')
+        
+    except Exception as e:
+        print('__SANDBOX_ERROR__:')
+        print(f'Error type: {type(e).__name__}')
+        print(f'Error message: {str(e)}')
+        print('Full traceback:')
+        traceback.print_exc()
+```

bpp_offline_aco/external_knowledge.txt

@@ -0,0 +1,2 @@
+- Try combining various factors to determine how promising it is to select an edge.
+- Try sparsifying the matrix by setting unpromising elements to zero.

bpp_offline_aco/function_description.txt

@@ -0,0 +1,7 @@
+Suppose `n` represents the number of items in the problem. The heuristics function takes as input a `demand` array of shape (n,) and an integer as the capacity of every bin, and it returns a `heuristics` array of shape (n,n). 
+`heuristics[i][j]` indicates how promising it is to put item i and item j in the same bin.
+
+### Solution Function Signature:
+```python
+def heuristics(demand: np.ndarray, capacity: int) -> np.ndarray:
+```

bpp_offline_aco/generate_dataset.py

@@ -0,0 +1,49 @@
+from typing import NamedTuple
+import numpy as np
+import numpy.typing as npt
+
+class BPPInstance(NamedTuple):
+    n: int
+    capacity: int
+    demands: npt.NDArray[np.int_]
+
+# Emanuel Falkenauer. A hybrid grouping genetic algorithm for bin packing. Journal of Heuristics,2:5–30, 1996.
+
+DEMAND_LOW = 20
+DEMAND_HIGH = 100
+CAPACITY = 150
+dataset_conf = {
+    'train': (500,),
+    'val':   (120, 500, 1000),
+    'test':  (120, 500, 1000),
+}
+
+def generate_dataset(filepath, n, batch_size=64):
+    demands = np.random.randint(low=DEMAND_LOW, high=DEMAND_HIGH+1, size=(batch_size, n))
+    np.savez(filepath, demands = demands)
+
+
+def generate_datasets(basepath = None):
+    import os
+    basepath = basepath or os.path.join(os.path.dirname(__file__), "dataset")
+    os.makedirs(basepath, exist_ok=True)
+
+    for mood, problem_sizes in dataset_conf.items():
+        np.random.seed(len(mood))
+        for n in problem_sizes:
+            filepath = os.path.join(basepath, f"{mood}{n}_dataset.npz")
+            generate_dataset(filepath, n, batch_size=5 if mood =='train' else 64)
+
+def load_dataset(fp) -> list[BPPInstance]:
+    data = np.load(fp)
+    demands = data['demands']
+    instances = []
+    n = demands.shape[1]
+    for demand in demands:
+        instance = BPPInstance(n, CAPACITY, demand)
+        instances.append(instance)
+    return instances
+
+
+if __name__ == "__main__":
+    generate_datasets()

bpp_offline_aco/problem_description.txt

@@ -0,0 +1,6 @@
+The Bin Packing Problem (BPP) is a combinatorial optimization challenge where items of varying sizes must be packed into bins of fixed capacity, minimizing the number of bins used while respecting capacity constraints. 
+In the offline version, all item sizes are known in advance, allowing for more sophisticated packing strategies. 
+We use Ant Colony Optimization (ACO) to solve this problem, where artificial ants probabilistically construct packing solutions guided by pheromone trails and heuristic information.
+Each ant builds a solution by sequentially assigning items to bins based on a probability distribution that combines pheromone intensity and heuristic desirability. 
+Your task is to evolve a `heuristics` function that generates an n×n heuristic matrix to guide ant movement, where n is the number of items. 
+The goal of minimizing the average number of bins used across all instances (called "score" or "objective" of solution).

bpp_offline_aco/seed_solution.py

@@ -0,0 +1,4 @@
+import numpy as np
+
+def heuristics(demand: np.ndarray, capacity: int) -> np.ndarray:
+    return np.tile(demand/demand.max(), (demand.shape[0], 1))

bpp_offline_aco/seed_solution_idea.txt

@@ -0,0 +1 @@
+This simple heuristic prioritizes larger items by giving them higher heuristic values, encouraging ants to pack larger items together first.

bpp_offline_aco/settings.yaml

@@ -0,0 +1,2 @@
+"function_to_evolve": "heuristics"
+"obj_type": "min"

bpp_online/dataset/weibull_100k_test.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22018e0ffa54cd405e0bd6102fe687b3d716802ee4785fca5613337937c2f485
+size 800292

bpp_online/dataset/weibull_10k_test.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0393be2ce402cfca3a7a56b5e791c0c0e6af5bb5293401e8b5d9322d96b65601
+size 400556

bpp_online/dataset/weibull_5k_test.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5df0be286b0bcbc6a680fb875490b651d49bcac4b31e4c3ef7b1349d31ab028
+size 200529

bpp_online/dataset/weibull_5k_train.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50ce65b6c06d940a746f200482e158d25e86ba5760cadfbae677c27596a8f0f2
+size 200534

bpp_online/dataset/weibull_5k_val.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3374f60053947b3424ec64fa799eca2de03edd8dae103e4e1c2ab97f2b28b02
+size 200524

bpp_online/eval.py

@@ -0,0 +1,193 @@
+# Evaluation script for online binpacking problem.
+import os 
+import sys
+import traceback
+import numpy as np
+import pickle
+import argparse
+from typing import Dict, Tuple, List, Any
+import seed_solution as solution_module  # Note: solution module script is generated and saved on the fly
+
+
+# =====Load function to evolve=====
+problem = "bpp_online"
+priority = getattr(solution_module, "priority")  # Get function to evolve
+
+
+# =====Binpacking functions=====
+def get_valid_bin_indices(item: float, bins: np.ndarray) -> np.ndarray:
+    """
+    Returns indices of bins that have sufficient capacity for a given item.
+
+    Args:
+        item: Size of the item to place (float)
+        bins: NumPy array of remaining bin capacities (float array)
+
+    Returns:
+        NumPy array of indices where bins have capacity >= item size
+    """
+    return np.nonzero((bins - item) >= 0)[0]
+
+def online_binpack(items: tuple[float], bins: np.ndarray) -> tuple[list[list[float]], np.ndarray]:
+    """
+    Performs online bin-packing of items into bins using a priority heuristic.
+
+    Args:
+        items: Tuple of item sizes to pack (float values)
+        bins: NumPy array of initial bin capacities (float array)
+
+    Returns:
+        Tuple of (packing, remaining_capacities):
+        - packing: List of lists, where each inner list contains items in a bin
+        - remaining_capacities: Updated bin capacities after packing
+    """
+    # Track which items are added to each bin.
+    packing = [[] for _ in bins]
+    # Add items to bins.
+    for item in items:
+        # Extract bins that have sufficient space to fit item.
+        valid_bin_indices = get_valid_bin_indices(item, bins)
+        # Score each bin based on heuristic.
+        priorities = priority(item, bins[valid_bin_indices])
+        # Add item to bin with highest priority.
+        best_bin = valid_bin_indices[np.argmax(priorities)]
+        bins[best_bin] -= item
+        packing[best_bin].append(item)
+    # Remove unused bins from packing.
+    packing = [bin_items for bin_items in packing if bin_items]
+    return packing, bins
+
+
+# ======Evaluation function=====
+def get_feature(metrics: Dict[int, float]) -> Tuple[int, ...]:
+    """
+    Convert the metrics dict to a feature vector
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (tuple): a tuple of discretized scores sorted by problem size
+    """
+    scores = metrics.values()
+    features = tuple([int(x) for x in scores])
+    return features
+
+def evaluate(instances: dict) -> float:
+    """Evaluate heuristic function on a set of online binpacking instances."""
+    # List storing number of bins used for each instance.
+    num_bins = []
+    metrics = {}
+    # Perform online binpacking for each instance.
+    for name in instances:
+        if name == 'l1_bound':  # Skip l1_bound; l1_bound is a float that represents the L1 lower bound (best performance) for benchmarking
+            continue
+        instance = instances[name]
+        capacity = instance['capacity']  # Initial capacity of each bin; note: each bin has the same capacity
+        items = instance['items']  # Items to pack
+        items = np.array(items) if isinstance(items, list) else items  # Convert to NumPy array
+        # Create num_items bins so there will always be space for all items,
+        # regardless of packing order. Array has shape (num_items,).
+        bins = np.array([capacity for _ in range(instance['num_items'])])
+        # Pack items into bins and return remaining capacity in bins_packed, which
+        # has shape (num_items,).
+        _, bins_packed = online_binpack(items.astype(float), bins)
+        # If remaining capacity in a bin is equal to initial capacity, then it is unused. Count number of used bins.
+        num_bins.append((bins_packed != capacity).sum())
+        metrics[name] = float(num_bins[-1])
+    # return negative of average number of bins used across instances (as we want to minimize number of bins).
+    return np.mean(num_bins), metrics
+
+
+# =======Main function=====
+if __name__ == "__main__":
+    # -----Parse command line arguments (same for all problems)-----
+    parser = argparse.ArgumentParser(description='Evaluation script.')
+    parser.add_argument(
+        '--root_dir',
+        type=str,
+        default=os.getcwd(),
+        help='Project root directory for loading data (default: current working directory)'
+    )
+    parser.add_argument(
+        '--file_output_prefix',
+        type=str,
+        default='',
+        help='Output file prefix for saving evaluation results. '
+             'Absolute path recommended. Files saved as {prefix}filename '
+             '(default: empty string, saves to current directory)')
+    parser.add_argument(
+        '--mode',
+        type=str,
+        default='val',
+        choices=['train', 'val'],
+        help='Execution mode: train or val (default: val)'
+    )
+    parser.add_argument(
+        '--problem_size',
+        type=int,
+        default=100,  # Customize this to your needs
+        help='Problem size parameter'
+    )
+    # Parse arguments
+    args = parser.parse_args()
+    root_dir = args.root_dir
+    file_output_prefix = args.file_output_prefix
+    mode = args.mode
+    problem_size = args.problem_size
+    # Print parsed arguments for verification
+    print(f"root_dir: {root_dir}")
+    print(f"file_output_prefix: {file_output_prefix}")
+    print(f"mode: {mode}")
+    #print(f"problem_size: {problem_size}")
+
+    # -----Run the evaluation-----
+    # Execution time: 7s
+    try:
+        basepath = os.path.join(root_dir, "problems", problem)
+        file_name = f"weibull_5k_{mode}.pickle"  # it contains multiple instances; each instance has 5000 items; bin capacity is 100
+        dataset_path = os.path.join(basepath, "dataset", file_name)
+
+        dataset = pickle.load(open(dataset_path, 'rb'))
+        
+        # Evaluate heuristic function on dataset
+        avg_num_bins, metrics = evaluate(dataset)
+        l1_bound = dataset['l1_bound']
+        excess = (avg_num_bins - l1_bound) / l1_bound
+        print(file_name)
+        print(f'\t Average number of bins: {avg_num_bins}')
+        print(f'\t Lower bound on optimum: {l1_bound}')
+        print(f'\t Excess: {100 * excess:.2f}%')
+        
+        print("[*] Average:")
+        print(excess * 100)
+                
+        if metrics:
+            features = get_feature(metrics)
+            score = avg_num_bins
+        else:
+            features = None
+            score = None
+
+        # -----Print results to stdout (same for all problems)-----
+        print('__SANDBOX_RESULT__')        
+        print('__METRICS_START__')
+        print(repr(metrics))
+        print('__METRICS_END__')
+        
+        print('__FEATURES_START__')
+        print(repr(features))
+        print('__FEATURES_END__')
+        
+        print('__SCORE_START__')
+        print(repr(score))
+        print('__SCORE_END__')
+        
+        print('__SANDBOX_SUCCESS__')
+        
+    except Exception as e:
+        print('__SANDBOX_ERROR__:')
+        print(f'Error type: {type(e).__name__}')
+        print(f'Error message: {str(e)}')
+        print('Full traceback:')
+        traceback.print_exc()

bpp_online/evaluation_description.txt

@@ -0,0 +1,197 @@
+The evaluation script for the problem is described below.
+
+```python
+# Evaluation script for online binpacking problem.
+import os 
+import sys
+import traceback
+import numpy as np
+import pickle
+import argparse
+from typing import Dict, Tuple, List, Any
+import seed_solution as solution_module  # Note: solution module script is generated and saved on the fly
+
+
+# =====Load function to evolve=====
+problem = "bpp_online"
+priority = getattr(solution_module, "priority")  # Get function to evolve
+
+
+# =====Binpacking functions=====
+def get_valid_bin_indices(item: float, bins: np.ndarray) -> np.ndarray:
+    """
+    Returns indices of bins that have sufficient capacity for a given item.
+
+    Args:
+        item: Size of the item to place (float)
+        bins: NumPy array of remaining bin capacities (float array)
+
+    Returns:
+        NumPy array of indices where bins have capacity >= item size
+    """
+    return np.nonzero((bins - item) >= 0)[0]
+
+def online_binpack(items: tuple[float], bins: np.ndarray) -> tuple[list[list[float]], np.ndarray]:
+    """
+    Performs online bin-packing of items into bins using a priority heuristic.
+
+    Args:
+        items: Tuple of item sizes to pack (float values)
+        bins: NumPy array of initial bin capacities (float array)
+
+    Returns:
+        Tuple of (packing, remaining_capacities):
+        - packing: List of lists, where each inner list contains items in a bin
+        - remaining_capacities: Updated bin capacities after packing
+    """
+    # Track which items are added to each bin.
+    packing = [[] for _ in bins]
+    # Add items to bins.
+    for item in items:
+        # Extract bins that have sufficient space to fit item.
+        valid_bin_indices = get_valid_bin_indices(item, bins)
+        # Score each bin based on heuristic.
+        priorities = priority(item, bins[valid_bin_indices])
+        # Add item to bin with highest priority.
+        best_bin = valid_bin_indices[np.argmax(priorities)]
+        bins[best_bin] -= item
+        packing[best_bin].append(item)
+    # Remove unused bins from packing.
+    packing = [bin_items for bin_items in packing if bin_items]
+    return packing, bins
+
+
+# ======Evaluation function=====
+def get_feature(metrics: Dict[int, float]) -> Tuple[int, ...]:
+    """
+    Convert the metrics dict to a feature vector
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (tuple): a tuple of discretized scores sorted by problem size
+    """
+    scores = metrics.values()
+    features = tuple([int(x) for x in scores])
+    return features
+
+def evaluate(instances: dict) -> float:
+    """Evaluate heuristic function on a set of online binpacking instances."""
+    # List storing number of bins used for each instance.
+    num_bins = []
+    metrics = {}
+    # Perform online binpacking for each instance.
+    for name in instances:
+        if name == 'l1_bound':  # Skip l1_bound; l1_bound is a float that represents the L1 lower bound (best performance) for benchmarking
+            continue
+        instance = instances[name]
+        capacity = instance['capacity']  # Initial capacity of each bin; note: each bin has the same capacity
+        items = instance['items']  # Items to pack
+        items = np.array(items) if isinstance(items, list) else items  # Convert to NumPy array
+        # Create num_items bins so there will always be space for all items,
+        # regardless of packing order. Array has shape (num_items,).
+        bins = np.array([capacity for _ in range(instance['num_items'])])
+        # Pack items into bins and return remaining capacity in bins_packed, which
+        # has shape (num_items,).
+        _, bins_packed = online_binpack(items.astype(float), bins)
+        # If remaining capacity in a bin is equal to initial capacity, then it is unused. Count number of used bins.
+        num_bins.append((bins_packed != capacity).sum())
+        metrics[name] = num_bins[-1]
+    # return negative of average number of bins used across instances (as we want to minimize number of bins).
+    return np.mean(num_bins), metrics
+
+
+# =======Main function=====
+if __name__ == "__main__":
+    # -----Parse command line arguments (same for all problems)-----
+    parser = argparse.ArgumentParser(description='Evaluation script.')
+    parser.add_argument(
+        '--root_dir',
+        type=str,
+        default=os.getcwd(),
+        help='Project root directory for loading data (default: current working directory)'
+    )
+    parser.add_argument(
+        '--file_output_prefix',
+        type=str,
+        default='',
+        help='Output file prefix for saving evaluation results. '
+             'Absolute path recommended. Files saved as {prefix}filename '
+             '(default: empty string, saves to current directory)')
+    parser.add_argument(
+        '--mode',
+        type=str,
+        default='val',
+        choices=['train', 'val'],
+        help='Execution mode: train or val (default: val)'
+    )
+    parser.add_argument(
+        '--problem_size',
+        type=int,
+        default=100,  # Customize this to your needs
+        help='Problem size parameter'
+    )
+    # Parse arguments
+    args = parser.parse_args()
+    root_dir = args.root_dir
+    file_output_prefix = args.file_output_prefix
+    mode = args.mode
+    problem_size = args.problem_size
+    # Print parsed arguments for verification
+    print(f"root_dir: {root_dir}")
+    print(f"file_output_prefix: {file_output_prefix}")
+    print(f"mode: {mode}")
+    #print(f"problem_size: {problem_size}")
+
+    # -----Run the evaluation-----
+    # Execution time: 7s
+    try:
+        basepath = os.path.join(root_dir, "problems", problem)
+        file_name = f"weibull_5k_{mode}.pickle"  # it contains multiple instances; each instance has 5000 items; bin capacity is 100
+        dataset_path = os.path.join(basepath, "dataset", file_name)
+
+        dataset = pickle.load(open(dataset_path, 'rb'))
+        
+        # Evaluate heuristic function on dataset
+        avg_num_bins, metrics = evaluate(dataset)
+        l1_bound = dataset['l1_bound']
+        excess = (avg_num_bins - l1_bound) / l1_bound
+        print(file_name)
+        print(f'\t Average number of bins: {avg_num_bins}')
+        print(f'\t Lower bound on optimum: {l1_bound}')
+        print(f'\t Excess: {100 * excess:.2f}%')
+        
+        print("[*] Average:")
+        print(excess * 100)
+                
+        if metrics:
+            features = get_feature(metrics)
+            score = avg_num_bins
+        else:
+            features = None
+            score = None
+
+        # -----Print results to stdout (same for all problems)-----
+        print('__SANDBOX_RESULT__')        
+        print('__METRICS_START__')
+        print(repr(metrics))
+        print('__METRICS_END__')
+        
+        print('__FEATURES_START__')
+        print(repr(features))
+        print('__FEATURES_END__')
+        
+        print('__SCORE_START__')
+        print(repr(score))
+        print('__SCORE_END__')
+        
+        print('__SANDBOX_SUCCESS__')
+        
+    except Exception as e:
+        print('__SANDBOX_ERROR__:')
+        print(f'Error type: {type(e).__name__}')
+        print(f'Error message: {str(e)}')
+        print('Full traceback:')
+        traceback.print_exc()
+```

bpp_online/function_description.txt

@@ -0,0 +1,7 @@
+The priority function takes as input an item and an array of bins_remain_cap (containing the remaining capacity of each bin) and returns a priority score for each bin. 
+The bin with the highest priority score will be selected for the item.
+
+### Solution Function Signature
+```python
+def priority(item: float, bins_remain_cap: np.ndarray) -> np.ndarray:
+```

bpp_online/generate_dataset.py

@@ -0,0 +1,96 @@
+import os
+import numpy as np
+import pickle
+
+# Parameters for Weibull distribution
+shape_param = 3
+scale_param = 45
+max_item_size = 100
+bin_capacity = 100
+
+
+def generate_weibull_instances(num_instances, num_items, shape, scale, max_size):
+    instances = []
+    for _ in range(num_instances):
+        # Sampling from Weibull distribution
+        samples = np.random.weibull(shape, num_items) * scale
+        
+        # Clipping and rounding
+        items = np.clip(samples, None, max_size)
+        items = np.round(items).astype(int)
+
+        instances.append(items)
+    return instances
+
+
+def l1_bound(items: tuple[int, ...], capacity: int) -> float:
+  """Computes L1 lower bound on OPT for bin packing.
+
+  Args:
+    items: Tuple of items to pack into bins.
+    capacity: Capacity of bins.
+
+  Returns:
+    Lower bound on number of bins required to pack items.
+  """
+  return np.ceil(np.sum(items) / capacity)
+
+
+def l1_bound_dataset(instances: dict) -> float:
+  """Computes the mean L1 lower bound across a dataset of bin packing instances.
+
+  Args:
+    instances: Dictionary containing a set of bin packing instances.
+
+  Returns:
+    Average L1 lower bound on number of bins required to pack items.
+  """
+  l1_bounds = []
+  for name in instances:
+    instance = instances[name]
+    l1_bounds.append(l1_bound(instance['items'], instance['capacity']))
+  return np.mean(l1_bounds)
+
+def generate_datasets():
+    basepath = os.path.dirname(__file__)
+    os.makedirs(os.path.join(basepath, "dataset"), exist_ok=True)
+    
+    # Generating datasets
+    training_data = generate_weibull_instances(5, 5000, shape_param, scale_param, max_item_size)
+    validation_data = generate_weibull_instances(5, 5000, shape_param, scale_param, max_item_size)
+    test_data_5k = generate_weibull_instances(5, 5000, shape_param, scale_param, max_item_size)
+    test_data_10k = generate_weibull_instances(5, 10000, shape_param, scale_param, max_item_size)
+    test_data_100k = generate_weibull_instances(1, 100000, shape_param, scale_param, max_item_size)
+
+    # Saving datasets as pickle files, e.g {train_i: {capacity: 100, num_items: 5000, items: [1, 2, 3, ...]},...}
+    weibull_5k_train = {'train_' + str(i): {'capacity': bin_capacity, 'num_items': len(training_data[i]), 'items': training_data[i]} for i in range(len(training_data))}
+    weibull_5k_val = {'val_' + str(i): {'capacity': bin_capacity, 'num_items': len(validation_data[i]), 'items': validation_data[i]} for i in range(len(validation_data))}
+    weibull_5k_test = {'test_' + str(i): {'capacity': bin_capacity, 'num_items': len(test_data_5k[i]), 'items': test_data_5k[i]} for i in range(len(test_data_5k))}
+    weibull_10k_test = {'test_' + str(i): {'capacity': bin_capacity, 'num_items': len(test_data_10k[i]), 'items': test_data_10k[i]} for i in range(len(test_data_10k))}
+    weibull_100k_test = {'test_' + str(i): {'capacity': bin_capacity, 'num_items': len(test_data_100k[i]), 'items': test_data_100k[i]} for i in range(len(test_data_100k))}
+    
+    # Note that weibull_5k_test is provided by Romera-Paredes et al. (https://github.com/google-deepmind/funsearch/blob/main/bin_packing/bin_packing.ipynb).
+    
+    # Add l1_bound to each dataset
+    weibull_5k_train['l1_bound'] = l1_bound_dataset(weibull_5k_train)
+    weibull_5k_val['l1_bound'] = l1_bound_dataset(weibull_5k_val)
+    weibull_5k_test['l1_bound'] = l1_bound_dataset(weibull_5k_test)
+    weibull_10k_test['l1_bound'] = l1_bound_dataset(weibull_10k_test)
+    weibull_100k_test['l1_bound'] = l1_bound_dataset(weibull_100k_test)
+    
+    print(weibull_5k_train['l1_bound'])
+    print(weibull_5k_val['l1_bound'])
+    print(weibull_5k_test['l1_bound'])
+    print(weibull_10k_test['l1_bound'])
+    print(weibull_100k_test['l1_bound'])
+    
+    
+    # Saving datasets as pickle files
+    pickle.dump(weibull_5k_train, open(os.path.join(basepath, 'dataset/weibull_5k_train.pickle'), 'wb'))
+    pickle.dump(weibull_5k_val, open(os.path.join(basepath,'dataset/weibull_5k_val.pickle'), 'wb'))
+    pickle.dump(weibull_5k_test, open(os.path.join(basepath,'dataset/weibull_5k_test.pickle'), 'wb'))
+    pickle.dump(weibull_10k_test, open(os.path.join(basepath,'dataset/weibull_10k_test.pickle'), 'wb'))
+    pickle.dump(weibull_100k_test, open(os.path.join(basepath,'dataset/weibull_100k_test.pickle'), 'wb'))
+
+if __name__ == "__main__":
+    generate_datasets()

bpp_online/problem_description.txt

@@ -0,0 +1,3 @@
+The Online Bin Packing Problem (BPP) is a combinatorial optimization challenge where items of varying sizes arrive sequentially and must be packed into bins of fixed capacity, with the goal of minimizing the total number of bins used while respecting capacity constraints. 
+Items must be assigned to bins immediately upon arrival without knowledge of future items, making it an online decision problem. 
+We use evolutionary search to develop a `priority` heuristic function that give priority scores to available bins based on the current item size and remaining bin capacities, with the goal of minimizing the average number of bins needed across instances (called "score" or "objective" of solution) while approaching the theoretical lower bound.

bpp_online/readme.md

@@ -0,0 +1 @@
+We refer to [Romera-Paredes, B. et al. Mathematical discoveries from program search with large language models. Nature (2023)](https://github.com/google-deepmind/funsearch) for eval.py, test.ipynb, gen_inst.py, and seed.txt.

bpp_online/seed_solution.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+def priority(item: float, bins_remain_cap: np.ndarray) -> np.ndarray:
+    """
+    Best Fit heuristic: prioritize bins with smallest remaining capacity that can still fit the item.
+    """
+    scores = np.zeros_like(bins_remain_cap)
+    
+    # Can the bin fit the item?
+    feasible = bins_remain_cap >= item
+    
+    # For feasible bins: higher priority to bins with LESS remaining space
+    # Invert the capacity so smaller remaining = higher score
+    scores = np.where(feasible, -bins_remain_cap, -np.inf)
+    
+    return scores

bpp_online/seed_solution_idea.txt

@@ -0,0 +1 @@
+Best Fit heuristic: prioritize bins with smallest remaining capacity that can still fit the item.

bpp_online/settings.yaml

@@ -0,0 +1,2 @@
+"function_to_evolve": "priority"
+"obj_type": "min"

cvrp_aco/dataset/test100_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fcf40e6bee3d9b798513a92017eab592539f8226529b696b95475a47a43167d
+size 155264

cvrp_aco/dataset/test20_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de6479d4ee48422e8ffb652e9ad7fa92dcad1be6894547f2267007b97e19b3de
+size 32384

cvrp_aco/dataset/test50_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3370bac48fa37c6d6f23c122a3803e9500fdaaaa57de20c519fe90f57bfd7fa8
+size 78464

cvrp_aco/dataset/train50_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caf38e123b53da4fefda9a988da5f029267d78daf0995d2b68721f6ca8b46452
+size 12368

cvrp_aco/dataset/val100_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5151fa344020005f2f1c402642d421feac2f1fb21db949013a0e611ac1f01df5
+size 155264

cvrp_aco/dataset/val20_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:766597c294673aa329738b988f9ebd6f02ddd87cb62a6e2c0008b4c974ffa5bb
+size 32384

cvrp_aco/dataset/val50_dataset.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c43d1e429036ad6672ac4699e1890edb6349431f501724ec80848f9fd17fde91
+size 78464

cvrp_aco/eval.py

@@ -0,0 +1,333 @@
+# Evaluation script for CVRP-ACO problem
+import os
+import sys
+import traceback
+import numpy as np
+import argparse
+from typing import Dict, List, Tuple, Any
+import torch
+from torch.distributions import Categorical
+from scipy.spatial import distance_matrix
+import inspect
+import seed_solution as solution_module  # Note: solution module script is generated and saved on the fly
+
+
+# =====Load function to evolve=====
+problem = "cvrp_aco"
+heuristics = getattr(solution_module, "heuristics")  # Get function to evolve
+
+
+# =====ACO class=====
+class ACO():
+    def __init__(self,  # 0: depot
+                 distances, # (n, n) distance matrix between all nodes
+                 demand,   # (n, ) demand at each node (0 for depot)
+                 heuristic, # (n, n) heuristic matrix guiding ant movement
+                 capacity,  # vehicle capacity constraint
+                 n_ants=30,  # number of ants in colony
+                 decay=0.9,  # pheromone evaporation rate
+                 alpha=1,    # pheromone importance factor
+                 beta=1,     # heuristic importance factor
+                 device='cpu',  # computation device
+                 ):
+        self.problem_size = len(distances)  # number of nodes including depot
+        self.distances = torch.tensor(distances, device=device) if not isinstance(distances, torch.Tensor) else distances
+        self.demand = torch.tensor(demand, device=device) if not isinstance(demand, torch.Tensor) else demand
+        self.capacity = capacity
+
+        self.n_ants = n_ants
+        self.decay = decay  # pheromone evaporation: τ = τ * decay
+        self.alpha = alpha  # controls pheromone influence: τ^α
+        self.beta = beta    # controls heuristic influence: η^β
+
+        self.pheromone = torch.ones_like(self.distances)  # initial pheromone matrix
+        self.heuristic = torch.tensor(heuristic, device=device) if not isinstance(heuristic, torch.Tensor) else heuristic
+
+        self.shortest_path = None  # best solution found
+        self.lowest_cost = float('inf')  # cost of best solution
+
+        self.device = device
+        
+    @torch.no_grad()
+    def run(self, n_iterations):
+        """Main ACO loop: run for n_iterations"""
+        for _ in range(n_iterations):
+            paths = self.gen_path()  # generate paths for all ants
+            costs = self.gen_path_costs(paths)  # compute total distance for each ant
+
+            best_cost, best_idx = costs.min(dim=0)  # find best ant in this iteration
+            if best_cost < self.lowest_cost:  # update global best if improved
+                self.shortest_path = paths[:, best_idx]
+                self.lowest_cost = best_cost
+
+            self.update_pheronome(paths, costs)  # update pheromone trails
+
+        return self.lowest_cost  # return best cost found
+       
+    @torch.no_grad()
+    def update_pheronome(self, paths, costs):
+        '''
+        Update pheromone trails using ant solutions.
+        Pheromone update rule: τ_ij = τ_ij * decay + Σ(Δτ_ij^k) where Δτ_ij^k = Q/L_k
+
+        Args:
+            paths: torch tensor with shape (problem_size, n_ants) - complete paths for all ants
+            costs: torch tensor with shape (n_ants,) - total distance for each ant
+        '''
+        self.pheromone = self.pheromone * self.decay  # evaporation: τ = τ * ρ
+        for i in range(self.n_ants):
+            path = paths[:, i]  # path for ant i
+            cost = costs[i]     # total distance for ant i
+            # Add pheromone to edges used by this ant: Δτ = Q/L (Q=1 here)
+            # path[:-1] gives current nodes, torch.roll(path, shifts=-1)[:-1] gives next nodes
+            self.pheromone[path[:-1], torch.roll(path, shifts=-1)[:-1]] += 1.0/cost
+        self.pheromone[self.pheromone < 1e-10] = 1e-10  # prevent pheromone from going to zero
+    
+    @torch.no_grad()
+    def gen_path_costs(self, paths):
+        """Compute total distance for each ant's path"""
+        u = paths.permute(1, 0) # shape: (n_ants, max_seq_len) - transpose for easier indexing
+        v = torch.roll(u, shifts=-1, dims=1)  # shift to get next node in sequence
+        # Sum distances between consecutive nodes (excluding last to first wrap-around)
+        return torch.sum(self.distances[u[:, :-1], v[:, :-1]], dim=1)
+
+    def gen_path(self):
+        """Generate complete paths for all ants using constructive heuristic"""
+        actions = torch.zeros((self.n_ants,), dtype=torch.long, device=self.device)  # all ants start at depot (node 0)
+        visit_mask = torch.ones(size=(self.n_ants, self.problem_size), device=self.device)  # 1=unvisited, 0=visited
+        visit_mask = self.update_visit_mask(visit_mask, actions)  # mark depot as visited
+        used_capacity = torch.zeros(size=(self.n_ants,), device=self.device)  # current load for each ant
+
+        used_capacity, capacity_mask = self.update_capacity_mask(actions, used_capacity)  # update capacity constraints
+
+        paths_list = [actions]  # paths_list[i] contains the ith move for all ants
+
+        done = self.check_done(visit_mask, actions)
+        while not done:
+            actions = self.pick_move(actions, visit_mask, capacity_mask)  # probabilistic node selection
+            paths_list.append(actions)  # record move
+            visit_mask = self.update_visit_mask(visit_mask, actions)  # update visited nodes
+            used_capacity, capacity_mask = self.update_capacity_mask(actions, used_capacity)  # update capacity
+            done = self.check_done(visit_mask, actions)  # check termination
+
+        return torch.stack(paths_list)  # shape: (seq_len, n_ants)
+        
+    def pick_move(self, prev, visit_mask, capacity_mask):
+        """Probabilistic node selection using transition probability: p_ij ∝ τ_ij^α * η_ij^β"""
+        pheromone = self.pheromone[prev]  # shape: (n_ants, p_size) - pheromone on edges from current nodes
+        heuristic = self.heuristic[prev]  # shape: (n_ants, p_size) - heuristic values from current nodes
+        # Transition probability: p_ij = (τ_ij^α * η_ij^β) / Σ(τ_ik^α * η_ik^β)
+        # Masked by visit_mask (unvisited nodes) and capacity_mask (feasible nodes)
+        dist = ((pheromone ** self.alpha) * (heuristic ** self.beta) * visit_mask * capacity_mask)  # shape: (n_ants, p_size)
+        dist = Categorical(dist)  # create categorical distribution
+        actions = dist.sample()  # shape: (n_ants,) - sample next node for each ant
+        return actions
+    
+    def update_visit_mask(self, visit_mask, actions):
+        """Update mask of unvisited nodes after moving to new nodes"""
+        visit_mask[torch.arange(self.n_ants, device=self.device), actions] = 0  # mark new nodes as visited
+        visit_mask[:, 0] = 1  # depot can always be revisited (for returning/starting new route)
+        # Exception: if ant returns to depot AND still has unvisited customers, don't allow immediate return
+        # This prevents depot-depot cycles when work remains
+        visit_mask[(actions==0) * (visit_mask[:, 1:]!=0).any(dim=1), 0] = 0
+        return visit_mask
+    
+    def update_capacity_mask(self, cur_nodes, used_capacity):
+        '''
+        Update vehicle capacity constraints and create mask of feasible next nodes.
+
+        Args:
+            cur_nodes: shape (n_ants, ) - current node for each ant
+            used_capacity: shape (n_ants, ) - current load for each ant
+
+        Returns:
+            used_capacity: updated capacity after visiting cur_nodes
+            capacity_mask: mask where 1=feasible (demand ≤ remaining capacity), 0=infeasible
+        '''
+        capacity_mask = torch.ones(size=(self.n_ants, self.problem_size), device=self.device)
+        # update capacity: reset to 0 when returning to depot, add demand of current node
+        used_capacity[cur_nodes==0] = 0  # reset load when returning to depot
+        used_capacity = used_capacity + self.demand[cur_nodes]  # add demand of current node
+
+        # update capacity_mask: mask out nodes whose demand exceeds remaining capacity
+        remaining_capacity = self.capacity - used_capacity  # (n_ants,) - remaining capacity for each ant
+        remaining_capacity_repeat = remaining_capacity.unsqueeze(-1).repeat(1, self.problem_size)  # (n_ants, p_size)
+        demand_repeat = self.demand.unsqueeze(0).repeat(self.n_ants, 1)  # (n_ants, p_size) - demand of all nodes
+        capacity_mask[demand_repeat > remaining_capacity_repeat] = 0  # mask infeasible nodes
+
+        return used_capacity, capacity_mask
+    
+    def check_done(self, visit_mask, actions):
+        """Check termination condition: all customers visited and all ants at depot"""
+        # All customers (nodes 1..n) visited AND all ants currently at depot (node 0)
+        return (visit_mask[:, 1:] == 0).all() and (actions == 0).all()  
+
+
+# =====Evaluation function=====
+N_ITERATIONS = 50  # number of ACO iterations
+N_ANTS = 30         # number of ants in colony
+CAPACITY = 50       # vehicle capacity
+
+def evaluate_heuristic(node_pos, demand):
+    """Evaluate a heuristic function using ACO on a CVRP instance"""
+    # Compute distance matrix between all nodes
+    dist_mat = distance_matrix(node_pos, node_pos)
+    dist_mat[np.diag_indices_from(dist_mat)] = 1  # set diagonal to 1 (avoid division by zero in heuristics)
+
+    # Call the heuristic function (evolved code) with appropriate arguments
+    # The heuristic function can have different signatures (2 or 4 args)
+    if len(inspect.getfullargspec(heuristics).args) == 4:
+        # Signature: heuristics(dist_mat, node_pos, demand, capacity)
+        heu = heuristics(dist_mat.copy(), node_pos.copy(), demand.copy(), CAPACITY) + 1e-9
+    elif len(inspect.getfullargspec(heuristics).args) == 2:
+        # Signature: heuristics(dist_mat, normalized_demand)
+        heu = heuristics(dist_mat.copy(), demand / CAPACITY) + 1e-9
+
+    heu[heu < 1e-9] = 1e-9  # ensure heuristic values are positive
+
+    # Run ACO with the computed heuristic matrix
+    aco = ACO(dist_mat, demand, heu, CAPACITY, n_ants=N_ANTS)
+    obj = aco.run(N_ITERATIONS)  # get best solution cost
+    return obj
+
+
+# =====Helper functions=====
+def get_feature(metrics: Dict[int, float]) -> Tuple[int, ...]:
+    """
+    Convert the metrics dict to a feature vector
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (tuple): a tuple of discretized scores sorted by problem size
+    """
+    scores = metrics.values()
+    features = tuple([int(x) for x in scores])
+    return features
+    
+def get_score(metrics: Dict[int, float]) -> float:
+    """
+    Convert the metrics dict to a score
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (float): a score
+    """
+    return sum(metrics.values()) / len(metrics)
+
+
+# =====Main function=====
+if __name__ == "__main__":
+    # -----Parse command line arguments (same for all problems)-----
+    parser = argparse.ArgumentParser(description='Evaluation script.')
+    parser.add_argument(
+        '--root_dir',
+        type=str,
+        default=os.getcwd(),
+        help='Project root directory for loading data (default: current working directory)'
+    )
+    parser.add_argument(
+        '--file_output_prefix',
+        type=str,
+        default='',
+        help='Output file prefix for saving evaluation results. '
+             'Absolute path recommended. Files saved as {prefix}filename '
+             '(default: empty string, saves to current directory)')
+    parser.add_argument(
+        '--mode',
+        type=str,
+        default='val',
+        choices=['train', 'val'],
+        help='Execution mode: train or val (default: val)'
+    )
+    parser.add_argument(
+        '--problem_size',
+        type=int,
+        default=50,  # Customize this to your needs
+        help='Problem size parameter'
+    )
+    # Parse arguments
+    args = parser.parse_args()
+    root_dir = args.root_dir
+    file_output_prefix = args.file_output_prefix
+    mode = args.mode
+    problem_size = args.problem_size
+    # Print parsed arguments for verification
+    print(f"root_dir: {root_dir}")
+    print(f"file_output_prefix: {file_output_prefix}")
+    print(f"mode: {mode}")
+    #print(f"problem_size: {problem_size}")
+    
+    # -----Run the evaluation-----
+    # Run instances: 20, 50, 100; execution time: 170s
+    try:
+        basepath = os.path.join(root_dir, "problems", problem)
+        if not os.path.isfile(os.path.join(basepath, "dataset/train50_dataset.npy")):
+            raise FileNotFoundError("[!] Dataset not found.")
+        
+        if mode == 'train':
+            dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npy")
+            dataset = np.load(dataset_path)
+            demands, node_positions = dataset[:, :, 0], dataset[:, :, 1:]
+            
+            n_instances = node_positions.shape[0]
+            print(f"[*] Dataset loaded: {dataset_path} with {n_instances} instances.")
+            
+            objs = []
+            for i, (node_pos, demand) in enumerate(zip(node_positions, demands)):
+                obj = evaluate_heuristic(node_pos, demand)
+                print(f"[*] Instance {i}: {obj}")
+                objs.append(obj.item())
+            
+            print("[*] Average:")
+            print(np.mean(objs))
+        else:  # mode: "val"
+            metrics = {}
+            for problem_size in [20, 50]:  # options: 20, 50, 100
+                dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npy")
+                dataset = np.load(dataset_path)
+                demands, node_positions = dataset[:, :, 0], dataset[:, :, 1:]
+                
+                n_instances = node_positions.shape[0]
+                print(f"[*] Evaluating {dataset_path}")
+                
+                objs = []
+                for i, (node_pos, demand) in enumerate(zip(node_positions, demands)):
+                    obj = evaluate_heuristic(node_pos, demand)
+                    objs.append(obj.item())
+                
+                print(f"[*] Average for {problem_size}: {np.mean(objs)}")
+                metrics[problem_size] = float(np.mean(objs))
+                
+        if metrics:
+            features = get_feature(metrics)
+            score = get_score(metrics)
+        else:
+            features = None
+            score = None
+
+        # -----Print results to stdout (same for all problems)-----
+        print('__SANDBOX_RESULT__')        
+        print('__METRICS_START__')
+        print(repr(metrics))
+        print('__METRICS_END__')
+        
+        print('__FEATURES_START__')
+        print(repr(features))
+        print('__FEATURES_END__')
+        
+        print('__SCORE_START__')
+        print(repr(score))
+        print('__SCORE_END__')
+        
+        print('__SANDBOX_SUCCESS__')
+        
+    except Exception as e:
+        print('__SANDBOX_ERROR__:')
+        print(f'Error type: {type(e).__name__}')
+        print(f'Error message: {str(e)}')
+        print('Full traceback:')
+        traceback.print_exc()

cvrp_aco/evaluation_description.txt

@@ -0,0 +1,337 @@
+The evaluation script for the problem is described below.
+
+```python
+# Evaluation script for CVRP-ACO problem
+import os
+import sys
+import traceback
+import numpy as np
+import argparse
+from typing import Dict, List, Tuple, Any
+import torch
+from torch.distributions import Categorical
+from scipy.spatial import distance_matrix
+import inspect
+import seed_solution as solution_module  # Note: solution module script is generated and saved on the fly
+
+
+# =====Load function to evolve=====
+problem = "cvrp_aco"
+heuristics = getattr(solution_module, "heuristics")  # Get function to evolve
+
+
+# =====ACO class=====
+class ACO():
+    def __init__(self,  # 0: depot
+                 distances, # (n, n) distance matrix between all nodes
+                 demand,   # (n, ) demand at each node (0 for depot)
+                 heuristic, # (n, n) heuristic matrix guiding ant movement
+                 capacity,  # vehicle capacity constraint
+                 n_ants=30,  # number of ants in colony
+                 decay=0.9,  # pheromone evaporation rate
+                 alpha=1,    # pheromone importance factor
+                 beta=1,     # heuristic importance factor
+                 device='cpu',  # computation device
+                 ):
+        self.problem_size = len(distances)  # number of nodes including depot
+        self.distances = torch.tensor(distances, device=device) if not isinstance(distances, torch.Tensor) else distances
+        self.demand = torch.tensor(demand, device=device) if not isinstance(demand, torch.Tensor) else demand
+        self.capacity = capacity
+
+        self.n_ants = n_ants
+        self.decay = decay  # pheromone evaporation: τ = τ * decay
+        self.alpha = alpha  # controls pheromone influence: τ^α
+        self.beta = beta    # controls heuristic influence: η^β
+
+        self.pheromone = torch.ones_like(self.distances)  # initial pheromone matrix
+        self.heuristic = torch.tensor(heuristic, device=device) if not isinstance(heuristic, torch.Tensor) else heuristic
+
+        self.shortest_path = None  # best solution found
+        self.lowest_cost = float('inf')  # cost of best solution
+
+        self.device = device
+        
+    @torch.no_grad()
+    def run(self, n_iterations):
+        """Main ACO loop: run for n_iterations"""
+        for _ in range(n_iterations):
+            paths = self.gen_path()  # generate paths for all ants
+            costs = self.gen_path_costs(paths)  # compute total distance for each ant
+
+            best_cost, best_idx = costs.min(dim=0)  # find best ant in this iteration
+            if best_cost < self.lowest_cost:  # update global best if improved
+                self.shortest_path = paths[:, best_idx]
+                self.lowest_cost = best_cost
+
+            self.update_pheronome(paths, costs)  # update pheromone trails
+
+        return self.lowest_cost  # return best cost found
+       
+    @torch.no_grad()
+    def update_pheronome(self, paths, costs):
+        '''
+        Update pheromone trails using ant solutions.
+        Pheromone update rule: τ_ij = τ_ij * decay + Σ(Δτ_ij^k) where Δτ_ij^k = Q/L_k
+
+        Args:
+            paths: torch tensor with shape (problem_size, n_ants) - complete paths for all ants
+            costs: torch tensor with shape (n_ants,) - total distance for each ant
+        '''
+        self.pheromone = self.pheromone * self.decay  # evaporation: τ = τ * ρ
+        for i in range(self.n_ants):
+            path = paths[:, i]  # path for ant i
+            cost = costs[i]     # total distance for ant i
+            # Add pheromone to edges used by this ant: Δτ = Q/L (Q=1 here)
+            # path[:-1] gives current nodes, torch.roll(path, shifts=-1)[:-1] gives next nodes
+            self.pheromone[path[:-1], torch.roll(path, shifts=-1)[:-1]] += 1.0/cost
+        self.pheromone[self.pheromone < 1e-10] = 1e-10  # prevent pheromone from going to zero
+    
+    @torch.no_grad()
+    def gen_path_costs(self, paths):
+        """Compute total distance for each ant's path"""
+        u = paths.permute(1, 0) # shape: (n_ants, max_seq_len) - transpose for easier indexing
+        v = torch.roll(u, shifts=-1, dims=1)  # shift to get next node in sequence
+        # Sum distances between consecutive nodes (excluding last to first wrap-around)
+        return torch.sum(self.distances[u[:, :-1], v[:, :-1]], dim=1)
+
+    def gen_path(self):
+        """Generate complete paths for all ants using constructive heuristic"""
+        actions = torch.zeros((self.n_ants,), dtype=torch.long, device=self.device)  # all ants start at depot (node 0)
+        visit_mask = torch.ones(size=(self.n_ants, self.problem_size), device=self.device)  # 1=unvisited, 0=visited
+        visit_mask = self.update_visit_mask(visit_mask, actions)  # mark depot as visited
+        used_capacity = torch.zeros(size=(self.n_ants,), device=self.device)  # current load for each ant
+
+        used_capacity, capacity_mask = self.update_capacity_mask(actions, used_capacity)  # update capacity constraints
+
+        paths_list = [actions]  # paths_list[i] contains the ith move for all ants
+
+        done = self.check_done(visit_mask, actions)
+        while not done:
+            actions = self.pick_move(actions, visit_mask, capacity_mask)  # probabilistic node selection
+            paths_list.append(actions)  # record move
+            visit_mask = self.update_visit_mask(visit_mask, actions)  # update visited nodes
+            used_capacity, capacity_mask = self.update_capacity_mask(actions, used_capacity)  # update capacity
+            done = self.check_done(visit_mask, actions)  # check termination
+
+        return torch.stack(paths_list)  # shape: (seq_len, n_ants)
+        
+    def pick_move(self, prev, visit_mask, capacity_mask):
+        """Probabilistic node selection using transition probability: p_ij ∝ τ_ij^α * η_ij^β"""
+        pheromone = self.pheromone[prev]  # shape: (n_ants, p_size) - pheromone on edges from current nodes
+        heuristic = self.heuristic[prev]  # shape: (n_ants, p_size) - heuristic values from current nodes
+        # Transition probability: p_ij = (τ_ij^α * η_ij^β) / Σ(τ_ik^α * η_ik^β)
+        # Masked by visit_mask (unvisited nodes) and capacity_mask (feasible nodes)
+        dist = ((pheromone ** self.alpha) * (heuristic ** self.beta) * visit_mask * capacity_mask)  # shape: (n_ants, p_size)
+        dist = Categorical(dist)  # create categorical distribution
+        actions = dist.sample()  # shape: (n_ants,) - sample next node for each ant
+        return actions
+    
+    def update_visit_mask(self, visit_mask, actions):
+        """Update mask of unvisited nodes after moving to new nodes"""
+        visit_mask[torch.arange(self.n_ants, device=self.device), actions] = 0  # mark new nodes as visited
+        visit_mask[:, 0] = 1  # depot can always be revisited (for returning/starting new route)
+        # Exception: if ant returns to depot AND still has unvisited customers, don't allow immediate return
+        # This prevents depot-depot cycles when work remains
+        visit_mask[(actions==0) * (visit_mask[:, 1:]!=0).any(dim=1), 0] = 0
+        return visit_mask
+    
+    def update_capacity_mask(self, cur_nodes, used_capacity):
+        '''
+        Update vehicle capacity constraints and create mask of feasible next nodes.
+
+        Args:
+            cur_nodes: shape (n_ants, ) - current node for each ant
+            used_capacity: shape (n_ants, ) - current load for each ant
+
+        Returns:
+            used_capacity: updated capacity after visiting cur_nodes
+            capacity_mask: mask where 1=feasible (demand ≤ remaining capacity), 0=infeasible
+        '''
+        capacity_mask = torch.ones(size=(self.n_ants, self.problem_size), device=self.device)
+        # update capacity: reset to 0 when returning to depot, add demand of current node
+        used_capacity[cur_nodes==0] = 0  # reset load when returning to depot
+        used_capacity = used_capacity + self.demand[cur_nodes]  # add demand of current node
+
+        # update capacity_mask: mask out nodes whose demand exceeds remaining capacity
+        remaining_capacity = self.capacity - used_capacity  # (n_ants,) - remaining capacity for each ant
+        remaining_capacity_repeat = remaining_capacity.unsqueeze(-1).repeat(1, self.problem_size)  # (n_ants, p_size)
+        demand_repeat = self.demand.unsqueeze(0).repeat(self.n_ants, 1)  # (n_ants, p_size) - demand of all nodes
+        capacity_mask[demand_repeat > remaining_capacity_repeat] = 0  # mask infeasible nodes
+
+        return used_capacity, capacity_mask
+    
+    def check_done(self, visit_mask, actions):
+        """Check termination condition: all customers visited and all ants at depot"""
+        # All customers (nodes 1..n) visited AND all ants currently at depot (node 0)
+        return (visit_mask[:, 1:] == 0).all() and (actions == 0).all()  
+
+
+# =====Evaluation function=====
+N_ITERATIONS = 50  # number of ACO iterations
+N_ANTS = 30         # number of ants in colony
+CAPACITY = 50       # vehicle capacity
+
+def evaluate_heuristic(node_pos, demand):
+    """Evaluate a heuristic function using ACO on a CVRP instance"""
+    # Compute distance matrix between all nodes
+    dist_mat = distance_matrix(node_pos, node_pos)
+    dist_mat[np.diag_indices_from(dist_mat)] = 1  # set diagonal to 1 (avoid division by zero in heuristics)
+
+    # Call the heuristic function (evolved code) with appropriate arguments
+    # The heuristic function can have different signatures (2 or 4 args)
+    if len(inspect.getfullargspec(heuristics).args) == 4:
+        # Signature: heuristics(dist_mat, node_pos, demand, capacity)
+        heu = heuristics(dist_mat.copy(), node_pos.copy(), demand.copy(), CAPACITY) + 1e-9
+    elif len(inspect.getfullargspec(heuristics).args) == 2:
+        # Signature: heuristics(dist_mat, normalized_demand)
+        heu = heuristics(dist_mat.copy(), demand / CAPACITY) + 1e-9
+
+    heu[heu < 1e-9] = 1e-9  # ensure heuristic values are positive
+
+    # Run ACO with the computed heuristic matrix
+    aco = ACO(dist_mat, demand, heu, CAPACITY, n_ants=N_ANTS)
+    obj = aco.run(N_ITERATIONS)  # get best solution cost
+    return obj
+
+
+# =====Helper functions=====
+def get_feature(metrics: Dict[int, float]) -> Tuple[int, ...]:
+    """
+    Convert the metrics dict to a feature vector
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (tuple): a tuple of discretized scores sorted by problem size
+    """
+    scores = metrics.values()
+    features = tuple([int(x) for x in scores])
+    return features
+    
+def get_score(metrics: Dict[int, float]) -> float:
+    """
+    Convert the metrics dict to a score
+
+    Args:
+        metrics (dict): A mapping of test problem size (int) to a score (float).
+
+    Returns:
+        (float): a score
+    """
+    return sum(metrics.values()) / len(metrics)
+
+
+# =====Main function=====
+if __name__ == "__main__":
+    # -----Parse command line arguments (same for all problems)-----
+    parser = argparse.ArgumentParser(description='Evaluation script.')
+    parser.add_argument(
+        '--root_dir',
+        type=str,
+        default=os.getcwd(),
+        help='Project root directory for loading data (default: current working directory)'
+    )
+    parser.add_argument(
+        '--file_output_prefix',
+        type=str,
+        default='',
+        help='Output file prefix for saving evaluation results. '
+             'Absolute path recommended. Files saved as {prefix}filename '
+             '(default: empty string, saves to current directory)')
+    parser.add_argument(
+        '--mode',
+        type=str,
+        default='val',
+        choices=['train', 'val'],
+        help='Execution mode: train or val (default: val)'
+    )
+    parser.add_argument(
+        '--problem_size',
+        type=int,
+        default=50,  # Customize this to your needs
+        help='Problem size parameter'
+    )
+    # Parse arguments
+    args = parser.parse_args()
+    root_dir = args.root_dir
+    file_output_prefix = args.file_output_prefix
+    mode = args.mode
+    problem_size = args.problem_size
+    # Print parsed arguments for verification
+    print(f"root_dir: {root_dir}")
+    print(f"file_output_prefix: {file_output_prefix}")
+    print(f"mode: {mode}")
+    #print(f"problem_size: {problem_size}")
+    
+    # -----Run the evaluation-----
+    # Run instances: 20, 50, 100; execution time: 170s
+    try:
+        basepath = os.path.join(root_dir, "problems", problem)
+        if not os.path.isfile(os.path.join(basepath, "dataset/train50_dataset.npy")):
+            raise FileNotFoundError("[!] Dataset not found.")
+        
+        if mode == 'train':
+            dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npy")
+            dataset = np.load(dataset_path)
+            demands, node_positions = dataset[:, :, 0], dataset[:, :, 1:]
+            
+            n_instances = node_positions.shape[0]
+            print(f"[*] Dataset loaded: {dataset_path} with {n_instances} instances.")
+            
+            objs = []
+            for i, (node_pos, demand) in enumerate(zip(node_positions, demands)):
+                obj = evaluate_heuristic(node_pos, demand)
+                print(f"[*] Instance {i}: {obj}")
+                objs.append(obj.item())
+            
+            print("[*] Average:")
+            print(np.mean(objs))
+        else:  # mode: "val"
+            metrics = {}
+            for problem_size in [20, 50]:  # options: 20, 50, 100
+                dataset_path = os.path.join(basepath, f"dataset/{mode}{problem_size}_dataset.npy")
+                dataset = np.load(dataset_path)
+                demands, node_positions = dataset[:, :, 0], dataset[:, :, 1:]
+                
+                n_instances = node_positions.shape[0]
+                print(f"[*] Evaluating {dataset_path}")
+                
+                objs = []
+                for i, (node_pos, demand) in enumerate(zip(node_positions, demands)):
+                    obj = evaluate_heuristic(node_pos, demand)
+                    objs.append(obj.item())
+                
+                print(f"[*] Average for {problem_size}: {np.mean(objs)}")
+                metrics[problem_size] = np.mean(objs)
+                
+        if metrics:
+            features = get_feature(metrics)
+            score = get_score(metrics)
+        else:
+            features = None
+            score = None
+
+        # -----Print results to stdout (same for all problems)-----
+        print('__SANDBOX_RESULT__')        
+        print('__METRICS_START__')
+        print(repr(metrics))
+        print('__METRICS_END__')
+        
+        print('__FEATURES_START__')
+        print(repr(features))
+        print('__FEATURES_END__')
+        
+        print('__SCORE_START__')
+        print(repr(score))
+        print('__SCORE_END__')
+        
+        print('__SANDBOX_SUCCESS__')
+        
+    except Exception as e:
+        print('__SANDBOX_ERROR__:')
+        print(f'Error type: {type(e).__name__}')
+        print(f'Error message: {str(e)}')
+        print('Full traceback:')
+        traceback.print_exc()
+```

cvrp_aco/external_knowledge.txt

@@ -0,0 +1,2 @@
+- Try combining various factors to determine how promising it is to select an edge.
+- Try sparsifying the matrix by setting unpromising elements to zero.

cvrp_aco/function_description.txt

@@ -0,0 +1,8 @@
+The `heuristics` function takes as input a distance matrix (shape: n by n), Euclidean coordinates of nodes (shape: n by 2), a vector of customer demands (shape: n), and the integer capacity of vehicle capacity. 
+It returns prior indicators of how promising it is to include each edge in a solution. 
+The return is of the same shape as the distance_matrix. The depot node is indexed by 0.
+
+### Solution Function Signature
+```python
+def heuristics(distance_matrix: np.ndarray, coordinates: np.ndarray, demands: np.ndarray, capacity: int) -> np.ndarray:
+```

cvrp_aco/generate_dataset.py

@@ -0,0 +1,51 @@
+import os
+import numpy as np
+
+CAPACITY = 50
+DEMAND_LOW = 1
+DEMAND_HIGH = 9
+DEPOT_COOR = [0.5, 0.5]
+
+def gen_instance(n):
+    locations = np.random.rand(n, 2)
+    demands = np.random.randint(low=DEMAND_LOW, high=DEMAND_HIGH+1, size=n)
+    depot = np.array([DEPOT_COOR])
+    all_locations = np.concatenate((depot, locations), axis=0)
+    all_demands = np.concatenate((np.zeros(1,), demands))
+    return np.concatenate((all_demands.reshape(-1, 1), all_locations), axis=1)
+
+def generate_datasets():
+    basepath = os.path.dirname(__file__)
+    os.makedirs(os.path.join(basepath, "dataset"), exist_ok=True)
+    
+    np.random.seed(1234)
+    
+    for problem_size in [50]:
+        n_instances = 10
+        dataset = []
+        for i in range(n_instances):
+            inst = gen_instance(problem_size)
+            dataset.append(inst)
+        dataset = np.array(dataset)
+        np.save(os.path.join(basepath, f'dataset/train{problem_size}_dataset.npy'), dataset)
+
+    for problem_size in [20, 50, 100]:
+        n_instances = 64
+        dataset = []
+        for i in range(n_instances):
+            inst = gen_instance(problem_size)
+            dataset.append(inst)
+        dataset = np.array(dataset)
+        np.save(os.path.join(basepath, f'dataset/val{problem_size}_dataset.npy'), dataset)
+    
+    for problem_size in [20, 50, 100]:
+        n_instances = 64
+        dataset = []
+        for i in range(n_instances):
+            inst = gen_instance(problem_size)
+            dataset.append(inst)
+        dataset = np.array(dataset)
+        np.save(os.path.join(basepath, f'dataset/test{problem_size}_dataset.npy'), dataset)
+
+if __name__ == "__main__":
+    generate_datasets()

cvrp_aco/problem_description.txt

@@ -0,0 +1,3 @@
+The Capacitated Vehicle Routing Problem (CVRP) is a combinatorial optimization challenge where vehicles with limited capacity must deliver goods from a central depot to multiple customer locations, minimizing total travel distance while respecting vehicle capacity constraints. 
+We use Ant Colony Optimization (ACO) to solve this problem, where artificial ants probabilistically construct routes guided by pheromone trails and heuristic information. 
+Your task is to evolve a `heuristics` function that generates a heuristic matrix to guide ant movement, with the goal of minimizing the total distance traveled across all vehicle routes (called "score" or "objective" of solution).

cvrp_aco/seed_solution.py

@@ -0,0 +1,4 @@
+import numpy as np
+
+def heuristics(distance_matrix: np.ndarray, coordinates: np.ndarray, demands: np.ndarray, capacity: int) -> np.ndarray:
+    return 1 / distance_matrix

cvrp_aco/seed_solution_idea.txt

@@ -0,0 +1,2 @@
+This heuristic implementation uses a simple inverse distance approach: heuristics = 1 / distance_matrix. 
+This creates a heuristic matrix where closer nodes have higher heuristic values, guiding ants to prefer shorter edges during path construction.