Learning Interpretable Error Functions
for Combinatorial Optimization Problem Modeling

Twenty years separate Freuder’s papers Freuder (1997) and Freuder (2018), both about the grand challenges Constraint Programming (CP) must tackle “to be pioneer of a new usability science and to go on to engineering usability” Freuder (2007). To respond to the lack of a “Model and Run” approach in CP Puget (2004); Wallace (2003), several languages have been developed since the late 2000’s, such as ESSENCE Frisch et al. (2008), XCSP Boussemart et al. (2016) or MiniZinc Nethercote et al. (2007). However, they require users to have deep expertise on global constraints and to know how well these constraints, and their associated mechanisms such as propagators, are suiting the solver. We are still far from the original Holy Grail of CP: “the user states the problem, the computer solves it” Freuder (1997).

This paper makes a contribution in automatic CP problem modeling. We focus on Error Function Satisfaction and Optimization Problems we defined in the next section. Compare to classical Constraint Satisfaction and Constrained Optimization Problems, they rely on a finer structure about the problem: the cost functions network, which is, for this work, an ordered structure over invalid assignments that constraint solver can exploit efficiently to improve the search.

In this paper, we propose a method to learn error functions automatically; a direction that, to the best of our knowledge, had not been explored in Constraint Programming. We focus here on “easy-to-use” aspects of Constraint Programming.

To sum up, the main contributions of this paper are: 1. to give the first formal definition of Error Function Satisfaction Problems and Error Function Optimization Problems, 2. to introduce Interpretable Compositional Networks, a variant of neural networks to get interpretable results, 3. to propose an architecture of Interpretable Compositional Network to learn error functions, and 4. to provide a proof of concept by learning Interpretable Compositional Network models of error functions, using a genetic algorithm, and to show that most of models give scalable functions, and remain fairly effective using incomplete training sets.

Constraint Satisfaction Problem (CSP) and Constrained Optimization Problem (COP) are hard constraint-based problems defined upon a classical constraint network, where constraints can be seen as predicates allowing or forbidding some combinations of variable assignments.

Likewise, Error Function Satisfaction Problem (EFSP) and Error Function Optimization Problem (EFOP) are hard constraint-based problems defined upon a specific constraint network named cost function network Cooper et al. (2020). Constraints are then represented by cost functions $f:D_{1}\times D_{2}\times\ldots\times D_{n}\rightarrow E$, where $D_{i}$ is the domain of $i$-th variable in the constraint scope, $n$ the number of variables (i.e., the size of this scope) and $E$ the set of possible costs.

A cost function network is a quadruplet $\langle V,D,F,S\rangle$ where $V$ is a set of variables, $D$ the set of domains for each variable, i.e., the sets of values each variable can take, $F$ the set of cost functions and $S$ a cost structure. A cost structure is also a quadruplet $S=\langle E,\oplus,\bot,\top\rangle$ with $E$ the totally ordered set of possible costs, $\oplus$ a commutative, associative, and monotone aggregation operator and $\bot$ and $\top$ the neutral and absorbing elements of $\oplus$, respectively.

In Constraint Programming, cost functions are often associated to soft constraints: they can be interpreted as preferences over valid or acceptable assignments. However, this is not necessarily the case: it depends on the cost structure. For instance, the classical cost structure

$$S_{t/f}=\langle\{true,false\},\wedge,true,false\rangle$$

makes the cost function network equivalent to a classical constraint network, so dealing with hard constraints.

Here, we consider particular cost functions that represent hard constraints only, by considering the additive cost structure $S_{+}=\langle\mathbb{R},+,0,\infty\rangle$. The additive cost structure produces useful cost function networks capturing problems such as Maximum Probability Explanation (MPE) in Bayesian networks and Maximum A Posteriori (MAP) problems in Markov random fields Hurley et al. (2016).

In this paper, an error function is a cost function defined in a cost function network with the additive cost structure $S_{+}$. Intuitively, error functions are preferences over invalid assignments. Let $f_{c}$ be an error function representing a constraint $c$ and $\vec{x}_{c}$ be an assignment of variables in the scope of $c$. Then $f_{c}(\vec{x}_{c})=0$ iff $\vec{x}_{c}$ satisfies the constraint $c$. For all invalid assignments $\vec{i}_{c}$, $f_{c}(\vec{i}_{c})>0$ such that the closer $f_{c}(\vec{i}_{c})$ is to 0, the closer $\vec{i}_{c}$ is to satisfy $c$.

The goal of this paper is not to study the advantages of such cost function networks over regular constraint networks. Without formally defining EFSP and EFOP problems, some studies illustrate that solvers (in particular, metaheuristics) can exploit this structure efficiently leading to state-of-the-art experimental results, both in sequential Codognet and Diaz (2001) and parallel solving Caniou et al. (2015). In addition, our Experiment 3 shows that error functions representing the classic AllDifferent constraint gives models that clearly outperformed a model based on a regular constraint networks in terms of runtimes, for models with either hand-crafted or learned error functions.

Let $\vec{x}$ be a variable assignment, and denote by $\vec{x}_{c}$ the projection of $\vec{x}$ over variables in the scope of a constraint $c$. We can now define the EFSP and EFOP problems.

• Problem: Error Function Satisfaction Problem
  Input: A cost function network $\langle V,D,F,S_{+}\rangle$.
  Question: Does a variable assignment $\vec{x}$ exist such that $\forall f_{c}\in F,\ f_{c}(\vec{x}_{c})=0$ holds?

• Problem: Error Function Optimization Problem
  Input: A cost function network $\langle V,D,F,S_{+}\rangle$ and an objective function $o$.
  Question: Find a variable assignment $\vec{x}$ maximizing or minimizing the value of $o(\vec{x})$ such that $\forall f_{c}\in F,\ f_{c}(\vec{x}_{c})=0$ holds.

With the system we propose in this paper, users provide the usual constraint network $\langle V,D,C\rangle$, and it computes the equivalent cost function networks $\langle V,D,F,S_{+}\rangle$. Learned error functions composing the set $F$ are independent of the number of variables in constraints scope, and are expressed in an interpretable way: users can understand these functions and easily modify them at will. This way, users can have the power of EFSP and EFOP with the same modeling effort as for CSP and COP.

This work belongs to one of the three directions identified by Freuder Freuder (2007): Automation, i.e., “automating efficient and effective modeling and solving”. To the best of our knowledge, few efforts have been done on the modeling side.

Another of these three directions which is slightly related is Acquisition described by Freuder to be “acquiring a complete and correct representation of real problems”. Remarkable efforts on this topic have been done by Bessiere’s research team, for instance with constraints learning by induction from positive and negative examples Bessiere et al. (2005) and with interactive queries asked to users Bessiere et al. (2007), and with constraint network learning also through with interactive queries Bessiere et al. (2013).

Model Seeker Beldiceanu and Simonis (2012) is a passive learning system taking positive examples only, which are certainly easier for users to provide. It transforms examples into data adapted to the Global Constraint Catalog Beldiceanu et al. (2007), then generate and simplify candidates by eliminating dominated ones. Model Seeker is particularly efficient to find a good inner structure of the target constraint network.

Teso Teso (2019) gives a good survey on Constraint Learning with this interesting remark: “A major bottleneck of [constraint-based problem modeling] is that obtaining a formal constraint theory is non-obvious: designing an appropriate, working constraint satisfaction or optimization problem requires both domain and modeling expertise. For this reason, in many cases a modeling expert is hired and has to interact with domain expert to acquire informal requirements and turn them into a valid constraint theory. This process can be expensive and time-consuming.”

We can consider that Constraint Acquisition, or Constraint Learning, focuses on modeling expertise and puts domain expertise on background: users would not be able to understand and modify a learned model without the help of a modeling expert. The goal of these systems is mainly to simplify the interaction between the domain and the modeling experts.

Our work is taking the opposite direction: we focus on domain expertise and put modeling expertise on background. With our system, users always have the control over constraints’ representation, which can be modified at will to fit needs related to their domain expertise. Constraint Implementation Learning is what best describes this research topic.

The main result of this paper is to propose a method to automatically learn an error function representing a constraint, to make easier the modeling of EFSP/EFOP. We are tackling a regression problem since the goal is to find a function that outputs a target value. Before diving into the description of our method, we need to introduce some essential notions.

To show the versatility of our method, we tested it on five very different constraints: AllDifferent, Ordered, LinearSum, NoOverlap1D, and Minimum. According to XCSP specifications Boussemart et al. (2016)²²2see also http://xcsp.org/specifications, those global constraints belong to four different families: Comparison (AllDifferent and Ordered), Counting/Summing (LinearSum), Packing/Scheduling (NoOverlap1D) and Connection (Minimum). Again according to XCSP specifications, these five constraints are among the twenty most popular and common constraints. We give a brief description of those five constraints below:

• •

  AllDifferent ensures that variables must all be assigned to different values.

• •

  LinearSum ensures that the equation $x_{1}+x_{2}+\ldots+x_{n}=p$ holds, with the parameter $p$ a given integer.

• •

  Minimum ensures that the minimum value of an assignment verifies a given numerical condition. In this paper, we choose to consider that the minimum value must be greater than or equals to a given parameter $p$.

• •

  NoOverlap1D is considering variables as tasks, starting from a certain time (their value) and each with a given length $p$ (their parameter). The constraint ensures that no tasks are overlapping, i.e., for all indexes $i,j\in\{1,n\}$ with $n$ the number of variables, we have $x_{i}+p_{i}\leq x_{j}$ or $x_{j}+p_{j}\leq x_{i}$. To have a simpler code, we have considered in our system that all tasks have the same length $p$.

• •

  Ordered ensures that an assignment of $n$ variables $(x_{1}\mathrel{,}\ldots\mathrel{,}x_{n})$ must be ordered, given a total order. In this paper, we choose the total order $\leq$. Thus, for all indexes $i,j\in\{1,n\}$, $i<j$ implies $x_{i}\leq x_{j}$.

Like Freuder Freuder (2007) wrote: “This research program is not easy because ’ease of use’ is not a science.” However, we believe our result is a step toward the ’ease of use’ of Constraint Programming, and in particular about EFSP and EFOP. Our system is excellent for learning error functions of simple constraints over complete spaces. For intrinsically combinatorial constraints, learning over large, incomplete spaces should be favored. One of the most significant results in this paper is that our system outputs interpretable results, unlike regular artificial neural networks. Error functions output by our system are intelligible. This allows our system to have two operating modes: 1. a fully automatic system, where error functions are learned and called within our system, being completely transparent to users who only need to furnish a concept function for each constraint, in addition to the regular sets of variables $V$ and domains $D$, and 2. a decision support system, where users can look at a set of proposed error functions, pick up and modify the one they prefer.

The current limitation of our system is that it struggles to learn high-quality error function for very combinatorial constraints, such as Ordered and, in particular, NoOverlap1D. By combining results from Experiments 1 and 2, we can conclude that: 1. our system is not overfitting but need more diverse and expressive operations to learn a high-quality error function for such constraints, and 2. the Hamming cost is certainly not the better choice to represent their assignment error.

An extension of our work would be to do reinforcement learning rather than supervision learning based on the Hamming cost. Learning via reinforcement learning would allow finding error functions that are more adapted to the chosen solver.