Graph Learning for Numeric Planning

Authors: dillon z chen
sylvie  thiébaux
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-06 09:54:44

Abstract: Graph learning is naturally well suited for use in symbolic, object-centric planning due to its ability to exploit relational structures exhibited in planning domains and to take as input planning instances with arbitrary number of objects. Numeric planning is an extension of symbolic planning in which states may now also exhibit numeric variables. In this work, we propose data-efficient and interpretable machine learning models for learning to solve numeric planning tasks. This involves constructing a new graph kernel for graphs with both continuous and categorical attributes, as well as new optimisation methods for learning heuristic functions for numeric planning. Experiments show that our graph kernels are vastly more efficient and generalise better than graph neural networks for numeric planning, and also yield competitive coverage performance over domain-independent numeric planners.

Main paper: 
 introduction: 
 Planning requires long range reasoning over combinatorially large state spaces. Numeric planning is an extension of classical planning in which states have numeric variables and the underlying transition system is built from inequality conditions and assignments over arithmetic expressions of such variables. It was formalised in PDDL 2.1 [FL03] and is undecidable in the general case [Hel02] which makes it more difficult than classical planning which is PSPACE-complete [Byl94] . Numeric planning is a well-established problem in the symbolic AI community and exhibits significant research effort [CCFL13, IM17, SHTR20, KSP + 22, KSB23, SKB23] , but this expressivity result implies that building a general, scalable numeric planner is a challenging problem.Learning for Planning (L4P) is a research direction which focuses on learning to solve problems from a specified domain in an automated supervised manner [TTTX20, STT20, FGT + 22, KS21, SBG22, SBG23, MLTK23, CTT24a, SDS + 24, RTG + 24, APK24]. Planning tasks in L4P are assumed to exhibit a factored, symbolic representation, which allow us to generate training data in a matter of seconds from easy to solve tasks with a domain-independent planner. We can then learn domain knowledge in a supervised manner that scales planners to significantly larger planning tasks. This is in contrast to Reinforcement Learning where agents do not require access to well-defined models but spend significant amounts of time exploring and learning from rewards [SB98] . Regardless, several works have showed that encoding or learning symbolic models for sequential decision making reasoning and embodied AI tasks [LCZ + 21, ZYP + 22, LSS + 22, SCK + 23, KVS + 23, LPM23] provided better performance and transparency over end-to-end reinforcement learning methods. Furthermore, it was shown recently that classical ML methods are much better suited for L4P than deep learning methods for symbolic planning [CTT24b] as they (1) can generalise well from small training data, (2) are orders of magnitude more efficient to train and evaluate than deep learning methods, which is important in time sensitive tasks such as planning, and (3) have interpretable features to understand what is being learned.In this paper we study whether this fact carries over to Learning for Numeric Planning (L4NP) [WT24] which now requires reasoning over logic and arithmetic. It is reasonable to think that because neural networks are function approximators, they may offer better reasoning capabilities over numbers than 38th Conference on Neural Information Processing Systems (NeurIPS 2024). just symbols alone. In this paper, we describe the GOOSE1 framework with classical ML and deep learning configurations for learning heuristic or value functions for use with search in L4NP. Fig. 1 illustrates the GOOSE framework and we outline our contributions as follows.• We introduce a new graph representation of numeric planning tasks for use with classical and deep graph learning methods, namely graph kernels and graph neural networks, respectively. • We extend the WL kernel [SSVL + 11] to handle graphs with both continuous and categorical attributes in a meaningful way which we call the CCWL kernel. • We introduce new ranking formulations [GKL16, CEKP23, HTT + 24] for learning heuristic or value functions with linear programs.The structure of the remainder of the paper is as follows. In Sec. 2, we provide the necessary formalism and background for numeric planning, as well as relevant notation. In Sec. 3, we introduce a new graph encoding νILG and CCWL kernel for generating features for numeric planning tasks. In Sec. 4, we introduce a deep learning architecture for L4NP using graph neural networks. In Sec. 5, we describe optimisation methods for L4NP, involving a new ranking formulation for learning heuristic functions. In Sec. 6, we describe our experimental setup and results. Related work is discussed in Sec. B in the appendix. We conclude the paper with final comments in Sec. 8. 
background: 
 Numeric Planning Task. A numeric planning task can be viewed as a compact representation of a deterministic, goal-conditioned Markov Decision Process with the use of predicate logic and relational numeric variables. A majority of the remainder of this section formalises the necessary components of a numeric planning task we use in the paper.A numeric planning task [FL03] is given by a tuple Π = ⟨X p , X n , A, s 0 , G⟩ where X p is a finite set of propositional variables with domain {⊤, ⊥} and X n is a finite set of numeric variables with domain R. Let X = X p ∪ X n denote the set of state variables, where a state is a total assignment of values the propositional and numeric variables. The variables implicitly induce a possibly infinite set of states S, where s 0 is the initial state.A propositional condition is a positive (resp. negative) literal x = ⊤ (resp. ⊥) for some propositional variable x ∈ X p , and a numeric condition has the form ξ ⊵ 0 where ξ is an arithmetic expression over numeric variables and ⊵ ∈ {≥, >, =}. We write [x] s (resp. [ξ] s ) for the value of a state variable x (resp. expression ξ) in state s, and V (ξ) for the set of numeric state variables in ξ. A state s satisfies a set of conditions (i.e. a set of propositional and numeric conditions) if each condition in the set evaluates to true given the values of the state variables in s. The goal G is a set of conditions and we write G p (resp. G n ) for the subset of propositional (resp. numeric) goal conditions.The set A contains a finite number of actions, each consisting of preconditions and effects. Action preconditions pre(a) are sets of conditions, and action effects assign Boolean values to propositional variables and assign the value of an arithmetic expression to numeric variables. An action a is applicable in a state s if s satisfies pre(a), in which case its successor a(s) is the state where the effects eff(a) are applied to the state variables in s. If a is not applicable in s, we set a(s) = s ⊥ ̸ ∈ S.Each action a has a cost c(a) given by an arithmetic expression.A plan for a numeric planning task is a sequence of actions π = a 1 , . . . , a n such that s i = a i (s i-1 ) ̸ = s ⊥ for all 1 ≤ i ≤ n and s n satisfies G; we call s 0 , s 1 , . . . , s n the plan trace of the plan. The plan length |π| and the plan cost are the number of actions in the plan, and the sum of their cost, respectively. A plan is optimal if it has the minimum cost among all plans. A numeric planning task is solvable if there exists a plan for it, and is unsolvable otherwise. A state s is a deadend if the task with the initial state replaced with s is unsolvable. Satisficing planning refers to the problem of finding a plan if it exists, or proving that the problem is unsolvable. Optimal planning refers to the problem of finding an optimal plan if it exists, or proving that the problem is unsolvable.Lifted representation. Numeric planning tasks can be compactly encoded in a lifted representation ⟨O, Σ p , Σ f , Σ a , A, s 0 , G⟩ whereby state variables are derived from a set of predicates, functions, and objects. Formally Σ p and Σ f are sets of predicate and function symbols, respectively. Each symbol σ ∈ Σ p ∪ Σ f , has an arity n σ ∈ N ∪ {0} which depends on σ. Predicates and functions take the form p(x 1 , . . . , x np ) and f (x 1 , . . . , x n f ), respectively, where the x i s are their arguments. Given the set O of objects, the propositional and numeric variables are obtained by substituting objects for the arguments of the predicates and functions, resulting in the grounded form p(o 1 , . . . , o np ) and f (o 1 , . . . , o n f ), respectively, where the o i s are objects. Similarly, actions can be represented in a lifted form via a set Σ a of action symbols and a set A of action schemata mapping action symbols to their lifted precondition and effect definitions in terms of predicates and functions. Grounding the set of action schemata results in the set of actions A of the planning task. Details are not needed to understand this paper. A domain is a set of numeric planning tasks sharing the same set of Σ p , Σ f , Σ a , and A, and may have constant objects, objects which are shared across all tasks in the domain.Example: Capacity Constrained Blocksworld. To help digest some of the definitions of numeric planning, we provide an example with a planning domain we call Capacity Constrained Blocksworld (ccBlocksworld). It is an extension of the original Blocksworld domain in which state consists of towers of blocks and the objective is to stack and unstack blocks to achieve a goal configuration. It is also a special case of the Hydraulic Blocksworld domain for planning with state constraints, in which blocks are placed on top of pistons which rise or fall depending on the configurations of other pistons [HIR + 18].In ccBlocksworld, we have a maximum number of tower locations, and each tower has a base limited by the number of blocks it can hold. To model this domain in the lifted representation, we retain the predicate on(x, y) from the original Blocksworld, which indicates block x is on another block or base y. Next, we also introduce the function capacity(z) which denotes the remaining number of blocks that are allowed to be placed on base z. The numeric variables instantiated from capacity may increase or decrease depending on whether blocks are unstacked from the tower or stacked on top of it. Action schemata preconditions constrain whether a block can be placed on a tower with base that has reached its capacity limit or not. The leftmost figure in Fig. 2 illustrates an example of a ccBlocksworld problem with an initial state and goal condition. We refer to the Sec. A of the appendix for the complete state representation of the problem as well as its PDDL encoding.Heuristics and Greedy Best First Search. State-of-the-art methods for both satisficing and optimal numeric planning [SHTR20, KSP + 22, CT24] employ some variant of heuristic search. A heuristic function maps a state s to R ∪ {∞} representing an estimate of the cost to reach the goal from the current state, where a value of ∞ estimates that s is a deadend. The optimal heuristic h * maps a state to the cost of an optimal plan if it exists, and ∞ otherwise. The Greedy Best First Search (GBFS) algorithm consists of a priority queue initialised with the initial state as the only element, and a main loop which performs the following steps while the queue is non-empty: (1) pop a state s with the lowest heuristic value and some tie-breaking criterion from the queue, (2) generate the successors of s via all applicable actions, and (3) check if a successor s ′ is a goal, in which case terminate with the plan traced back from s ′ , and otherwise add s ′ to the queue if it has not been seen before. The algorithm determines a problem is unsolvable if the main loop completes, in which case the problem has finitely many states of which all have been seen.Graph and other notations. Let G = ⟨V, E, F cat , F con , L⟩ denote a graph with nodes V, undirected edges E ⊆ V 2 , categorical node features F cat : V → Σ V where Σ V is a finite set, continuous node features F con : V → R d with d ∈ N, and edge labels (categorical edge features) L : E → Σ E where Σ E is a finite set. The neighbourhood of a node u ∈ V in a graph with respect to an edge label ι is defined by N ι (u) = {v | ∃e ∈ E, s.t. e = ⟨u, v⟩ = ⟨v, u⟩ ∧ L(e) = ι} . We use ∥ to denote the concatenation operator for vectors, and [[N ]] to denote {1, . . . , N }. 
relational features for numeric planning: 
 In this section, we describe an automatic method for generating embeddings for numeric planning tasks that may be used for any downstream inference model. The method is an extension of the feature generation method for classical planning [CTT24b] and consists of two main steps: (1) generating a graph representation of a planning task, and (2) running a variant of the WL-algorithm for generating features for the graph [SSVL + 11]. Extending the first step of the method is simple as it is easy to extend the graph encoding to capture numeric information of the task. This is done in Sec. 3.1 where we introduce the Numeric Instance Learning Graph (νILG) representation for numeric planning tasks. The second step is more difficult as we require constructing a WL-algorithm variant that can handle both categorical and continuous nodes features in a meaningful way for numeric planning. This is where we introduce the CCWL algorithm in Sec. 3.2 that handle such node features. Thus, we can generate features for numeric planning tasks by first converting them into the νILG representation, and then running the CCWL algorithm on them.We begin by describing our graph encoding of a planning task, namely the Numeric Instance Learning Graph (νILG). Similarly to the classical case, the graph representation does not encode the transition model of the planning task nor requires grounding all possible variables in the planning task. Thus, our encoding only requires a first-order representation of states, and therefore applies to problems whose transition model is unknown such as in model-free reinforcement learning.We begin with a descriptive definition of the graph with an example Fig. 2 illustrating a subgraph of the νILG representation of the example ccBlocksworld problem. In the figure, the nodes in the graph represent the objects (light blue), propositional variables true in the state (green), numeric variables (red), propositional goals (yellow) and numeric goals (not present in the example) of the problem. Blue (resp. orange) edges connect object nodes to goal and variable nodes where the object is instantiated in the first (resp. second) argument of the corresponding node variable or condition.We provide the formal definition below. Let X p (s) denote the set of propositional variables that are true in s, X n (s) the set of numeric variables, and X(s) = X p (s) ∪ X n (s). Definition 3.1 (Numeric Instance Learning Graph). The Numeric Instance Learning Graph (νILG) of a numeric planning task in the lifted representationΠ = ⟨O, Σ p , Σ f , Σ a , A, s 0 , G⟩ is a graph G = ⟨V, E, F cat , F con , L⟩ with • nodes V = O ∪ X(s 0 ) ∪ G,where we assume w.l.o.g. that V (g) ⊆ X(s 0 ) for all g ∈ G n ,• edges E = p=σ(o1,...,on σ )∈X(s0)∪Gp {⟨p,o i ⟩ | i ∈ [[n σ ]]} ∪ ξ⊵0∈Gn {⟨ξ, v⟩ | v ∈ V (g)}, • categorical node features F cat : V → Σ V with F cat (u) =    OBJ(u) if u ∈ O FUNC(u) if u ∈ Xn(s0) (COMP(u), ACH(u)) if u ∈ Gn    (PRED(u), achieved_propositional_goal) if u ∈ Xp(s0) ∩ Gp (PRED(u), unachieved_propositional_goal) if u ∈ Gp \ Xp(s0) (PRED(u), achieved_propositional_nongoal) if u ∈ Xp(s0) \ Gpwhere OBJ(u) = u if u is a constant object and object otherwise, PRED(u)/FUNC(u) returns the predicate/function symbol from which a proposition/fluent was instantiated from, COMP(u) ∈ {≥, >, =} encodes the comparator type of the numeric goal condition u, and ACH(u) ∈ {unachieved_numeric_goal, achieved_numeric_goal} encodes whether s 0 satisfies u,• continuous node features Lines 1-3 of Alg. 1 are the original steps of the WL algorithm for generating graph embeddings by iteratively refining categorical node features, which we call colours, with two differences. Firstly, we replaced the multi-set with a set in the input of the hashing function. This is because in planning, unseen colours arise from graphs with increasing degrees which occur for out-of-distribution testing problems of increasing size. This problem is limited by relaxing the hash input with a set, which trades expressivity for generalisation. Secondly, we make use of edge labels in the hashing function.F con : V → R where F con (u) = [u] s0 for nodes u ∈ X n (s 0 ), F con (u) = [ξ] s0 for nodes u = ξ ⊵ 0 ∈ G n with [ξ] s0 ̸ ⊵0,(1+d)|C| . κ 0 (v) ← F cat (v), ∀v ∈ V for j ∈ [[L]] do for v ∈ V do κ j (v) ← HASH κ j-1 (v), ι∈ΣE {(κ j-1 (u), ι) | u ∈ N ι (v)} M ← j∈{0}∪[[L]] { {κ j (v) | v ∈ V} } ⃗ v cat ← COUNT(M, c 1 ), . . . , COUNT(M, c |C| ) S i = v | v ∈ V s.t. ∃j ∈ {0} ∪ [[L]] , κ j (v) = c i , ∀i ∈ C ⃗ v con ← [con(1) ∥ . . . ∥ con(|C|)], con(i) = POOL v∈Si (F con (v)) return ⃗ v cat ∥ ⃗ v con 1 1 2 1 [0.2, 0.4] [0.3, 1.3] [0.5, 1.5] [0.2, 0.4] iter 0 β α γ β 3 4 5 3 iter 1 HASH(1, {(1, α), (1, β)}) = 3 HASH(1, {(1, β), (2, γ)}) = 4 HASH(2, {(1, γ)}) = 5 con(1) = [0.7 2.1], con(2) = [0.5 1.5] con(3) = [0.4 0.8], con(4) = [0.3 1.3] [3 1 2 1 ⃗ v cat 0.7 2.1 0.5 1.5 0.4 0.8 0.3 1.3 ⃗ vcon ]Lines 4-5 collect the counts of allowed colours C seen during the main loop of the algorithm to generate the categorical feature vector in the form of a histogram. We assume by relabelling colours that C = [[|C|]]. Lines 6-7 generate features from pooling the continuous attributes from different groups of nodes. More specifically, for each colour c ∈ C, we find the set of nodes which have been assigned the colour c some time during the refinement process and pool the continuous attributes of these nodes. Thus, we have |C| pooled continuous feature vectors which we concatenate together. We note that this pooling and concatenation process is invariant to the order of nodes in a graph in contrast to the intermediate graph embeddings generated for Wasserstein WL graph kernels by Togninalli et al. [TGL + 19]. The algorithm returns the concatenation of the categorical and continuous feature vectors as the final feature vector output for the graph in Line 8. We note that d = 1 when running CCWL on the νILG representation of a numeric planning task.We note that a drawback of the algorithm is that continuous attributes are not refined directly. This could be done by introducing one or more aggregation functions as parameters to the algorithm and refining continuous attributes by concatenating the aggregations of their neighbouring attributes. However, this method introduces an increase in the size of the continuous feature vector exponential in the number of layers, with base equal to the number of aggregation functions chosen. Moreover, we noted from informal experiments that this method led to overfitting of models to a large number of blended continuous features that do not have an obvious relation to the learning target.Assuming a constant time hashing function, the complexity of the CCWL algorithm is O(nL(δ + d))where n = |V | of the input graph, δ = max u∈V ι∈L |N ι (u)| is the degree of the graph, d is the dimension of the continuous node attributes, and L is the number of layers. The main computation comes from Line 3 which is performed nL times and the hashing function takes an input of size δ. Collecting the categorical feature vector takes the same time, while collecting the continuous feature vector takes O(nLd) time. For reasonably sized d ≲ δ, as in the case of νILG where d = 1, this is the same complexity as the original WL algorithm for generating graph features, which is O(nLδ). 
relational neural networks for numeric planning: 
 Deep learning architectures such as graph neural networks (GNNs) [SGT + 09, GSR + 17] benefit in generating latent representations automatically with backpropagation when trained end-toend [LBH15] . GNNs also benefit from being able to train and evaluate on arbitrary sized graphs. However, it is generally understood that the expressive power of GNNs is limited by the WL-algorithm and counting logics with two variables [XHLJ19, BKM + 20]. This result translates to the impossibility result of GNNs not being able to learn features that can work well for arbitrary planning domains [SBG22, CTT24a] . Nevertheless, their application to numeric planning tasks, in which both logical and numeric reasoning is required, is less well understood. Thus, we still propose GNNs as an additional baseline for L4NP and empirically evaluate their performance for numeric planning in Sec. 6.For our GNN architecture, we perform a transformation on the node features of the νILG from 3.1 as input for GNNs that can handle edge labels. More specifically, given a νILGG = ⟨V, E, F cat : V → Σ V , F con → R, L⟩, we construct a new graph G ′ with continuous node attributes X : V → R |ΣV|+2 defined by X(u) = OH(F cat (u)) ∥[r 1 , r 2 ],where OH(F cat (u)) ∈ {0, 1} |ΣV| ⊆ R |ΣV| denotes a one-hot encoding of the categorical node feature of u, and r 1 denotes the numerical value of numeric variable nodes defined by r 1 = [u] s0 if u ∈ X n (s 0 ) and r 1 = 0 otherwise, and r 2 denotes the goal error for numeric goal nodes defined by r 2 = [u] s0 if u ∈ G n and r 2 = 0 otherwise. We denote the νILG for GNNs by ⟨V, E, X, L⟩ with notation for categorical features removed. Thus, we can use this graph encoding of numeric planning tasks as input into any downstream GNN that can handle edge labels or features. Fig. 2 illustrates the node feature matrix representation of the νILG encoding of a ccBlocksworld task for input to a GNN. Each row represents a node in the graph, with columns representing the semantics of the node as well as the value of the numeric variables in the state and error of numeric goal nodes. We note however, that the ccBlocksworld example does not have any numeric goals and thus the last column is zero for all entries.Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?Answer: [Yes] Justification: we have done our best in the given space limits to describe in detail the experimental setup and algorithms used. We have also provided descriptions of the new datasets used. 
optimisation formulations for learning heuristic functions: 
 In this section, we describe two optimisation methods used for learning heuristic functions from training data, namely by minimising cost-to-go estimate error and ranking estimate error. Fig. 4 illustrates examples of learned heuristic functions on states of a planning task when trained to zero loss with both the cost-to-go and ranking formulations. We assume that training data for our models consist of a set of numeric planning tasks Π 1 , . . . , Π n with corresponding optimal plans π 1 , . . . , π n . A cost-to-go heuristic can achieve 0 loss on the plan trace but may not generalise correctly to state successors. A ranking heuristic does not need represent correct cost-to-go values and only need to satisfy ranking constraints. GBFS will return a plan in linear time for the ranking heuristic here but not for the cost-to-go heuristic.We note that a numeric planning task can offer more training data by generating additional tasks and plans from different states in the state space of the task. Each plan is denotedEQUATION|πi| with plan trace s(i) 0 , s (i) 1 , . . . , s (i)|πi| . Each state s in a plan trace induces a new planning task by replacing s 0 with s of the original task, with which we can construct graph or vector representations from our aforementioned models.Heuristic functions from cost-to-go estimates. We can use planning tasks and corresponding optimal plans as training data for learning a heuristic function representing the estimated cost-to-go to the plan. Each task and corresponding plan π i contributes training data s (i) j with targets h * (s(i) j ) for each state s (i)j in the plan trace of π i . Then given an estimator H, we may try to find weights that minimise the mean squared error (MSE)L(θ) = 1 N n i=1 |πi| j=0 h * (s (i) j ) -H θ (s (i) j )2 where N is the normalisation constant and H θ denotes the estimator with weights θ.Heuristic functions from ranking estimates. The MSE loss is a simple but naive method for training a heuristic function. Various researchers have instead proposed to use the concept of ranking to learn heuristic functions [GKL16, CEKP23, HTT + 24]. However, a drawback of the formulation of the ranking optimisation of previous works is that a state in a plan trace is marked as strictly better as its siblings when it could be the case that the siblings may have the same h * value. Furthermore, the formulation in [CEKP23] scales quadratically in the plan trace. We offer a novel ranking optimisation criterion that (1) fixes the problem of siblings being misclassified and (2) also results in a sparse model. We also offer a corresponding differentiable loss function for use with any end-to-end model.Our first ranking formulation requires solving an LP as the optimisation problem, similarly to [FCGP19] but only using states from the plan trace, whereas the latter work uses states from the entire state space of the problem. It can also be viewed as an LP encoding of the formulation by Garrett et al. [GKL16] but fixing the problem of misrepresented siblings and learning sparse weights. Let SUCCS(s) denote the set of successors of the state s in a planning task by applying all applicable actions at s. Hence the set of siblings of state s(i) j in Π i 's state space is SIBLINGS(s (i) j ) = SUCCS(s (i) j-1 ) \ {s (i) j }.Let φ denote our feature generation function with φ(s) ∈ R d for any state s. Then we can define our optimisation problem as a linear program defined byEQUATIONw ⊤ (φ(s(i) j-1 ) -φ(s (i) j )) ≥ cost(a (i) j ) -zi,j,0 ∀i ∈ [[n]] , j ∈ [[|πi|]] w ⊤ (φ(sα) -φ(s (i) j )) ≥ -zi,j,α ∀i ∈ [[n]] , j ∈ [[|πi|]] , sα ∈ SIBLINGS(s (i) j ).The vector w represents the weights our linear model aims to learn, and the nonnegative slack variables z model the soft inequality constraints representing the ranking of states. The optimisation problem is to minimise the the slack variables corresponding to the error of the constraints, and the ℓ 1 norm of the weights to encourage sparsity.We next offer a differentiable loss function version of the previous model which we can use as a fair comparison when combining it with our GNN architecture in Sec. 4 compared to combining (1) with features generated in Sec. 3. The idea is to replace the slack variables with the max function: 6 ExperimentsEQUATIONQuestion: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?Answer: [Yes] Justification: we aim to provide open access to our code and new datasets.Guidelines:• The answer NA means that paper does not include experiments requiring code. • Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted. 
numeric planning benchmarks: 
 We take 8 domains out of 10 domains from the International Planning Competition 2023 Learning Track (IPC-LT) [SSA23] and either convert them to equivalent numeric formulations, or introduce numeric variables to model extra features such as capacity constraints. The two domains from the IPC-LT that we do not convert into numeric domains are Floortile and Sokoban which do not have any benefit from compilation to a numeric representation nor exhibit any interesting features that can be modelled with numeric variables. The domains we considered from the IPC-LT are summarised in Fig. 5 alongside the sizes of training and testing tasks, and time to generate training data. Each domain consists of 90 testing problems and at most 99 small training problems for which the median time for generating an optimal training plan is less than a second and a few outliers taking more than a minute. We refer to the appendix for further details on the domains.Training. As discussed in Sec. 5, we only consider optimal plans from small problems as training data. We compute them with the Numeric Fast Downward planner [AN17] using A * search and the admissible h LMCUT heuristic [KSP + 22], with a 30 minute timeout and 8GB main memory.We consider 4 model configurations. Firstly, we use CCWL features from Sec. 3 with Support Vector Regression and the linear dot product kernel to learn a linear model for cost-to-go estimation (h CCWLF cost). Next, we use CCWL features in optimisation problem in (1) with CPLEX version 22.11 and a timeout of 600 seconds for ranking estimation (h CCWLF rank ). Both h CCWLF cost and h CCWLF rank models have allowed colours C in Alg. 1 given by all the refined colours seen during training. We also have cost-to-go (h GNN cost ) and ranking (h GNN rank ) estimation models using GNNs operating on νILG representations of planning tasks and optimised with the MSE loss function and (2), respectively. For the backbone GNN, we use a Relational Graph Convolution Network [SKB + 18] but replacing the mean aggregation function with the element-wise max operator in the message-passing update step: h(l+1) u = σ(W 0 h (l) u + ι∈ΣE max v∈Nι(u) W (l) ι h (l) v ), where l denotes the GNN layer, σ is implemented with the leaky ReLU function, and W 0 and W (l) ι are learnable weight matrices. Each GNN has a hidden dimension of 64, and is trained with the Adam optimiser [KB15] with an initial learning rate of 10 -3 and batch size of 16. A scheduler reduces the training loss by a factor of 10 if loss does not improve after 10 epochs. Training then terminates if the learning rate falls below 10 -5 . Let L denote the iterations hyperparameter for CCWL models and number of layers for GNN models.Evaluation. We consider several numeric planners as baselines for benchmarking the effectiveness of learning. We first include h LMCUT as the only optimal planner baseline as it is also the training data generator but solves a more difficult problem of optimal planning compared to satisficing planning. We consider the Metric-FF planner (M-FF) [Hof03] , and the h ADD , h MRP , h MRP +hj and M(3h∥3n) configurations in the ENHSP planner [SHTR20, SSSG20, CT24]. We have that h ADD and h MRP are planners that perform GBFS with a single heuristic only, while h MRP +hj and M(3h∥3n) use additional techniques (macro actions, multiple queues, and novelty heuristics) to boost planning performance. Our CCWL and GNN models are all used in single-queue GBFS with the learned heuristic function, with Numeric Fast Downward as the backend search implementation. All baselines and models are run on a single Intel Xeon Platinum 8268 (2.90 GHz) core with a 5 minute timeout for search and 8GB of main memory. Tab. 1 summarises the coverage results of all considered planners on the benchmarks, with more details provided in the appendix.How do learning approaches compare to domain-independent numeric planners? From Tab. 1, we note that our best performing model with L = 1 is h CCWLF rank and outperforms all domainindependent planners for satisficing planning on 4 out of 8 domains. Increasing L to 2 brings h CCWLF rank to achieve the best coverage on Blocksworld. The domains which learners fall behind on are Rovers, Satellite and Transport, even when taking the best hyperparameter configuration. The former two are difficult as they require features more expressive than those generated by graph learning approaches to capture the semantics of reasoning required to solve the problems [SBG22] , while the latter requires path finding which is not possible for learners with finite receptive fields [TTTX20] . These results hold for classical planning and thus also for our extension to numeric planning. Generally the best performing planner on a domain expands fewer nodes than the other planners. With regards to plan length, h CCWLF rank performs best for Blocksworld but is marginally worse than the best of the domain-independent numeric planners for Rovers, Satellite and Spanner.How do CCWL models compare to GNN models? From Tab. 1, we see that the CCWL models always have similar or better performance than the corresponding GNN models, when comparing cost-to-go and ranking estimates. The performance of a planners which use GBFS and a heuristic depend on the heuristic evaluation speed, in which more search can be done in the time limit, or the quality of the heuristic, in which search can be more informed. Fig. 8 in the appendix shows that GNN are generally at least an order of magnitude slower than CCWL models for heuristic evaluation due to performing intensive matrix operations. We note that GNN models are evaluated on CPUs and could be sped up with access GPUs. Fig. 6a illustrates the number of node expansions of GNN and CCWL models and we note that there is no clear winner between the two approaches across all domains, with the exception of h CCWLF rank generalising perfectly on Childsnack where other models could not. Thus, we can conclude with respect to planning efficiency that CCWL models generally outperform their GNN counterparts due to faster heuristic evaluation speeds, while generally both models have similar generalisation performance.How do ranking models compare to cost-to-go models? From Tab. 1, ranking models outperform cost-to-go models in total coverage. However, their performance is incomparable across domains even when looking at Fig. 6b with the exception of CCWL being able to achieve perfect performance on Childsnack. Nevertheless, on 8 domain-model pairs for L = 1, ranking models achieve strictly better coverage, while the converse is only true for 4 domain-model pairs. This suggests a bias favouring ranking models which can be explained by their advantages covered in Sec. 5, namely that they implicitly use more training data by considering successor states of plan trace states, and have a larger solution space as they are not restricted to predicting an exact value.What is the effect of number of iterations for CCWL models and layers for GNNs? The hyperparameter L, which denotes the number of iterations (resp. layers) for CCWL (resp. GNN) models, generally plays an important role in planning performance. This is because increasing L improves model expressivity and reasoning capabilities, but comes at the cost of heuristic evaluation time and increased possibility of overfitting to the training data. From Tab. 2 in the appendix, we note that surprisingly for most domains and models L = 0 or L = 1 provides the best coverage, while increasing L rarely improves coverage. This suggests that heuristic evaluation time plays an important role in planning performance for domains that cannot be solved with the learner's expressivity.Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?Answer: [Yes]Justification: details of training and test details are given in the corresponding experimental section of the paper.Guidelines:• The answer NA means that the paper does not include experiments.• The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them. • The full details can be provided either with the code, in appendix, or as supplemental material. 
limitations: 
 The setup of our work is limited to the assumption that the problems being solved can be explicitly represented in a symbolic language such as PDDL. The assumption of the existence of PDDL encodings of planning problems allows us to generate training data quickly with domain-independent numeric planners for supervised training. Furthermore, experiments and theoretical insights also show that our proposed techniques have room for improvement as there are still classes of numeric planning tasks with which our models cannot learn and generalise well in.Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?Answer: [No] Justification: evaluation of planning tasks is also expensive to run and thus are only ran once.Informal experiments also show that training with different seeds offer minor variance in performance.Guidelines:• The answer NA means that the paper does not include experiments.• The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.• The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). • The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) • The assumptions made should be given (e.g., Normally distributed errors). • It should be clear whether the error bar is the standard deviation or the standard error of the mean. Justification: our research is mainly foundational and not tied to particular applications. It is mainly focused on improving the efficiency and effectiveness of underlying algorithms. Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
conclusion: 
 We  
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?Answer: [NA]Justification: there is no obvious method for our data (PDDL files) or models (planners) that may have a high risk of misuse.Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?Answer: [Yes]Justification: original owners of datasets from which we create new benchmarks are properly cited and their licenses respected.Guidelines:• The answer NA means that the paper does not use existing assets.• The authors should cite the original paper that produced the code package or dataset.• The authors should state which version of the asset is used and, if possible, include a URL. • The name of the license (e.g., CC-BY 4.0) should be included for each asset.• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided. • If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset. • For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. • If this information is not available online, the authors are encouraged to reach out to the asset's creators. 
new assets: 
 Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?Answer: [Yes]Justification: we will provide detailed documentation of our new datasets and planners when we release them.Guidelines:• The answer NA means that the paper does not release new assets.• Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc. • The paper should discuss whether and how consent was obtained from people whose asset is used. • At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file. 
crowdsourcing and research with human subjects: 
 Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?Answer: [NA] Justification: we do not do crowdsourcing experiments nor research with human subjects.Guidelines:• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. • Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. • According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector. 
institutional review board (irb) approvals or equivalent for research with human subjects: 
 Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?Answer: [NA] Justification: same justification as previous question.Guidelines:• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.• Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper. • We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review. 
 
 Appendix: We repeat the running ccBlocksworld example in Fig. 7 . Listings 2 and 1 provide the explicit PDDL domain and problem encodings for the running ccBlocksworld example. An optimal plan for the problem is given as follows on the left, and an optimal plan without capacity constraints on the right.Two related fields to Learning For Planning (L4P) and Learning For Numeric Planning (L4NP) are Generalised Planning (GP) and Reinforcement Learning (RL). In the following subsections, we outline the main difference between L4P with the respective related fields as well as corresponding related work.GP consists of automatically characterising the solution of a (possibly infinite) set of planning tasks [Sri10, SIZ08] . The most common characterisations are action policies, but other characterisations also include finite state controllers [BPG09, BPG10, HG11, HG13, AJJ18], and programs with branching and looping [AJJ21, ACSJ22] . Logic programming approaches involving decision lists [Kha99, GT04] and Datalog programs [GRH24, CHŠ24] have also been used to characterise solutions for planning domains. We refer to articles [CAJ19] and [Sri23] for more detailed surveys of GP. The difference L4P and GP can be subtle given that there is a non-empty intersection between the two fields, and works in both fields generally aim to compute structures that solve problems from a given domain. The way we differentiate the two fields is that L4P follows generally follows traditional supervised learning approaches, whereas GP can be likened to performing program synthesis.With regards to numeric planning, Srivastava et al. [SZIG11] introduced Qualitative Numeric Planning (QNP) which is a subset of numeric planning where numeric variables exhibit non-negative domains, and actions increase or decrease the value of numeric variables by indeterminate amounts. A solution for a QNP is a policy which can be used to represent solutions for sets of planning tasks. QNP has been shown to be equivalent to fully observable non-deterministic (FOND) planning [BG20] arising from the non-determinism of action effects, and the connection between FOND and GP has often shown itself when used to synthesise generalised policies [BG18, IM19] . Lin et al. [LCF + 22] studies GP for a more expressive class of numeric planning, by allowing for integer numeric variables and employing linear expressions in conditions and action effects. Their approach involves synthesising programs that allow for branching and looping. Lastly, νASNets [WT24] extends ASNets [TTTX20] in order to learn policies with a neural network architecture for planning.RL is a learning paradigm for decision making that does not have access to a model and instead learns from rewards [SB98] . RL has achieved promising results in games when combined with deep learning [MKS + 15, SHM + 16]. A major difference between RL and L4P is that the former requires reasoning over dense reward functions, whereas the latter requires reasoning over logic [Gef18] .Nevertheless, there has been some preliminary work looking at the intersection of RL and planning.Reward machines [IKVM22] are a logical language used for specifying reward functions for RL problems, inspired by the declarative nature of the planning as modelling paradigm. RL has also been applied directly into planning tasks, as done by [MV21] for temporal planning. Rewards are mostly sparse, with 1 being reward for achieved goals, minor 10 -5 rewards for achieved goal propositions, and no reward otherwise. Gehring et al. [GAC + 22] explored introducing denser reward functions to planning through domain-independent heuristics to allow for RL approaches. Supervised RL has also been used for learning planning policies [SBG23] . Nevertheless, the use cases for RL and planning are generally different, with RL being more suited for control tasks in continuous or dynamic environments such as in robotics, and planning being more suited for combinatorial tasks in discrete or abstract environments such as in logistics. A task from the domain consists of feeding c children with sandwiches in l locations, of which some are allergic to gluten. There are a finite amount of gluten-free (GF) and non-GF ingredients.GF sandwiches can only be made from GF ingredients, whereas non-GF sandwiches can be made with any ingredients. Children allergic to gluten are only allowed to eat GF sandwiches while the remaining children can eat any type of sandwich. Thus, the problem has deadends because resources are finite and can be wasted A task from the domain consists of p passengers with different weights spread across f floors. There is a single elevator with a fixed load capacity that can transport passengers between floors. Furthermore, if the load of the elevator exceeds a secondary threshold, it takes twice as long to move between floors. The goal of the domain is to move the passengers to their target floors. The numeric component of the domain arises from modelling the weight of the passengers and load capacity of the elevator. Training problems have p ∈ [1, 10] passengers while testing problems have p ∈ [1, 485] passengers.A task from the domain consists of r rovers some of which can sample rock and soil data, while others have cameras that can take images of objectives. The goal of each problem is to sample rock and soil data as well as take images of objectives and communicate all g data to the lander. The rovers can move around a map with w waypoints and the rover is only able to communicate data to the lander from a subset of waypoints. Furthermore, rovers have a limited energy supply that is consumed with any action, but they can recharge with solar panels at certain waypoints. Thus, the problem has deadends because rovers have limited energy and could exhaust them in waypoints where they cannot recharge. The numeric component of the domain arises from modelling the energy supply of the rovers. Training problems have g ∈ [1, 10] goals while testing problems have [2, 728] goals problemsA task from the domain consists of s satellites, each carrying a subset of i instruments that can take pictures of space using a subset of m modes. Satellites can rotate to take pictures of d locations in space. Each satellite has a fixed amount of fuel that is consumed when rotating, and a fixed amount of data capacity that is consumed when taking pictures. Thus, the problem has deadends because resources are finite and can be wasted. The goal of a Satellite problem is to take pictures of a set of locations in space with specified modes while adhering to the fuel and data capacity constraints. The numeric component of the domain arises from modelling the fuel and data capacity features. Training problems have s ∈ 2, 10 satellites and testing problems have s ∈ [4, 98] satellites.A task from the domain consists of s spanners scattered along a one-way hallway with l locations, and n nuts at the end of the hallway that have to be fixed. Each spanner can only be used to fix a single nut before it breaks. The goal of the domain is to fix all the nuts. The problem has deadends if not enough spanners are picked up before reaching the end of the hallway. The numeric component of the domain arises from modelling the number of spanners and nuts. Training problems have s ∈ [1, 10] spanners while testing problems have s ∈ [1487] spanners.A task from the domain consists of p packages spread across l locations, with t number of trucks that can transport pick up and transport packages on a map. Each truck has a limited capacity of packages it can carry. The goal of the problem is to transport all the packages to their target locations. We refer to Fig. 8 for distributions of heuristic evaluation time for GNN and CCWL models with L = 1. Times are computed by taking the total search time for each problem and dividing by the number of heuristic evaluations made by the planner. We assume that the heuristic evaluation is the bottleneck of the search which is confirmed with informal profiling experiments.We refer to Tab. 2 for the coverage of models with different L values. Justification: we do not formalise any theoretical results in this paper, but refer to previous work for theoretical results.Guidelines:• The answer NA means that the paper does not include theoretical results.• All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced. • All assumptions should be clearly stated or referenced in the statement of any theorems.• The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition. • Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material. • Theorems and Lemmas that the proof relies upon should be properly referenced.• The answer NA means that the paper does not include experiments.• If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. • If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable. • Depending on the contribution, reproducibility can be accomplished in various ways.For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. • While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. , with an open-source dataset or instructions for how to construct the dataset). (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility.In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.Graphs Optimised fOr Search Evaluation 


Decision: Overall, the technical contributions are solid and the evaluation shows strong results compared to state-of-the-art planners. 

A common theme of the reviews was that the presentation is dense and can be improved. The authors have been receptive to this feedback and appear committed to improving the presentation. 

There were also concerns about the relevance of the problem and the limited related work to compare to. These are definitely valid concerns when we see an uncommon problem being studied. In this case, the ACs assessment is that the problem of "symbolic planning for numeric planning problems" is a well-established area in a less populated corner of the AI world (e.g. the ICAPS community). It could be viewed as a positive step to bring this problem to the NeurIPS community. It is hard to predict the impact, but I can imagine a number of directions other researchers might advance the area.

Reviews: review: paper_summary: paper_summary: The authors introduce a method to generate features for planning tasks that involve numerical variables. These features can then be used with machine learning to learn a heuristic function from a set of training examples. Architectures used for learning include Gaussian processes and graph neural networks. The authors also introduce a method for learning to rank states and do a search based on the ranking instead of the cost-to-go. Results show that, for benchmarks modified to include numerical variables, learning a heuristic function with Gaussian process regression and ranking performs significantly better than planners that do not make use of a numerical representation.
strength_weakness: strength_weakness: The only learning approach that performed better than the baseline planners was the Gaussian process regression with ranking, while Gaussian process regression with cost-to-go performed better than three out of four baseline planners. This makes it appear as if ranking is contributing to the overall success and not the numerical representation and learning.
questions: questions: Do any of these baseline planners make use of ranking?

Is it possible that the main increase in performance is due to ranking and not the numerical representation and learning?

On line 152, V is comprised of G, while, on line 151, it says that G is comprised of V. Do these two Gs represent different concepts?
limitations: limitations: The learning approach relies on supervised learning, which assumes a planner exists that can already solve problems and may limit performance to what the existing planner can solve in a given time limit. On the other hand, research using deep reinforcement learning does not assume the existence of any solver.
paper_summary: paper_summary: The paper tackles numeric planning problems by proposing two heuristics for numeric planning. The first one is based on graph kernels for graphs and addresses both continuous and categorical attributes. The second uses graph neural networks. The authors experimentally show the effectiveness of the two proposed algorithms by showing that they show better coverage compared to domain independent planners for numeric planning.
strength_weakness: strength_weakness: The paper presentation can be improved.  Examples below (no particular order):

1. The abstract states “… in comparison to domain-independent planners” whereas it is more informative to state domain-independent numeric planners. (Other places did indicate numeric planners).
2. The paper can be dense in various places (section 5 for example) 
3. Sometimes the authors miss details that can be helpful in understanding the paper.  For example, what is M(3h||3n) can you explain? Maybe it would be good to give a bit of explanations on each of the configurations.
4. Fig 1, why x, y, z are not shown as blocks, the figure was confusing at first specially given that there are dotted block spaces above y and z with only 2 available blocks whereas the limit is 3 blocks. 
5. In the Table2 caption, mention which ones are your proposed planners and the two variations (rank/cost). 
6. minor typo: “Requires requires” repeated in section 3.1
questions: questions: 1. Can you claim theoretically on admissibility, safe pruning, or tractability of the proposed algorithms? I find it strange that the authors refer to prior work re theory. At least a proof sketch can be given which refers to prior work. 
2. Related to 1, can you prove the complexity on the WL algorithm (right before section 4 starts). 
3. Can you please explain with an example how one should read Table 1. 
4. Which planner is h^LMCUT used in. h^LMCUT is a heuristics, not a planner, right? Same with the other heuristics mentioned in the figure, not sure if it is accurate to refer to them as planners. 
5. In section 8, you mention in the last sentence, one can learn forms of domain knowledge different from heuristic functions, can you give an example.
limitations: limitations: The paper covers that.
paper_summary: paper_summary: The paper proposes a new method for learning a heuristic function to guide search for solving numeric planning problems. In contrast to classical planning, the states in numeric planning may involve numeric variables while the state transitions are defined by mathematical expressions over these kinds of variables. In addition, numeric planning is computationally quite challenging to solve but it may be the right formulation in many interesting real-world applications. The proposed heuristic is learned from training data consisting of example planning instances and their corresponding optimal plans. Features are automatically extracted from a graphical representation of the planning instances and used subsequently by the machine learning models encoding the heuristic functions. The experimental evaluation is carried out on standard benchmarks for numeric planning. The results show clearly that state-of-the-art search algorithms guided by the proposed heuristics improve considerably over their competitors.
strength_weakness: strength_weakness: - In my opinion, the presentation is the main weakness of the paper. While I believe it is a solid contribution for numeric planning, the way it is currently presented makes it hard to understand the details.

- The examples currently supporting sections 3.1 and 3.2 need to be expanded a little more. Right now, it is kind of difficult to follow them.

- Section 4 which describes the graph neural network is too high level and without a supporting example is very hard to understand.

- There is currently a relatively big disconnect between Sections 3, 4 and 5. Namely it takes a while to figure out that the features extracted by the proposed method are subsequently used to learn the heuristics. The current notation doesn't help much either. I also think that adding illustrative examples in Section 5 would clearly improve the quality of the presentation.
questions: questions: - The paper claims that grounding is not required for building the graphical representation of the planning problem. However, the graph shown in Figure seems to be partially grounded. So, how much grounding is needed to build such graphs?
limitations: limitations: The limitations are addressed clearly in the paper.
paper_summary: paper_summary: This paper proposed new learning-based methods for numeric planning. Numeric planning is formalized with the PDDL language. The proposed approaches are based on graph neural networks, and are evaluated in a lot of domains, e.g., blockworld, childsnack.
strength_weakness: strength_weakness: As there is only one closely related work on learning for numeric planning, it is hard to assess whether this is an important research problem.

The abstract has not summarized the novelty of this work, and the relationship between the two proposed approaches.

There are some missing related works about learning heuristics: evolution of Heuristics github.com/FeiLiu36/EoH.
questions: questions: Are the proposed two approaches suitable for different scenarios? Can the authors analyze this issue?
limitations: limitations: This paper has discussed the potential limitations.

Comments: comment: Thanks for the clarifications.
Thank you for answering my questions. I have no further questions.