Evolving Generalizable Parallel Algorithm Portfolios via Domain-Agnostic Instance Generation
Abstract
Generalization is the core objective when training optimizers from data. However, limited training instances often constrain the generalization capability of the trained optimizers. Co-evolutionary approaches address this challenge by simultaneously evolving a parallel algorithm portfolio (PAP) and an instance population to eventually obtain PAPs with good generalization. Yet, when applied to a specific problem class, these approaches have a major limitation. They require practitioners to provide instance generators specially tailored to the problem class, which is often non-trivial to design. This work proposes a general-purpose, off-the-shelf PAP construction approach, named domain-agnostic co-evolution of parameterized search (DACE), for binary optimization problems where decision variables take values of 0 or 1. The key novelty of DACE lies in its neural network-based domain-agnostic instance representation and generation mechanism that eliminates the need for domain-specific instance generators. The strong generality of DACE is validated across three real-world binary optimization problems: the complementary influence maximization problem (CIMP), the compiler arguments optimization problem (CAOP), and the contamination control problem (CCP). Given only a small set of training instances from these problem classes, DACE, without requiring domain knowledge, constructs PAPs with even better generalization performance than existing approaches on all three classes, despite their use of domain-specific instance generators.
Keywords: Algorithm configuration, parallel algorithm portfolios, automatic algorithm design, co-evolutionary algorithm, binary optimization problem
1Introduction
In recent decades, search-based methods such as Evolutionary Algorithms (EAs) have become the mainstream approach for solving NP-hard optimization problems [1]-[4]. Most, if not all, of these methods involve a set of free parameters that would affect their search behavior. While theoretical analyzes for many search-based methods have offered worst or average bounds on their performance, their actual performance in practice is highly sensitive to the settings of parameters, i.e., algorithm configurations. However, finding the optimal algorithm configurations requires both domain-specific knowledge and algorithmic expertise, which cannot be done manually with ease. In response to this, significant efforts have been made to automate the tuning procedure, commonly referred to as automatic parameter tuning [5] and automatic algorithm configuration (AAC) [6]-[8]. Typically, AAC follows a high-level generate-and-evaluate process, where different configurations are iteratively generated and evaluated on a given set of problem instances, i.e., the training set. Upon termination, the best-performing configuration is returned. Since an algorithm configuration fully instantiates a parameterized algorithm, for brevity, throughout this article we will use the term "configuration" to refer to the resultant algorithm.
Building upon AAC, a series of works have been conducted to identify a set of configurations instead of a single configuration to form a parallel algorithm portfolio (PAP), referred to as automatic construction of PAPs [9]-[12]. Each configuration in the PAP is called a member algorithm. When applied to a problem instance, all member algorithms in the PAP run independently in parallel to obtain multiple solutions, from which the best solution is returned. Although a PAP consumes more computational resources than a single algorithm, it can achieve superior overall performance than any single algorithm through the complementary strengths of its member algorithms [13],[14]. That is, different member algorithms of the PAP excel at solving different types of problem instances. Moreover, PAPs employ simple parallel solution strategies, making them well-suited to exploit modern computing facilities (e.g., multi-core CPUs). Nowadays, such capability has become increasingly crucial for tackling computationally challenging problems [15], given the tremendous advancement of parallel computing architectures in the past decade [16].
Generalization is the core objective in the automatic construction of PAPs [11]. It requires that the constructed PAP performs well not only on instances within the training set but also on unseen instances from the same problem class. Given a training set that sufficiently represents the problem class, existing approaches have proven highly effective in constructing PAPs with good generalization [9],[10],[17],[18]. However, in real-world applications, one is very likely to encounter the few-shots scenarios, where the collected training instances are limited and biased (e.g., sampled from a specific distribution) and thus fail to sufficiently represent the target problem class [19]. To address this challenge, recent studies have explored integrating instance generation into the construction process [11],[12],[20]. One representative approach is the co-evolution of parameterized search (CEPS) [11] that maintains two competing populations during evolution: a configuration population (PAP) and a problem instance population. The evolution of the instance population aims to identify challenging instances that exploit weaknesses in the current PAP, while the evolution of the PAP improves its generalization by identifying configurations that better handle these instances.
Although CEPS has shown promising performance in few-shot scenarios, it has one major limitation. That is, CEPS fundamentally relies on domain-specific instance generators, which significantly limits its generality and practical applicability. As shown in Fig. 1, when applying CEPS to a specific problem class, one needs to provide instance generators tailored to the problem class to generate problem instances during the evolution of the instance population. As demonstrated in [11], when applying CEPS to the traveling salesman problem (TSP), Tang et al. developed a TSP-specific instance mutation operator based on 2D coordinate representations of TSP instances. However, designing such generators requires comprehensive knowledge of the problem class, including suitable instance representations and corresponding variation mechanisms. This becomes particularly challenging for newly emerging optimization problems and black-box problems where such knowledge is not readily available. For example, consider the compiler argument optimization problem [21], which aims to find the optimal compiler argument settings to minimize the size of the binary file generated from compiling a given program source code. For such a problem, the instance generator should be able to create new yet valid program source code - a task that demands deep understanding of program syntax and semantics.
This work proposes a novel PAP construction approach called domain-agnostic co-evolution of parameterized search (DACE). The term "domain-agnostic" refers specifically to the problem domain. That is, unlike existing methods requiring domain-specific instance generators built upon a problem instance's structural information (e.g., the TSP instance generator as described above), DACE has a general-purpose generator that does not need such information. This allows DACE to be applicable to diverse binary optimization problem classes where variables take 0/1 values. Such problems are widespread in practice, e.g., appearing in combinatorial optimizationTheoretically, any discrete optimization problem can be reformulated as a binary optimization problem., discrete facility location, and certain graph problems (e.g., max cut and max coverage).
As shown in Fig. 1, the key novelty of DACE lies in its universal, domain-agnostic neural network-based representation of problem instances and its mechanism for evolving these neural networks to generate new problem instances. Additionally, DACE automatically extracts domain-invariant features from training instances and uses these features to constrain instance generation, ensuring the generated instances are meaningful. In essence, DACE addresses the challenge of representing and generating instances of binary optimization problems without domain-specific knowledge, an area that remains largely unexplored in existing research (as discussed further in Section 2.3).
DACE follows the same co-evolutionary framework as CEPS where a configuration population (PAP) and a problem instance population compete with each other; therefore it is particularly well-suited for constructing generalizable PAPs in few-shot scenarios. Compared to CEPS, DACE offers a significant advantage in terms of generality and practical applicability. In particular, DACE requires only a small set of training instances from the problem class and no domain-specific instance generators. Furthermore, and importantly, these training instances can be provided purely as black boxes, where only solution evaluation (i.e., input a solution and output a fitness score) is available without access to the analytic form of the objective function. This means DACE can readily construct PAPs for black-box optimization problems. In contrast, existing PAP construction approaches with reliance on domain-specific instance generators face significant challenges with such problems.
The main contributions of this work are summarized below.
A novel PAP construction approach, namely DACE, is proposed. By eliminating the need for domain-specific instance generators, DACE is a general-purpose, off-the-shelf PAP construction approach for binary optimization problems.
The strong generality of DACE is validated across three real-world binary optimization problems including a black-box problem. Compared to CEPS with expert-crafted domain-specific instance generators, for DACE, a method requiring no domain-specific knowledge, our baseline expectation is to achieve performance comparable to CEPS. Surprisingly, DACE not only matches but actually outperforms CEPS across all three problems.
The proposed domain-agnostic instance representation and generation approach serves as a general data augmentation technique, which not only benefits PAP construction but also opens up new possibilities for training broad classes of optimizers, i.e., learning to optimize (L2O) [22].
The remainder of this article is organized as follows. Section 2 introduces the problem of seeking generalizable PAPs in few-shot scenarios, as well as existing PAP construction and problem instance generation methods. Section 3 presents DACE's domain-agnostic instance representation and generation, followed by its complete framework in Section 4. Computational studies are presented in Section 5. Section 6 concludes the article with discussions.
2Few-Shot Construction of Generalizable PAPs
2.1Notations and Problem Description
Assume a PAP is to be built for a problem class, for which we denote a problem instance as \(s\) and the set of all possible instances as \(\Omega\). Given a parameterized optimization algorithm with its configuration space \(\Theta\), each \(\theta \in \Theta\) is an algorithm configuration that fully instantiates the algorithm. Let \(P=\left\{\theta_1,\theta_2,\cdots,\theta_K\right\}\) denote a PAP that consists of \(K\) configurations as its member algorithms. For any problem instance \(s \in \Omega\) and configuration \(\theta \in \Theta\), let \(f\left(\theta, s\right)\) denote the performance of \(\theta\) on \(s\). In practice, this indicator can measure various aspects of performance such as solution quality [7], computational efficiency [23], or even be stated in a multi-objective form [24]. Without loss of generality, we assume larger values indicate better performance. The performance of \(P\) on instance \(s\) is the best performance achieved among its member algorithms \(\theta_1,\theta_2,\cdots,\theta_K\) on \(s\):
The goal is to identify \(K\) configurations \(\theta_1,\ldots,\theta_K\) from \(\Theta\) to form a PAP \(P\) that achieves the optimal generalization performance over \(\Omega\):
Here, \(p(s)\) denotes the prior probability distribution of instances in \(\Omega\). Since the prior distribution is typically unknown in practice, a uniform distribution can be assumed without loss of generality. Then Eq. (2) simplifies to Eq. (3) by omitting a normalization constant:
In practice, directly optimizing Eq. (3) is intractable since the set \(\Omega\) is generally unavailable. Instead, only a set of training instances, i.e., a subset \(T \subset \Omega\), is given for the construction of \(P\).
2.3Existing Problem Instance Generation Methods
Designing effective instance generators is crucial for the few-shot construction of generalizable PAPs, yet it is often difficult, as discussed earlier. Domain-specific generators developed for particular problems, such as TSP [11],[26], vehicle routing problem [11], and job shop scheduling problem [27], can be utilized but are limited only to those specific problem domains. In deep learning, instance generation methods have also been developed to address few-shot scenarios in vision [28] and natural language domains [29]. However, due to the fundamental differences between these domains (images and text) and optimization problems, these approaches cannot be applied to the latter. Furthermore, for emerging and black-box optimization problems where even experts lack sufficient domain knowledge, designing domain-specific instance generators becomes even more challenging. The following sections will present DACE that eliminates the need for domain-specific instance generators.
3Domain-Agnostic Problem Instance Representation and Generation
The key innovation of DACE lies in its domain-agnostic approach to representing and generating problem instances. At its core, DACE employs neural networks (NNs) as a universal representation for problem instances, dubbed neural instance representation (NIR). Given a small set \(T\) of training instances, DACE first converts these instances into NIRs and then uses these NIRs as a basis for generating new instances, which are also represented as NIRs. Since different problem instances essentially differ in their underlying objective functions, specifically, in how they map solutions to objective values. Therefore, an NIR represents a problem instance by approximating its objective function. This way, the training process of an NIR only requires pairs of solutions and their corresponding objective values, without requiring any domain-specific knowledge such as analytic form of the objective function. Furthermore, by varying the weight parameters within the NIR, different objective functions corresponding to different problem instances are obtained.
As a result, NIR maintains generality across various binary optimization problem classes, where training instances in \(T\) can be treated as black boxes that simply return solution evaluations. It is worth noting that the term "generality" differs from "generalization". Specifically, PAP's generalization indicates its ability to perform well not only on training instances, but also on unseen instances from the same problem class, whereas NIR's generality means its broad applicability to various binary optimization problem classes.
Technically, NIRs share similarities with surrogate models, a technique widely used in EAs to reduce the number of expensive fitness evaluations [30]-[33]. However, it is important to note that NIRs serve a fundamentally different purpose here. Rather than reducing number of fitness evaluations, NIRs serve as the basis for instance generation, where all generated instances in DACE are represented as NIRs instead of their actual forms. To achieve this goal, two technical challenges must be addressed. First, effective mutation operators need to be developed that can generate meaningful instances represented as NIRs. Due to the powerful representation capabilities of NNs, particularly deep NNs, random mutations of NIR parameters could produce arbitrary objective functions that do not correspond to valid actual problem instances. In other words, the generated instances should relate to the training instances and belong to the same problem class. This requires the extraction and utilization of domain-invariant features from the training instances to properly constrain the instance generation process. The second challenge arises from the discrete nature of binary optimization problems. In these problems, small changes in discrete inputs (such as flipping a few bits) can result in dramatic changes in objective values. This makes NN learning particularly challenging, as NNs are typically suited for fitting smooth, continuous functions [34].
To address these challenges, we propose a decoupled design of the structure of NIR based on variational autoencoders (VAE) [35] and hypernetworks [36]. This structure decouples domain-invariant features from instance-specific features, and also decouples solution encoding from objective function approximation. Below we detail the NIR structure, its training method, and the NIR-based instance mutation operator.
3.1Structure of the NIR
As shown in Fig. 2, NIR employs a VAE for encoding discrete solutions into continuous latent vectors and decoding them back. The VAE consists of an encoder \(F_E\) and a decoder \(F_D\), which are both multilayer perceptrons (MLPs). A scorer \(F_S\), also implemented as an MLP, is built upon the latent vectors output by \(F_E\) to approximate the objective function of the problem instance. Using real-valued latent vectors instead of original discrete solutions as inputs to \(F_S\) creates a smoother function mapping that NNs can approximate more effectively. Let \(\boldsymbol{w}_E\) and \(\boldsymbol{w}_D\) denote the weight parameters of \(F_E\) and \(F_D\), respectively. Given an input solution \(\boldsymbol{x}\in\left\{0, 1\right\}^{d_I}\), where \(d_I\) is the dimension of the problem instance, \(F_E\) predicts the means \(\boldsymbol{\mu}_z\in\mathbb{R}^{d_z}\) and standard deviations \(\boldsymbol{\sigma}_z\in\mathbb{R}^{d_z}\) of a \(d_z\) -dimensional multivariate Gaussian distribution \(\mathcal{N}\left(\boldsymbol{\mu}_z,\boldsymbol{\sigma}_z^2\boldsymbol{I}\right)\). A vector \(\boldsymbol{z} \in \mathbb{R}^{d_z}\) is then sampled from the distribution:
Based on \(\boldsymbol{z}\), the decoder \(F_D\) outputs a reconstructed solution \(\boldsymbol{x}^\prime \in \left\{0, 1\right\}^{d_I}\):
Let \(\boldsymbol{w}_S\) denote the weight parameters of \(F_S\), the concatenation (denoted by \(\oplus)\) of \(\boldsymbol{\mu}_z\) and \(\boldsymbol{\sigma}_z\) is fed into \(F_S\), which predicts the score (objective value) \(y^\prime\):
To capture domain-invariant features of the problem class, the encoder \(F_E\) and decoder \(F_D\) are shared across all NIRs, i.e., all instances in the class. Additionally, the scorer's parameters \(\boldsymbol{w}_S\) are generated by a hypernetwork \(F_H\), which is also shared across all NIRs. Specifically, \(F_H\) is an MLP with weight parameters \(\boldsymbol{w}_H\) that takes an instance-specific embedding \(\boldsymbol{e} \in \mathbb{R}^{d_e}\) as input and outputs \(\boldsymbol{w}_S\):
This means the weight parameters \(\boldsymbol{w}_S\) of the scorer \(F_S\) is generated by the hypernetwork \(F_H\) through its output conditioned on the input embedding \(\boldsymbol{e}\). The instance embedding \(\boldsymbol{e}\) is a trainable vector optimized to encode instance-specific information. It is randomly initialized and then trained with (solution, objective value) pairs sampled from the corresponding training problem instance, as detailed in Section III-B.
In summary, the trainable parameters in an NIR include \(\boldsymbol{w}_E\), \(\boldsymbol{w}_D\), \(\boldsymbol{w}_H\), and the instance embedding \(\boldsymbol{e}\). The first three are shared across all NIRs, while the last one is instance-specific. By training these parameters on the training instances, domain-invariant features are automatically extracted and encoded into \(\boldsymbol{w}_E\), \(\boldsymbol{w}_D\), and \(\boldsymbol{w}_H\), while instance-specific features are captured in their respective embeddings. When generating new instances represented as NIRs, the shared parameters are kept fixed while only instance embedding is perturbed, ensuring that the learned domain-invariant features are preserved.
3.2Training NIRs
Given a small set of training instances \(T = \{s_1, s_2, \ldots\}\), an NIR is built for each \(s_i\), denoted as \(m_i\). As described earlier, all NIRs share \(\boldsymbol{w}_E\), \(\boldsymbol{w}_D\), and \(\boldsymbol{w}_H\), but each has its own instance embedding. Let \(\boldsymbol{e}_i\) denote the embedding of \(s_i\). For each instance \(s_i\), a set of solutions and their corresponding objective values is assumed to be available, denoted as \(\mathcal{X}^i = \{(\boldsymbol{x}_1^i, y_1^i), (\boldsymbol{x}_2^i, y_2^i), \dots\}\). This set can be obtained by running search or sampling methods on \(s_i\). Given \(\mathcal{X}^i\) \((i=1,2,\ldots, |T|)\), all parameters \(\boldsymbol{w}_E\), \(\boldsymbol{w}_D\), \(\boldsymbol{w}_H\), and \(\boldsymbol{e}_i\ (i=1,2,\ldots, |T|)\) are trained by minimizing the following loss, where \(\lambda_1\) and \(\lambda_2\) are weighting hyper-parameters and MSE denotes the mean squared error:
Here, \(\boldsymbol{\mu}_z,\boldsymbol{\sigma}_z\) are obtained through Eq. (5), and \(\boldsymbol{x}^\prime, y^\prime\) are obtained through Eq. (6) and Eq. (7), respectively. The loss function consists of three terms. The first term is a reconstruction loss between the input solution \(\boldsymbol{x}\) and its reconstructed counterpart \(\boldsymbol{x}^\prime\), promoting the encoder to capture the structure of \(\boldsymbol{x}\). The second term is a prediction loss for objective values, encouraging the scorer to be accurate. It should be noted that the actual objective value \(y\) has been normalized to the range \(\left[0,1\right]\) to prevent the influence of varying value scales across different problem instances on the training process. The third term is the KL-divergence between the learned latent distribution and the standard Gaussian distribution, which serves as a standard regularization term commonly used in VAEs [35] to ensure a smooth latent space. All parameters are randomly initialized and jointly optimized using stochastic gradient descent.
During the training process of NIR, constraint information from problem instances is not incorporated, meaning NIR does not directly handle constraints. This is because constraints in optimization problems are typically problem-dependent, and encoding them into the model's representation would compromise the generality of NIR. To address constrained optimization problems, constraint-handling techniques are applied to convert infeasible solutions into feasible ones before they are fed into NIR. More details can be found in Section 5.1.
3.3NIR-based Instance Generation and Evaluation
Alg. 1 presents the NIR-based instance mutation operator, the key mechanism for generating new instances (NIRs) during the evolution of DACE's instance population. This operator takes an NIR \(m\) as input and outputs a new NIR \(m^\prime\) that is challenging for the PAP \(P\). Specifically, \(m^\prime\) is generated by perturbing the instance embedding \(\boldsymbol{e}\) of \(m\) to find a new embedding \(\boldsymbol{e}^\prime\) that minimizes Eq. (10):
where \(f(P, m^\prime | \boldsymbol{e}^\prime)\) is the indicator \(f\) measuring the performance of PAP \(P\) on the NIR \(m^\prime\) specified by \(\boldsymbol{e}^\prime\), which is the best performance achieved among \(P\) 's member algorithms on \(m^\prime\), as defined in Eq. (1). A smaller value indicates that the NIR is more challenging for \(P\).
In summary, our objective is to find a new embedding \(\boldsymbol{e}^\prime\) such that the NIR \(m^\prime\) with this embedding becomes more challenging for the PAP \(P\). It is noted that during the evolutionary process of DACE, we directly employ the NIR \(m^\prime\) to evaluate the performance of algorithm configurations rather than reverting the NIR \(m^\prime\) back to an authentic problem instance in the problem class \(\Omega\). In fact, such a restoration cannot be achieved without domain-specific knowledge.
When the performance indicator \(f\) concerns solution quality, it is important to normalize the objective values of solutions found by the PAP to make \(f\) values comparable across different NIRs. To achieve this normalization, we leverage the computational efficiency of NNs on massive-parallel GPUs to randomly sample a large number (10M) solutions and evaluate their objective values using the NIR \(m^\prime\). The maximum and minimum objective values (denoted as \(f^{max}_{{m}^\prime}\) and \(f^{min}_{{m}^\prime}\), respectively) from these samples are used to normalize the original objective value \(f^{ori}_{\boldsymbol{m}^\prime}\) obtained by the PAP on \(m^\prime\):
Since the performance indicator \(f\) typically lacks analytic forms and \(\boldsymbol{e}^\prime\) is a real-valued vector, Eq. (10) represents a continuous black-box optimization problem. In this work, PGPE [37], an evolution strategy (ES) method, is employed to optimize Eq. (10) (lines 1-2 in Alg. 1). Details of PGPE are provided in Appendix A of the supplementary. Note that other black-box continuous optimizers could also be used here, as the specific choice of optimizer is not central to our approach. Upon termination, the mutation operator returns the NIR \(m^\prime\) specified by the best embedding \(\boldsymbol{e}^\prime\) found by the optimizer (lines 3-4 in Alg. 1).
4Domain-Agnostic Co-Evolution of Parameterized Search (DACE)
DACE is a general-purpose, off-the-shelf approach for constructing PAPs for binary optimization problems. Same as CEPS [11], DACE evolves two competing populations: a configuration population (PAP) and a problem instance population. However, in DACE, problem instances are represented as NIRs, and are generated through the mutation operator described in Section 3. Additionally, configurations in the PAP are identified from a configuration space defined by a parameterized algorithm. To eliminate the need for domain-specific parameterized algorithms, general-purpose EAs are used in DACE. Specifically, the biased random-key genetic algorithm (BRKGA) [38] is employed here, which has five configurable parameters: elite population size, offspring population size, mutant population size, elite bias for parent selection, and duplicate elimination flag. Details of these parameters are provided in Appendix B of the supplementary. The configuration space \(\Theta\) consists of all possible combinations of these parameter values.
The pseudocode of DACE is presented in Alg. 2, with its workflow diagram illustrated in Fig. 3 for better understanding. Overall, DACE consists of two phases: an initialization phase followed by a co-evolution phase where PAP and instance population evolve alternately for \(MaxRound\) rounds. These phases are detailed below.
4.0.1Initialization Phase (lines 1-7 in Alg. 2)
Given a training set \(T\), an NIR is built for each instance in \(T\) as described in Section 3.2, and the population of NIRs (instances) is denoted as \(M\) (line 1). To initialize a PAP \(P\) of \(K\) member algorithms, a set of configurations \(C\) is first randomly sampled from BRKGA's configuration space \(\Theta\), and these configurations are tested on each NIR in \(M\) (line 2). Then, the PAP is constructed by iteratively selecting one configuration from \(C\) that provides the largest performance improvement on \(M\) in terms of the performance indicator \(f\), until \(K\) configurations are chosen (lines 3-7).
4.0.2Evolution of PAP (lines 9-16 in Alg. 2)
Given the current PAP \(P\), a so-called configuration mining process is iterated \(n\) times (lines 10-15). In the \(i\) -th iteration, the \(j\) -th member algorithm is removed from \(P\) to form \(P'\), where \(j=i\mod K\) (lines 11-12). Then, an AAC procedure (SMAC [8] is used here, following CEPS) is employed to search for a new configuration \(\theta'\) within \(\Theta\) that maximizes \(\sum\nolimits_{m \in M}f(P'\cup \{\theta'\},m)\) (line 13), i.e., the performance of \(P'\cup\left\{\theta'\right\}\) on the instance population \(M\). After \(n\) iterations, \(n\) new configurations are obtained. In CEPS, the configuration whose inclusion yields the best-performing PAP is selected from these \(n\) configurations to update \(P\), and it is analogous to a mutation operation where the AAC procedure acts as a mutation operator that perturbs one member algorithm in \(P\). DACE extends this approach. Specifically, a configuration set \(\Psi\) is constructed by combining all \(n\) new configurations with the \(K\) configurations in \(P\) (line 9 and line 14). DACE then examines all possible combinations of \(K\) configurations from \(\Psi\) and selects the combination with the best performance on \(M\) to replace the current PAP (line 16). Since the performance of each configuration in \(\Psi\) on each NIR in \(M\) has already been evaluated, this enumeration does not require actually running the configurations on NIRs, but simply queries the previously recorded performance results. Given that \(\left\vert\Psi\right\vert=K+n\), the total number of combinations to examine is a combinatorial value \(\binom{n+K}{K}=\frac{\left(n+K\right)!}{K!n!}\), and this would take negligible time when \(K\) and \(n\) are not large (in our experiments, \(K = 4\) and \(n = 20\), with \(\binom{n+K}{K}=10626\)). As a result, this approach can potentially update all configurations in \(P\) simultaneously, which is a more powerful mutation operation compared to CEPS's single-configuration mutation. Since this improvement is not the primary focus of this work, the same PAP mutation mechanism is also applied to CEPS in our experiments to enhance its performance.
4.0.3Evolution of Instance Population (lines 17-28 in Alg. 2)
The objective of evolving \(M\) is to identify new NIRs that are challenging for the current PAP \(P\). The fitness of each NIR \(m\) is defined as \(-f(P,m)\) (line 18). That is, NIRs on which \(P\) performs poorly have higher fitness values. DACE begins by creating a copy \(M'\) of the instance population \(M\) (line 19). Additionally, an empty set \(M_{new}\) is initialized to store newly generated NIRs (line 20). DACE then repeats a so-called instance mining process \(\left\vert M^\prime\right\vert/2\) times (lines 22-27). In each iteration, the mutation operator described in Alg. 1 is applied to an NIR \(m\) randomly selected from \(M^\prime\) to generate a new NIR \(m^\prime\) (line 22). If no NIR in \(M\) has lower quality than \(m^\prime\), indicating that the generated instance is not challenging for the current PAP, the mining process terminates (lines 24–25). Otherwise, an instance \(m^\star\) with lower fitness than \(m^\prime\) is randomly removed from \(M\), and \(m^\prime\) is added to \(M_{new}\) (lines 26-27 ). When the mining process completes, the newly generated NIRs in \(M_{new}\) are added to the instance population \(M\) (line 29), which is used to obtain the new PAP in the next co-evolution round. The evolution of \(M\) will be skipped in the last co-evolution round (line 17) because there is no need to generate more NIRs since the final PAP has been constructed completely.
5Computational Studies
Extensive experiments are conducted on three binary optimization problems from real-world applications: the complementary influence maximization problem (CIMP) [39], compiler arguments optimization problem (CAOP) [21], and contamination control problem (CCP) [40]. Through the experiments, we aim to assess the potential of DACE by addressing the following research questions (RQs):
RQ1: How does DACE perform across different problem classes, particularly in its ability to match the performance of CEPS that uses domain-specific instance generators?
RQ2: How do the PAPs constructed by DACE, which consist of general-purpose search methods as member algorithms, perform against state-of-the-art domain-specific optimizers?
RQ3: How effectively do the generated NIRs represent actual instances from the problem class?
For each problem class, problem instances were generated based on public benchmarks and divided into training and test sets. Following the experimental setup of CEPS [11], few-shot scenarios were simulated where the training set size is limited. Specifically, the training set for each problem class contained 5 instances, while the test set contained 100 instances with problem dimensions equal to or larger than training instances. Throughout the experiments, test instances were used solely to evaluate the generalization performance of PAPs obtained by DACE and the compared methods. The training instances were only used for PAP construction, regardless of which method used. The source code and benchmark instances for each problem class have been anonymously open-sourced at https://github.com/MetaronWang/DACE.
It is important to note that for each of the three problem classes, CEPS's instance mutation operator (i.e., its instance generator) directly employs the generation mechanism of the training instances (see details in the next subsection), producing in-distribution problem instances identical to the training set. This results in an effective mutation operator that assumes CEPS's users have comprehensive domain-specific knowledge of these three problem classes. Therefore, for DACE - a method requiring no domain-specific knowledge - the baseline expectation was to match the performance of CEPS in both RQ1 and RQ3. Surprisingly, experimental results demonstrate that DACE even outperforms CEPS across all three problems in RQ1 while achieving comparable performance in RQ3. The problem classes, compared methods, experimental protocol, and results are detailed in the following.
5.1Constraint Handling, Problem Classes and Instances
During the three problems, CIMP and CCP involve constraints. As noted in Section 3.2, NIR does not handle constraints directly. Instead, problem-specific constraint-handling techniques are applied here. Specifically, solution repair [41] is employed to handle the constraint on the size of the selected seed set in CIMP. For CCP, following the previous study [42], the contamination probability constraint is converted to a penalty component. Details on each problem class, including their objective functions, constraint-handling techniques, and problem instances, are provided below.
5.1.1Complementary Influence Maximization Problem (CIMP)
The rapid growth of online social platforms has made influence maximization an increasingly important problem. Given a social network \(\mathcal{G} = \left(V, E, p\right)\), where \(V\) denotes the nodes, \(E\) denotes the edges, and \(p\) specifies influence probabilities between nodes, the influence maximization problem (IMP) aims to find a seed set \(S\) of \(k\) nodes (each selected node is called a "seed") to maximize the expected number of active nodes. CIMP [39] extends IMP by introducing complementary users, making the influence analysis more complex due to collaborator interactions. Specifically, given a social network \(\mathcal{G}\) and a complementary seed set \(S_A\) for opinion \(A\), CIMP aims to find a seed set \(S_B\) of \(k\) nodes from a candidate set \(C \subset V\) with \(\left\vert C\right\vert = d_I\) to maximize the spread of opinion \(B\), making it a \(d_I\) -dimensional binary optimization problem. The interaction between opinions \(A\) and \(B\) is governed by parameters \(q_{A|\emptyset}\), \(q_{A|B}\), \(q_{B|\emptyset}\), \(q_{B|A}\), as detailed in [39].
In the binary solution representation \(\boldsymbol{x} \in \{0,1\}^{d_I}\), \(x_i = 1\) indicates the \(i\) -th node is included into \(S_B\), while \(x_i = 0\) indicates it is excluded. The objective function is to maximize the expected number of nodes activated by \(S_B\), subject to selecting at most \(k\) seeds:
Given a solution, if it exceeds \(k\) selected seeds, it is repaired by keeping only the first \(k\) chosen seeds and discarding the rest. Then, Eq. (12) is evaluated through Monte Carlo simulations of the propagation process on the network.
For CIMP, problem instances were generated using three public social network benchmarks: Wiki [43], Facebook [44], and Epinions [43]. The Wiki benchmark was used for generating training instances, while test instances were generated from Epinions, Facebook and Wiki benchmarks, with the benchmark being randomly selected for each instance. For each \(d_I\) -dimensional CIMP instance, a candidate seed set \(C\) of size \(d_I\) was randomly selected from the node set \(V\). The interaction parameters \(\left\{q_{A|\emptyset}, q_{A|B}, q_{B|\emptyset}, q_{B|A}\right\}\) were randomly selected from two default settings: \(\left\{0.5, 0.75, 0.5, 0.75\right\}\), and \(\left\{0.5, 0.25, 0.5, 0.25\right\}\). The maximum seed set size \(k\) is an integer randomly selected from \(\left[0.2d_I, 0.6d_I\right]\). Finally, the training set contained five problem instances with \(d_I = 80\), and the test set contained 100 instances evenly split between \(d_I=80\) and \(d_I=100\).
5.1.2Compiler Arguments Optimization Problem (CAOP)
CAOP [21] aims to minimize executable file size during software compilation, which is crucial in storage-limited environments. Software developers use compiler arguments to control various features that can reduce code size. The impact of these arguments varies depending on the source code being compiled. While appropriate arguments can effectively reduce file size, poor choices may lead to increased size. Therefore, selecting the right compiler arguments is critical for optimal results.
In a \(d_I\) -dimensional CAOP instance, \(d_I\) compiler arguments are considered, and the source code to be compiled is denoted as \(F\). The solution \(\boldsymbol{x} \in \{0,1\}^{d_I}\) represents which arguments are used. If \(x_i = 1\), the \(i\) -th compiler argument is enabled, whereas \(x_i = 0\) indicates it is disabled. The objective function is defined as the negative of the generated executable file size (the negative sign is used to convert the minimization problem into a maximization problem):
Due to the complex nature of the compilation process, Eq. (13) lacks an analytic form and can only be evaluated by actually compiling the source code \(F\) with the specified arguments, making CAOP a black-box optimization problem.
For CAOP, problem instances were generated using the cbench and polybench-cpu [45] benchmarks, which contain 50 program source files in total. Among them 11 files were selected as training group and 26 files were selected as test group. To generate a training instance, a source file was randomly selected from the training group, while test instances were generated using random selections from the test group. Following [21], GCC was chosen as the compiler due to its widespread use. Among GCC's 186 available arguments, \(d_I\) arguments were randomly selected for each instance, with all other arguments being disabled. Finally, the training set contained five problem instances with \(d_I=80\), and the test set contained 100 instances in total, evenly split between \(d_I=80\) and \(d_I=100\).
5.1.3Contamination Control Problem (CCP)
CCP [40],[42] arises from the need for contamination prevention in the food production supply chain. Multiple stages are involved during food production, each of which can potentially introduce contamination. At stage \(i\), taking mitigation measures can reduce contamination at a rate of random variable \(\Gamma_i\), but incurs a cost of \(c_i\). If no action is taken, the contamination rate will be \(\alpha_i\). In a \(d_I\) -dimensional CCP instance, there are \(d_I\) stages. For a binary solution \(\boldsymbol{x} \in \{0,1\}^{d_I}\), \(x_i = 1\) indicates measures are taken at stage \(i\) while \(x_i=0\) representing no measures. Let \(z_i\) denote the proportion of contaminated food at stage \(i\), which is defined as \(z_i = \alpha_i (1 - x_i)(1 - z_{i-1}) + (1 - \Gamma_i x_i) z_{i-1}\).
In CCP, the constraint limits the probability that contamination at each stage exceeds the upper limit \(u_i\), approximated through \(T\) Monte Carlo simulations. Following the previous work [42], this constraint is incorporated into the objective function as a penalty term \(\frac{1}{T}\sum_{k=1}^{T}1_{\left\{z_k>u_i\right\}}\), and the final objective function is:
where \(\lambda\) is a weighting parameter, \(T\) represents the number of Monte Carlo simulations, \(u_i\) is the upper limit of contamination which is set to \(0.1\), and all the random variables follow beta distributions.
In [42], CCP instances were generated with a dimension of 21, where \(\lambda\) was selected from \(\left\{0, 10^{-4}, 10^{-2}\right\}\), while the random variables followed distributions: \(\alpha\sim\textrm{Be}\left(1, \frac{17}{3}\right)\), \(\Gamma\sim\textrm{Be}\left(1, \frac{7}{3}\right)\), and the initial contamination \(z_0\sim\textrm{Be}\left(1, 30\right)\). Since \(\lambda\) was found to significantly influence instance characteristics, we adopted their instance generation approach and used \(\lambda\) values to distinguish between training and test instances. Specifically, \(\lambda\) was set to \(10^{-4}\) for training instances and randomly selected from \(\left\{0, 10^{-2} \right\}\) for test instances. The training set consisted of five problem instances with \(d_I=30\), while the test set contained 100 instances in total, evenly split between \(d_I=30\) and \(d_I=40\).
5.2Compared Methods
To address RQ1, DACE was compared with several state-of-the-art PAP construction methods across all three problem classes. The main comparison was made with CEPS [11], which uses instance generation during PAP construction. The domain-specific instance mutation operator in CEPS was implemented exactly as the training instance generation mechanism described in Section 5.1, thus generating in-distribution instances identical to the training set. This is to simulate that CEPS’s users possess comprehensive domain-specific knowledge of these three problem classes.
Additionally, GLOBAL [9] and PARHYDRA [18] were included as they represent state-of-the-art PAP construction that assumes sufficient training instances. PCIT [10] and CLUSTERING [17] were not included in the comparison due to their clustering mechanism being invalid with the limited training instances. To ensure fair comparison, all methods constructed PAPs based on the same configuration space defined by BRKGA, a general-purpose EA implemented using an open-source library [46]. This means that all constructed PAPs consist of BRKGA configurations. A manually constructed PAP (referred to as BRKGA-PAP) was also included as a baseline. This PAP contains four configurations: two recommended configurations from the open-source BRKGA library [46] and previous work [38], plus two additional configurations created by flipping the "eliminate_duplicates" parameter in the original two configurations.
To address RQ2, a SMARTEST-based PAP (referred to as SMARTEST-PAP) was included for comparison on CAOP. SMARTEST [21] is the state-of-the-art optimizer for CAOP, and its PAP variant is stronger than a single SMARTEST configuration. This PAP contains four SMARTEST configurations recommended in [21], each designed for instances with different characteristics. The specific configurations in BRKGA-PAP and SMARTEST-PAP are provided in Appendix C of the supplementary.
5.3Experimental Protocol
Following the experimental protocol in the CEPS paper [11], the number of member algorithms in PAP, i.e., \(K\), was set to \(4\), and solution quality was used as the performance indicator \(f\). For both CEPS and DACE, identical parameter settings were used to make fair comparisons. Specifically, the number of co-evolution rounds (i.e., \(MaxRound\)) was set to 4, configuration mining was repeated 20 times (i.e., \(n=20\)), and the maximum number of trials in SMAC was set to 1600. Both methods used the same randomly sampled initial configuration set \(C\) in their initialization phase. For instance generation in both methods, the mutation operator was run for a maximum of 200 iterations, and the hardest instance (on which the PAP achieves the lowest solution quality) from these iterations was returned to update the instance population. The hyper-parameters of the NIR structure in DACE are shown in Table 1 and the parameters were chosen based on empirical experience. The weighting hyper-pamraeters \(\lambda_1\) and \(\lambda_2\) in the NIR training loss function were set to 1 and 0.0005, respectively.
For constructing PAPs using GLOBAL and PARHYDRA, their parameters were set to ensure they consumed at least the same CPU time and on-wall time as DACE. The actual time consumption of all methods is shown in Table 2. Specifically, for GLOBAL, the maximum number of trials in SMAC was set to 6400 for CIMP and CAOP, and 51200 for CCP; the number of independent SMAC runs was set to 75, 100, and 200 for CIMP, CAOP, and CCP, respectively. For PARHYDRA, the maximum number of trials in SMAC were set to 12800, 4800, and 25600 for CIMP, CAOP, and CCP, respectively, with independent SMAC runs set to 20, 100, and 200, respectively.
On each problem class, PAP construction methods were applied to build PAPs based on the training set, and then these PAPs were evaluated on the test set. The number of solution evaluations for each member algorithm in the PAP was set to \(800\). To ensure solution quality is comparable across different test instances, 1M solutions were sampled for each instance and their objective values were evaluated. The objective values obtained by PAPs were then normalized using the method described in Eq. (11). Each PAP was applied 20 times on every test instance, and the mean of the normalized objective values of these runs was recorded as the performance of the PAP on that instance.
The PAP construction by DACE was conducted on a server with 2 Intel Xeon Silver 4310 CPUs (48 threads, 3.3GHz, 36 MB cache), 256 GB RAM, and 8 Nvidia A30 GPUs. The remaining experiments were performed on a cluster of 3 servers. The first server was configured with dual AMD EPYC 7713 CPUs (256 threads, 3.6GHz, 512MB cache) and 512GB RAM, while the other two servers each contained dual Intel Xeon Gold 6336Y CPUs (96 threads, 3.6GHz, 72MB cache) and 784GB RAM. All servers operated on Ubuntu 22.04.
5.4Test Results and Analysis
Table 3 reports the mean and standard deviation of solution quality achieved by each PAP on test instances of different dimensions in each problem class, along with Wilcoxon sign-rank test results comparing DACE against other methods. For a more detailed analysis, instance-level performance comparisons are also reported. Specifically, Table 4 presents win-draw-loss (W-D-L) counts from Wilcoxon rank-sum tests, indicating the number of instances in each test set where DACE performs significantly better than, statistically equivalent to, or significantly worse than the compared methods. Fig. 4 visualizes the performance distribution of the PAPs on each test set through boxplots.
When reporting the results, PAP construction methods are used to denote their constructed PAPs. BRKGA-PAP refers to a manually constructed PAP containing recommended configurations of BRKGA, and SMARTEST-PAP represents the state-of-the-art PAP optimizer specifically designed for CAOP, containing four recommended configurations of SMARTEST, as described in Section 5.2.
The first observation from Table 3 is that DACE, not only matches, but also surprisingly outperforms CEPS across all dimensions in all three problem classes. At the instance level, as shown in Table 4, DACE performs at least as well as CEPS on 290 out of 300 test instances, with only 10 instances in CIMP where CEPS shows an advantage. Moreover, across all problem classes, the number of instances where DACE significantly outperforms CEPS ("W" in the table) far exceeds those where it underperforms ("L" in the table). Notably, on CAOP and CCP, no instance exists where DACE performs worse than CEPS. This finding is also shown in Fig. 4, where DACE's performance distribution on test instances consistently surpasses CEPS across the three problem classes.
Given that the key distinction between CEPS and DACE lies in their instance generators, we speculate that the superior performance of DACE's domain-agnostic instance mutation operator might be attributed to two aspects. First, by transforming instance generation into a continuous optimization problem through NIRs as described in Alg. 1, DACE can leverage powerful continuous optimization methods to identify challenging instances more effectively than CEPS's domain-specific approaches. In the co-evolutionary training process, an instance \(m^\prime\) is considered challenging when the solution quality achieved by the PAP \(P\) on that instance is inferior to the solution quality achieved by \(P\) on any instance in the current population \(M\):
where the solution quality \(f\) is defined in Eq. (11). This advantage is particularly evident in CAOP, where CEPS's instance mutation operator failed to identify any challenging instances, resulting in the break of the instance mining process (lines 24-25 of Algorithm 2) and no expansion of the training instance population. In contrast, DACE's NIR-based mutation operator successfully identified new challenging instances that enriched the problem instance population. These results demonstrate that DACE not only successfully eliminates the need for domain-specific instance generators but also achieves superior effectiveness.
Compared to GLOBAL and PARHYDRA, DACE's performance advantage is even more pronounced, showing superior results on most test instances. For example, in CIMP and CCP, DACE significantly outperforms both methods across all test instances. This superiority is further confirmed in Fig. 4, where DACE's performance distribution notably exceeds those of GLOBAL and PARHYDRA across all problem classes. Against BRKGA-PAP, DACE demonstrates significantly better performance across all three problem classes without underperforming in any instance, indicating the effectiveness of DACE for PAP construction in few-shot scenarios compared to using a few sets of recommended configurations directly for the PAP. The above results demonstrate DACE's strong generality across problem classes and its successful elimination of the need for domain-specific instance generators, positively addressing RQ1 raised at the beginning of this section.
To address RQ2, comparisons with SMARTEST-PAP on CAOP reveal that DACE, constructing PAP with BRKGA - a general-purpose EA - yields better performance than using recommended configurations of SMARTEST as the PAP, which is specifically designed for CAOP. Interestingly, it is also found that BRKGA-PAP outperforms SMARTEST-PAP on CAOP, suggesting BRKGA's strong optimization capabilities as a general-purpose EA and making it a suitable choice for the parameterized optimization algorithm in DACE.
Another observation from Fig. 4 is that DACE and CEPS, which incorporate instance generation mechanisms, consistently outperform GLOBAL and PARHYDRA, which lack such mechanisms. This indicates generating synthetic instances during PAP construction effectively improves generalization in few-shot scenarios, aligning with findings from previous work [11]. Moreover, GLOBAL and PARHYDRA perform worse than the manually constructed BRKGA-PAP across most problem classes. This performance degradation is likely due to overtuning, where the PAPs become overly specialized to the limited training set, compromising their generalization capabilities.
5.5Analysis of PAP's Generalization through Co-Evolution
Fig. 5 shows how the PAP's test performance evolves through consecutive co-evolution rounds of DACE. The mean normalized solution quality over 20 runs on the test set is plotted, with error bars representing the 95% confidence intervals. For each problem class and dimension, results are shown separately. The results in Fig. 5 demonstrate that DACE's co-evolution phase consistently improves PAP's generalization capability, though the improvement patterns vary across problem classes. For CCP, a sharp performance gain is observed in the first round, followed by diminishing improvements in subsequent rounds. This suggests that the test instances in CCP exhibit relatively simple patterns that can be effectively captured by the generated instances early in the co-evolution process. In contrast, for CIMP, sustained performance improvements are shown across all four rounds, with notable gains even in the final round. This indicates that CIMP test instances contain diverse patterns, requiring more extensive instance synthesis to enhance PAP's generalization ability. For CAOP, significant improvements are achieved in the first two rounds, but performance plateaus and slightly decreases after the third round. This suggests that while CAOP test instances also contain diverse patterns, the generated instances begin to diverge from these patterns in later rounds, highlighting the challenge of generating instances that match complex problem characteristics.
An interesting observation spans all three problem classes. While PAPs were constructed using training instances of only certain dimensions (30 for CCP, 80 for CIMP and CAOP), they were tested on both matching dimensions and larger ones (40 for CCP, 100 for CIMP and CAOP). DACE's performance improvement is particularly noticeable on higher-dimensional test instances in CAOP and CCP, while for CIMP the improvement is consistent across both dimensions. This observation has two important implications. First, it suggests that higher-dimensional instances, which are typically more challenging to solve with limited solution evaluations, provide more opportunities for performance improvement. Second, it demonstrates that DACE can construct effective PAPs that generalize well to instances of different dimensions, even when trained on a small set of fixed-dimension instances.
5.6Visual Analysis of NIR-based Instance Generation
To address RQ3 raised at the beginning of this section, experiments were conducted to examine whether the generated NIRs can effectively represent problem instances in the problem class. A visualization method was developed to compare the distributions of instances from different sources across three problem classes. The visualization included instances from training sets, test sets, and those generated by DACE and CEPS. Additionally, to investigate the role of domain-invariant features in NIRs, a variant of DACE called \(\text{DACE}_{NoReg}\) was introduced. Unlike DACE which mutates instance embeddings and then uses a hypernetwork to generate scorer weights, \(\text{DACE}_{NoReg}\) directly applies the mutation operator from Alg. 1 to modify the scorer weights. This removal of the hypernetwork, a key component for capturing domain-invariant features, allows examination of its importance in instance generation. It should be noted that the instances in the training set and test set, as well as the instances generated by CEPS, are indeed authentic problem instances belonging to their specific problem classes. In contrast, the instances generated by DACE and \(\text{DACE}_{NoReg}\) are represented as NIRs.
A visualization method was developed to project problem instances into a 2D space based on features extracted from their solution-to-objective value mappings, with dimensionality reduction performed using PCA. The method was inspired by the previous fitness-distance correlation (FDC) research [47]-[49], which demonstrated the significant influence of neighborhood characteristics on the difficulty of combinatorial optimization problems. However, standard FDC focuses on analyzing the correlation between solution fitness and distance specifically to the global optimum. While this correlation is useful for algorithm compatibility analysis, it lacks the information required for our goal of fine-grained problem characterization and classification. Therefore, we propose a novel feature extraction method that captures neighborhood characteristics across the entire global solution space, rather than concentrating solely on the optimum. By statistically characterizing fitness variations relative to distance throughout the solution space, this approach provides richer information. The feature extraction process began by randomly sampling 1M solutions for each instance and evaluating their normalized objective values. From these solutions, 10M pairs were randomly sampled to analyze the relationship between Hamming distances and objective value differences. The solution pairs were grouped into \(m\) sets based on their Hamming distances, with each set containing pairs of equal distance. Using 16 quantiles \(\left[a_0, a_1, \cdots, a_{15}\right]\) where \(a_i=\frac{i}{15}\), the set \(V_i\) was defined as containing pairs with the \(\lfloor a_i\times m\rfloor\) -th largest Hamming distance. For each \(V_i\), two statistics were calculated: \(b_i\) as the mean objective value difference and \(c_i\) as the standard deviation of objective value differences. These statistics were combined into two vectors: \(\boldsymbol{b} = \left[b_0, b_1, \cdots, b_{15}\right]\) and \(\boldsymbol{c} = \left[c_0, c_1, \cdots, c_{15}\right]\). The final feature vector for each problem instance is \(\boldsymbol{b}\oplus\boldsymbol{c}\), where \(\oplus\) is the concatenation operator. After obtaining feature vectors for all instances, we construct a dimensionality reduction mapping from 32 to 2 dimensions using PCA, based on only training and test sets. Subsequently, this mapping is applied to reduce all feature vectors to their 2-dimensional representations. Fig. 6 shows the visualization results of all problem instances used in the experiment, including those from the training set, test set, instances generated by CEPS, as well as NIRs generated by DACE and \(\text{DACE}_{NoReg}\).
Fig. 6a shows clear separation among instances from different classes in the 2D space, validating the effectiveness of the visualization method. A slight overlap is observed between instances from CAOP and CIMP classes. For analysis purposes, two key areas are defined in the 2D space: the reference area, covered by training and test instances, and the coverage area, occupied by instances generated by each method. The similarity between generated and actual problem instances can be assessed by comparing these areas.
In the CIMP class (Fig. 6b), all three methods - DACE, CEPS, and \(\text{DACE}_{NoReg}\) - generate instances that overlap with the reference area, though their distributions differ. For the CAOP class (Fig. 6c), only DACE and \(\text{DACE}_{NoReg}\) are compared since CEPS failed to generate challenging instances in this class. Specifically, CEPS cannot generate instances with lower quality than the initial training instances in CAOP, while quality is defined in Eq. (11). In Fig. 6c, both DACE and \(\text{DACE}_{NoReg}\) show limited overlap with the reference area. Actually, instances generated by \(\text{DACE}_{NoReg}\) deviate significantly from the reference area and even overlap with the CCP region, which explains the previously observed overlap between CAOP and CIMP instances. It can be also observed that DACE's coverage area lies closer to the reference area than \(\text{DACE}_{NoReg}\), indicating that problem class regularization helps generate more realistic instances. In the CCP class (Fig. 6d), both DACE and CEPS achieve coverage areas that align with the reference area, though DACE’s alignment and coverage are slightly inferior to CEPS's. On the other hand, \(\text{DACE}_{NoReg}\) 's coverage area largely falls outside the reference area, with some instances showing significant deviation. This suggests that without problem class regularization, \(\text{DACE}_{NoReg}\) generates instances with substantially different neighborhood characteristics from authentic CCP instances, potentially reducing their usefulness in PAP construction.
The above results demonstrate that generated NIRs in DACE effectively resemble authentic instances in the problem class, providing a positive answer to RQ3. It is worth noting that the above conclusion's scope could be limited, since instance similarity was measured only using the selected fitness-distance features. A more comprehensive characterization of instance properties is an important direction for future work. This would involve incorporating other key properties, such as the "challenge" (or "difficulty level") that the generated instances pose for PAPs.
6Conclusion and Discussion
This work presents DACE, a general-purpose approach for constructing PAPs for binary optimization problems. The key innovation of DACE is its domain-agnostic NN-based instance representation and generation mechanism. This approach eliminates the need for practitioners to provide domain-specific instance generators - a major limitation of existing few-shot PAP construction approaches like CEPS. Notably, across all three problem classes, DACE constructs PAPs with better generalization performance than existing approaches, despite their use of domain-specific instance generators. Finally, a visualization method based on neighborhood characteristics is developed, which validates the effectiveness of NIR-based instance generation.
When tackling real-world problems, PAPs offer a significant advantage over using a single algorithm, i.e., they can achieve superior solution quality. Naturally, PAPs introduce some additional computational overhead. However, with the widespread availability of modern parallel computing platforms, PAPs provide a straightforward way to leverage these resources, effectively mitigating this overhead. The enhanced solution quality is particularly valuable in quality-sensitive scenarios, such as the CCP problem class explored in this work, where even small improvements can have substantial practical implications.
Several promising directions for future research are outlined. First, the training of NIRs is currently limited to problem instances of a single dimension. While we introduced a simple workaround in the supplementary (Appendix E) to potentially handle small dimensional variations, developing a truly robust cross-dimensional training approach remains a critical and open challenge for future work. This would significantly expand the application scenarios of our method. Second, a more comprehensive characterization of instance properties would be beneficial for analyzing the generated instances (NIRs). One way is to move beyond the current focus on instance similarity to also include a deeper assessment of the "challenge" (or "difficulty level") that the generated instances pose for PAPs. Such an assessment could be achieved by analyzing the instances' fitness landscapes or the specific behaviors of solvers when applied to them. Finally, since DACE can be applied to various optimizers beyond BRKGA, extending it to other optimizers, such as the estimation of distribution algorithms (EDA) variants, or even constructing a PAP containing multiple types of optimizers, is a valuable future direction.
References
- S. Wang, Y. Mei, M. Zhang, X. Yao, "Genetic Programming With Niching for Uncertain Capacitated Arc Routing Problem", IEEE Trans. Evol. Comput., vol. 26, no. 1, pp. 73--87, 2022.
- X. Zhou, A. K. Qin, M. Gong, K. C. Tan, "A Survey on Evolutionary Construction of Deep Neural Networks", IEEE Trans. Evol. Comput., vol. 25, no. 5, pp. 894--912, 2021.
- X. Li, M. G. Epitropakis, K. Deb, A. P. Engelbrecht, "Seeking Multiple Solutions: An Updated Survey on Niching Methods and Their Applications", IEEE Trans. Evol. Comput., vol. 21, no. 4, pp. 518--538, 2017.
- L. Beke, L. Uribe, A. Lara, C. A. C. Coello, M. Weiszer, E. K. Burke, J. Chen, "Routing and Scheduling in Multigraphs With Time Constraints - A Memetic Approach for Airport Ground Movement", IEEE Trans. Evol. Comput., vol. 28, no. 2, pp. 474--488, 2024.
- C. Huang, Y. Li, X. Yao, "A Survey of Automatic Parameter Tuning Methods for Metaheuristics", IEEE Trans. Evol. Comput., vol. 24, no. 2, pp. 201--216, 2020.
- C. Ans\'otegui, Y. Malitsky, H. Samulowitz, M. Sellmann, K. Tierney, "Model-Based Genetic Algorithms for Algorithm Configuration", in Proceedings of IJCAI 2015, Buenos Aires, Argentina, pp. 733--739.
- L. Manuel, D. Jérémie, P. C. Leslie, B. Mauro, S. Thomas, "The irace package: Iterated racing for automatic algorithm configuration", Oper. Res. Perspect., vol. 3, pp. 43--58, 2016.
- F. Hutter, H. H. Hoos, K. Leyton-Brown, "Sequential Model-Based Optimization for General Algorithm Configuration", in Proceedings of LION 2011, Rome, Italy, pp. 507--523.
- M. Lindauer, H. H. Hoos, K. Leyton-Brown, T. Schaub, "Automatic construction of parallel portfolios via algorithm configuration", Artif. Intell., vol. 244, pp. 272--290, 2017.
- S. Liu, K. Tang, X. Yao, "Automatic Construction of Parallel Portfolios via Explicit Instance Grouping", in Proceedings of AAAI 2019, HI, USA, pp. 1560--1567.
- K. Tang, S. Liu, P. Yang, X. Yao, "Few-Shots Parallel Algorithm Portfolio Construction via Co-Evolution", IEEE Trans. Evol. Comput., vol. 25, no. 3, pp. 595--607, 2021.
- S. Liu, K. Tang, X. Yao, "Generative Adversarial Construction of Parallel Portfolios", IEEE Trans. Cybern., vol. 52, no. 2, pp. 784--795, 2022.
- B. A. Huberman, R. M. Lukose, T. Hogg, "An economics approach to hard computational problems", Science, vol. 275, no. 5296, pp. 51--54, 1997.
- C. P. Gomes, B. Selman, "Algorithm portfolios", Artif. Intell., vol. 126, no. 1-2, pp. 43--62, 2001.
- R. Sutton, "The bitter lesson", 2019.
- R. W. Hockney, C. R. Jesshope, "Parallel Computers 2: architecture, programming and algorithms", CRC Press, 2019.
- S. Kadioglu, Y. Malitsky, M. Sellmann, K. Tierney, "ISAC - Instance-Specific Algorithm Configuration", in Proceedings of ECAI 2010, Lisbon, Portugal, pp. 751--756.
- L. Xu, H. H. Hoos, K. Leyton-Brown, "Hydra: Automatically Configuring Algorithms for Portfolio-Based Selection", in Proceedings of AAAI 2010, GA, USA, pp. 210--216.
- K. Smith-Miles, S. Bowly, "Generating new test instances by evolving in instance space", Comput. Oper. Res., vol. 63, pp. 102--113, 2015.
- C. Wang, Z. Yu, S. McAleer, T. Yu, Y. Yang, "ASP: Learn a Universal Neural Solver!", IEEE Trans. Pattern Anal. Mach. Intell., vol. 46, no. 6, pp. 4102--4114, 2024.
- H. Jiang, G. Gao, Z. Ren, X. Chen, Z. Zhou, "SMARTEST: A Surrogate-Assisted Memetic Algorithm for Code Size Reduction", IEEE Trans. Reliab., vol. 71, no. 1, pp. 190--203, 2022.
- K. Tang, X. Yao, "Learn to Optimize-A Brief Overview", Natl. Sci. Rev., vol. 11, no. 8, pp. nwae132, 2024.
- S. Liu, K. Tang, Y. Lei, X. Yao, "On Performance Estimation in Automatic Algorithm Configuration", in Proceedings of AAAI 2020, NY, USA, pp. 2384--2391.
- A. Blot, H. H. Hoos, L. Jourdan, M. Kessaci-Marmion, H. Trautmann, "MO-ParamILS: A Multi-objective Automatic Algorithm Configuration Framework", in Proceedings of LION 2011, Ischia, Italy, pp. 32--47.
- X. Ma, X. Li, Q. Zhang, K. Tang, Z. Liang, W. Xie, Z. Zhu, "A Survey on Cooperative Co-Evolutionary Algorithms", IEEE Trans. Evol. Comput., vol. 23, no. 3, pp. 421--441, 2019.
- J. I. V. Hemert, "Evolving Combinatorial Problem Instances That Are Difficult to Solve", Evol. Comput., vol. 14, no. 4, pp. 433--462, 2006.
- J. Branke, C. W. Pickardt, "Evolutionary search for difficult problem instances to support the design of job shop dispatching rules", Eur. J. Oper. Res., vol. 212, no. 1, pp. 22--32, 2011.
- Y. Zhang, M. Gong, J. Li, K. Feng, M. Zhang, "Few-Shot Learning With Enhancements to Data Augmentation and Feature Extraction", IEEE Trans. Neural Netw. Learn. Syst., pp. 1-14, 2024.
- J. Zhou, Y. Zheng, J. Tang, L. Jian, Z. Yang, "FlipDA: Effective and Robust Data Augmentation for Few-Shot Learning", in Proceedings of ACL 2022, Dublin, Ireland, pp. 8646--8665.
- Y. Jin, "Surrogate-assisted evolutionary computation: Recent advances and future challenges", Swarm Evol. Comput., vol. 1, no. 2, pp. 61--70, 2011.
- F. Zhang, Y. Mei, S. Nguyen, M. Zhang, K. C. Tan, "Surrogate-Assisted Evolutionary Multitask Genetic Programming for Dynamic Flexible Job Shop Scheduling", IEEE Trans. Evol. Comput., vol. 25, no. 4, pp. 651--665, 2021.
- B. H. Nguyen, B. Xue, M. Zhang, "A Constrained Competitive Swarm Optimizer With an SVM-Based Surrogate Model for Feature Selection", IEEE Trans. Evol. Comput., vol. 28, no. 1, pp. 2--16, 2024.
- Q. Lin, X. Wu, L. Ma, J. Li, M. Gong, C. A. C. Coello, "An Ensemble Surrogate-Based Framework for Expensive Multiobjective Evolutionary Optimization", IEEE Trans. Evol. Comput., vol. 26, no. 4, pp. 631--645, 2022.
- S. Ferrari, R. F. Stengel, "Smooth function approximation using neural networks", IEEE Trans. Neural Netw., vol. 16, no. 1, pp. 24--38, 2005.
- D. P. Kingma, M. Welling, "Auto-Encoding Variational Bayes", in Proceedings of ICLR 2014, AB, Canada.
- V. K. Chauhan, J. Zhou, P. Lu, S. Molaei, D. A. Clifton, "A brief review of hypernetworks in deep learning", Artif. Intell. Rev., vol. 57, no. 9, pp. 250, 2024.
- H. Beyer, H. Schwefel, "Evolution strategies - A comprehensive introduction", Nat. Comput., vol. 1, no. 1, pp. 3--52, 2002.
- J. F. Gon, M. G. C. Resende, "Biased random-key genetic algorithms for combinatorial optimization", J. Heuristics, vol. 17, no. 5, pp. 487--525, 2011.
- W. Lu, W. Chen, L. V. S. Lakshmanan, "From Competition to Complementarity: Comparative Influence Diffusion and Maximization", Proc. VLDB Endow., vol. 9, no. 2, pp. 60--71, 2015.
- Y. Hu, J. Hu, Y. Xu, F. Wang, R. Cao, "Contamination control in food supply chain", in Proceedings of WSC 2010, MD, USA, pp. 2678--2681.
- C. A. C. Coello, "Theoretical and numerical constraint-handling techniques used with evolutionary algorithms: a survey of the state of the art", Comput. Methods in Appl. Mech. Eng., vol. 191, no. 11-12, pp. 1245--1287, 2002.
- C. Oh, J. M. Tomczak, E. Gavves, M. Welling, "Combinatorial Bayesian Optimization using the Graph Cartesian Product", in Proceedings of NeurIPS 2019, BC, Canada, pp. 2910--2920.
- J. Leskovec, D. P. Huttenlocher, J. M. Kleinberg, "Predicting positive and negative links in online social networks", in Proceedings of WWW 2010, NC, USA.
- J. J. McAuley, J. Leskovec, "Learning to Discover Social Circles in Ego Networks", in Proceedings of NIPS 2012, NV, USA.
- G. Fursin, "Collective Tuning Initiative: automating and accelerating development and optimization of computing systems", in Proceedings of the GCC Developers' Summit 2009, QC, Canada.
- J. Blank, K. Deb, "Pymoo: Multi-Objective Optimization in Python", IEEE Access, vol. 8, pp. 89497--89509, 2020.
- T. Jones, S. Forrest, "Fitness Distance Correlation as a Measure of Problem Difficulty for Genetic Algorithms", in Proceedings of ICGA 1995, PA, USA, pp. 184--192.
- L. Altenberg, "Fitness Distance Correlation Analysis: An Instructive Counterexample", in Proceedings of ICGA 1997, MI, USA., pp. 57--64.
- E. Pitzer, M. Affenzeller, "A Comprehensive Survey on Fitness Landscape Analysis", Recent Advances in Intelligent Engineering Systems, 2012.
- F. Sehnke, C. Osendorfer, T. Ruckstiess, A. Graves, J. Peters, J. Schmidhuber, "Parameter-exploring policy gradients", Neural Netw., vol. 23, no. 4, pp. 551--559, 2010.
App. AUsing PGPE in the NIR-based Mutation Operator
In the NIR-based instance mutation operator described in Alg. 1, PGPE [50] is used as the optimizer. The details are shown in Alg. 3. Specifically, PGPE employs the symmetric sampling exploration strategy (lines 6-9) and the strategy update method (lines 16-20). It uses an iteratively updated multivariate Gaussian distribution to explore the vector space of problem instance embeddings. The problem instance embedding vector that has the lowest \(f\) value in this exploration process replaces the problem instance embedding vector in \(m\), yielding a new NIR \(m^\prime\) as the newly generated problem instance (line 15). The hyper-parameters in Alg. 3 are set to \(\boldsymbol{\sigma}^{init}=\boldsymbol{1}\), \(\alpha_{\mu}=0.05\), \(\alpha_{\sigma}=0.1\), and \(\sigma^{limit}=0.01\). Compared to the recommended configuration [50], we choose a larger \(\boldsymbol{\sigma}\) and a lower \(\alpha_{\sigma}\) to encourage the operator to find more diverse solutions.
App. BValue Ranges of BRKGA's Parameters
BRKGA [38] is used as the parameterized optimization algorithm in DACE, as mentioned in Section 4. The descriptions and value ranges of BRKGA's parameters are listed in Table 5 and Table 6, respectively.
App. CBRKGA-PAP, SMARTEST-PAP and PAPs Constructed Automatically
The specific configurations in BRKGA-PAP are listed below, where each configuration contains five values corresponding to the parameters in Table 5 in order: [20, 70, 10, 0.7, False], [20, 70, 10, 0.7, True], [15, 75, 10, 0.7, False], [15, 75, 10, 0.7, True].
Descriptions of the parameters of SMARTEST are listed in Table 7. The specific configurations in SMARTEST-PAP are listed below, where each configuration contains five values corresponding to the parameters in Table 7 in order: \(\left[100, 0.8, 0.1\right]\), \(\left[150, 0.8, 0.1\right]\), \(\left[100, 0.8, 0.2\right]\), \(\left[100, 0.5, 0.2\right]\).
The automatically constructed PAP configurations from the methods discussed in this paper are presented in Table 8. For each configuration listed, the fourth parameter (representing elite bias) is displayed with two decimal places, while the fifth parameter (indicating duplicate elimination) is abbreviated as T for True and F for False.
From the table, it appears that DACE and CEPS consistently generate PAPs with greater diversity. Specifically, compared with BRKGA-PAP, for the three parameters—elite, offspring, and mutation population sizes, the configurations in PAPs generated by DACE and CEPS tend to cover a broader range of values. In contrast, the recommended configurations included in BRKGA-PAP exhibit minimal variation across these parameters. Regarding the elite bias parameter, configurations in PAPs produced by DACE and CEPS also adopt diverse values, whereas BRKGA-PAP's recommended configurations only include the default setting. The PAPs generated by GLOBAL predominantly consist of the initial configurations \([200, 700, 100, 0.70, F]\), indicating that GLOBAL struggles to identify effective algorithm configurations within the allotted time. This limitation may be due to GLOBAL simultaneously optimizing all configurations in the PAP. PARHYDRA performs slightly better than GLOBAL, discovering multiple new algorithm configurations. However, on CAOP and CCP, PARHYDRA's PAPs retain one and two initial configurations, respectively. This suggests that, for these two problem domains, expanding PAP performance by identifying additional configurations based on a limited training instance set remains difficult.
App. DAccuracy of the NIR Obtained by Training Instances
To demonstrate the accuracy of the NIRs obtained from training instances, we present the loss performance on the validation set after training. It is worth noting that the validation set data does not appear during the training process, and the data size ratio between the training set and validation set is 3:1.
As can be observed from Table 11 and Fig. 7, both prediction loss and reconstruction loss have significantly decreased compared to the beginning of training. Consequently, the trained NIRs achieve excellent results on the validation data for both losses: the prediction loss (corresponding to the \(\textrm{MSE}\left(\boldsymbol{x}, \boldsymbol{x}^\prime\right)\) term in Eq. (9)) used to predict fitness values, and the reconstruction loss (corresponding to the \(\textrm{MSE}\left(y, y^\prime\right)\) term in Eq. (9)) designed to ensure the encoder correctly captures the structural features of solutions.
App. EExperiment on CCP with Training Instances that have Mixed Dimensions
To further investigate the feasibility of training on problem instances with varying dimensionalities, we conducted additional experiments on the contamination control problem (CCP).
In our initial experiment, we trained exclusively on 30-dimensional CCP instances. For this new investigation, we maintained all experimental parameters from Section 5, except we utilized training instances with dimensionalities of 31, 32, 33, 34, and 35. During training, we standardized the NIR dimensionality to 33. For 31- and 32-dimensional instances, we padded solutions to 33 dimensions, while for 34- and 35-dimensional instances, we truncated solutions to 33 dimensions. Notably, in NIR processing, we converted all zeros in solutions to -1, resulting in solution dimensions taking values of either 1 or -1. Padding operations appended zeros to the solution's end.
We designated the results from DACE training on mixed-dimensionality instances as \(\text{DACE}_{MixedDim}\). Table 9 presents the mean and standard deviation of solution quality achieved by each performance assessment protocol (PAP) across test instances of varying dimensions, along with Wilcoxon signed-rank test results comparing \(\text{DACE}_{MixedDim}\) against other methods. For a more detailed analysis, Table 10 provides instance-level win-draw-loss (W-D-L) counts derived from Wilcoxon rank-sum tests, quantifying instances where \(\text{DACE}_{MixedDim}\) performs significantly better than, statistically equivalent to, or significantly worse than the compared methods.
For 30-dimensional test instances, \(\text{DACE}_{MixedDim}\) exhibited performance comparable to standard DACE on CCP, with no statistically significant difference (Wilcoxon signed-rank test, \(p=0.05\)) despite CCP's marginally higher mean quality. Remarkably, for 40-dimensional instances, \(\text{DACE}_{MixedDim}\) significantly outperformed standard DACE, potentially attributable to reduced dimensionality disparity between training and test instances.
These findings suggest that the simple padding/truncation workaround can achieve reasonable performance across small dimensional spans when the dimensionality of training problem instances is mismatched. The reason might be that a small amount of padding or truncation does not affect the main information structure of the solution. In our experiments, we also observed that when the dimensional span of the training problem instances exceeds 10, the training process of NIR tends to overfit easily and is hard to achieve low loss on the validation set. This indicates that on training problem instances with even slightly larger dimensional spans, the training of NIRs still faces significant challenges.
App. FExperiments on OneMax Problem to Explore the Effectiveness of NIR
To further validate the effectiveness of our proposed NIR-based method for generating problem instances, particularly in terms of the similarity between the generated and authentic instances, we experiment on the OneMax Problem. The OneMax Problem is a simple binary optimization problem where each instance possesses a target string \(\boldsymbol{t}\). The objective is to find a solution \(\boldsymbol{x}\) that is as similar as possible to \(\boldsymbol{t}\). The objective function for the OneMax Problem is:
where \(d_I\) is the dimension of the problem instance.
In our experiment, we set the instance dimension \(d_I\) to 30 and randomly generate 5 instances with different target strings. Subsequently, the NIRs are trained following the procedure detailed in Section III of the main text. After training, the five NIRs (\(m_1, m_2, \cdots, m_5\)) share the same VAE and Hypernetwork, with the only difference being their instance embeddings. Their corresponding authentic OneMax Problem instances are denoted as \(s_1, s_2, \cdots, s_5\). Following this, we generate 15 NIRs, \(m^\prime_1, m^\prime_2, \cdots, m^\prime_{15}\), by replacing the instance embeddings in the trained models with 15 vectors sampled from the standard normal distribution \(\mathcal{N}\left(\mathbf{0}, I\right)\). These 15 newly generated NIRs have the same VAE and Hypernetwork as the five NIRs trained on authentic instances; they differ only in their instance embeddings.
Then, we identify the OneMax Problem instance that most closely resembles a given NIR, i.e., the closest instance to the NIR. First, we randomly generate a solution set \(X_1\in\left\{0,1\right\}^{100,000\times 30}\) and feed it into the NIR to obtain the predicted results \(\boldsymbol{y}_1^\prime\). The search for the corresponding authentic instance is then formulated as a binary optimization problem. Finding a OneMax Problem instance is essentially equivalent to finding its target string \(\boldsymbol{t}\), which is a binary vector. The objective function for this search process is:
where \(d_I\) is the instance dimension and \(\boldsymbol{y}_1\) is the evaluation result of the solution set \(X_1\) on the OneMax Problem instance defined by the target string \(\boldsymbol{t}\). Note that both \(\boldsymbol{y}_1\) and \(\boldsymbol{y}_1^\prime\) are normalized according to Eq. (11) in the main text. We then employ BRKGA as the solver for this optimization problem, with the number of function evaluations (#FEs) set to 10,000.
After identifying the most relevant target string \(\boldsymbol{t}\), we generate an additional, larger solution set \(X_2\in\left\{0,1\right\}^{500,000\times 30}\) as a validation set to validate its effectiveness. This set \(X_2\) is fed to the NIR to get the predicted results \(\boldsymbol{y}_2^\prime\), while \(\boldsymbol{y}_2\) represents the evaluation results of \(X_2\) on the OneMax Problem instance with the found target string \(\boldsymbol{t}\). This yields the objective value on the validation set, \(\mathcal{L}_2=\textrm{MSE}\left(\boldsymbol{y}_2^\prime, \boldsymbol{y}_2\right)\). Here, \(\boldsymbol{y}_2\) and \(\boldsymbol{y}_2^\prime\) are also normalized accordig to Eq. (11).
By applying this method to the five trained NIRs (\(m_1, m_2, \cdots, m_5\)), we identify their cloest authentic OneMax Problem instances. As shown in Table 12, the identified instance for each NIR is indeed its corresponding instance from the training set. Furthermore, the values of both \(\mathcal{L}_1\) and \(\mathcal{L}_2\) are extremely low, demonstrating that our NIRs can accurately model OneMax Problem instances. We also generate 10 NIRs by randomly sampling all weight parameters including VAE and Hypernetwork (note this is different from our NIR-based instance generation approach where only instance embeddings are sampled). After identifying the closest authentic OneMax instances for these NIRs and calculating their losses in Table 13, we find that they exhibit a significantly larger discrepancy compared to any authentic OneMax instances.
We then apply the same method to the 15 generated NIRs (\(m^\prime_1, m^\prime_2, \cdots, m^\prime_{15}\)) to find their corresponding closest authentic OneMax Problem instances. As presented in Table 14, the resulting \(\mathcal{L}_1\) and \(\mathcal{L}_2\) values are considerably lower compared to the values in Table 13 where NIRs are generated by randomly sampling all weight parameters (including VAE and Hypernetwork). Crucially, the values of \(\mathcal{L}_1\) and \(\mathcal{L}_2\) are very close, and we observed no cases where \(\mathcal{L}_2\) was significantly larger than \(\mathcal{L}_1\). This indicates that the NIRs, generated using random instance embeddings, exhibit a high degree of similarity to authentic OneMax Problem instances.
Furthermore, an interesting observation is that among the 15 target strings identified for the generated NIRs, six target strings are novel, while the remaining nine strings are identical to the target strings of the instances in the training set. This might be due to the relative simplicity of the OneMax Problem itself, which may have led to overfitting to the training instances, ultimately causing the learned Hypernetwork to have a bias towards generating Scorers with properties similar to those of the training instances. In summary, the above results demonstrate that our method is capable of generating new instances (in the form of NIRs) that differ from those in the training set, and resemble authentic instances belong to the same OM problem class.