An LP-Based Approach for Goal Recognition as Planning
Lu\'isa R. de A. Santos, Felipe Meneguzzi, Ramon Fraga Pereira, and Andr\'e Grahl Pereira

TL;DR
This paper introduces an LP-based method for goal recognition that explicitly handles partial and noisy observations, improving accuracy and reliability over previous approaches.
Contribution
The paper presents a novel operator-counting framework for goal recognition that effectively manages uncertainty and sensor unreliability in planning tasks.
Findings
Outperforms previous methods in accuracy and agreement ratio
Effectively handles partial and noisy observations
Provides a foundation for future combinatorial optimization research in goal recognition
Abstract
Goal recognition aims to recognize the set of candidate goals that are compatible with the observed behavior of an agent. In this paper, we develop a method based on the operator-counting framework that efficiently computes solutions that satisfy the observations and uses the information generated to solve goal recognition tasks. Our method reasons explicitly about both partial and noisy observations: estimating uncertainty for the former, and satisfying observations given the unreliability of the sensor for the latter. We evaluate our approach empirically over a large data set, analyzing its components on how each can impact the quality of the solutions. In general, our approach is superior to previous methods in terms of agreement ratio, accuracy, and spread. Finally, our approach paves the way for new research on combinatorial optimization to solve goal recognition tasks.
| Optimal | Sub-Optimal | |||||
|---|---|---|---|---|---|---|
| # | % | |||||
| blocks | 10 | 20.33 | 1.25 | 8.0 | 1.42 | 7.61 |
| 30 | 3.08 | 3.97 | 3.83 | 3.58 | ||
| 50 | 4.42 | 2.5 | 5.92 | 3.19 | ||
| 70 | 6.67 | 1.94 | 8.5 | 2.53 | ||
| 100 | 8.83 | 1.83 | 11.83 | 2.25 | ||
| ipc-grid | 10 | 7.5 | 1.63 | 2.71 | 2.06 | 1.58 |
| 30 | 4.0 | 1.21 | 5.56 | 1.4 | ||
| 50 | 6.19 | 1.13 | 8.88 | 1.35 | ||
| 70 | 8.69 | 1.04 | 12.56 | 1.31 | ||
| 100 | 11.88 | 1.0 | 17.25 | 1.5 | ||
| sokoban | 10 | 8.67 | 2.33 | 2.11 | 3.33 | 1.83 |
| 30 | 6.5 | 1.25 | 8.67 | 1.28 | ||
| 50 | 10.33 | 1.22 | 13.75 | 1.33 | ||
| 70 | 14.67 | 1.03 | 19.33 | 1.36 | ||
| 100 | 20.17 | 1.0 | 27.0 | 1.33 | ||
| Other | 10 | 6.89 | 1.85 | 3.01 | 2.46 | 2.32 |
| 30 | 4.69 | 1.61 | 6.37 | 1.45 | ||
| 50 | 7.52 | 1.21 | 10.04 | 1.21 | ||
| 70 | 10.61 | 1.1 | 14.13 | 1.15 | ||
| 100 | 14.51 | 1.06 | 19.55 | 1.08 | ||
| Optimal | Sub-Optimal | ||||||||||||
| # | % | S | L | P | S, L | L, P | S, P | S | L | P | S, L | L, P | S, P |
| blocks | 10 | 0.45 | 0.42 | 0.44 | 0.45 | 0.41 | 0.44 | 0.44 | 0.41 | 0.39 | 0.44 | 0.39 | 0.41 |
| 30 | 0.43 | 0.33 | 0.43 | 0.43 | 0.47 | 0.47 | 0.5 | 0.44 | 0.41 | 0.5 | 0.44 | 0.49 | |
| 50 | 0.55 | 0.46 | 0.44 | 0.55 | 0.58 | 0.59 | 0.5 | 0.37 | 0.51 | 0.5 | 0.57 | 0.55 | |
| 70 | 0.75 | 0.54 | 0.58 | 0.75 | 0.81 | 0.85 | 0.64 | 0.45 | 0.55 | 0.64 | 0.69 | 0.71 | |
| 100 | 0.82 | 0.58 | 0.62 | 0.82 | 0.88 | 0.92 | 0.74 | 0.52 | 0.58 | 0.74 | 0.79 | 0.84 | |
| ipc-grid | 10 | 0.65 | 0.92 | 0.4 | 0.87 | 0.92 | 0.68 | 0.6 | 0.86 | 0.25 | 0.76 | 0.86 | 0.63 |
| 30 | 0.73 | 0.97 | 0.25 | 0.93 | 0.97 | 0.78 | 0.69 | 0.88 | 0.23 | 0.82 | 0.88 | 0.71 | |
| 50 | 0.83 | 0.97 | 0.27 | 0.96 | 0.97 | 0.9 | 0.81 | 0.89 | 0.29 | 0.84 | 0.89 | 0.87 | |
| 70 | 0.9 | 0.97 | 0.3 | 0.97 | 0.97 | 0.95 | 0.87 | 0.91 | 0.08 | 0.89 | 0.91 | 0.89 | |
| 100 | 1.0 | 1.0 | 0.23 | 1.0 | 1.0 | 1.0 | 0.94 | 0.94 | 0.05 | 0.94 | 0.94 | 0.94 | |
| sokoban | 10 | 0.38 | 0.38 | 0.24 | 0.39 | 0.34 | 0.31 | 0.38 | 0.3 | 0.24 | 0.52 | 0.25 | 0.36 |
| 30 | 0.59 | 0.41 | 0.14 | 0.75 | 0.38 | 0.59 | 0.72 | 0.43 | 0.14 | 0.77 | 0.37 | 0.68 | |
| 50 | 0.82 | 0.53 | 0.21 | 0.92 | 0.49 | 0.82 | 0.77 | 0.51 | 0.17 | 0.79 | 0.41 | 0.79 | |
| 70 | 0.93 | 0.73 | 0.21 | 0.99 | 0.62 | 0.93 | 0.85 | 0.58 | 0.17 | 0.8 | 0.51 | 0.85 | |
| 100 | 0.96 | 0.85 | 0.23 | 1.0 | 0.81 | 0.96 | 0.88 | 0.73 | 0.22 | 0.83 | 0.72 | 0.88 | |
| Other | 10 | 0.71 | 0.73 | 0.63 | 0.78 | 0.72 | 0.69 | 0.63 | 0.63 | 0.55 | 0.72 | 0.63 | 0.64 |
| 30 | 0.71 | 0.71 | 0.54 | 0.82 | 0.7 | 0.73 | 0.67 | 0.7 | 0.54 | 0.78 | 0.69 | 0.69 | |
| 50 | 0.81 | 0.78 | 0.58 | 0.88 | 0.77 | 0.82 | 0.8 | 0.78 | 0.61 | 0.87 | 0.78 | 0.83 | |
| 70 | 0.91 | 0.87 | 0.63 | 0.96 | 0.87 | 0.92 | 0.9 | 0.87 | 0.64 | 0.94 | 0.88 | 0.9 | |
| 100 | 0.96 | 0.94 | 0.66 | 0.98 | 0.95 | 0.95 | 0.95 | 0.93 | 0.66 | 0.97 | 0.95 | 0.95 | |
| AVG | 0.79 | 0.77 | 0.54 | 0.86 | 0.78 | 0.8 | 0.76 | 0.74 | 0.52 | 0.82 | 0.75 | 0.78 | |
| Optimal | |||||||||||||||||||
| RG | POM | POM-10% | POM-30% | ||||||||||||||||
| # | % | AGR | ACC | SPR | AGR | ACC | SPR | AGR | ACC | SPR | AGR | ACC | SPR | AGR | ACC | SPR | AGR | ACC | SPR |
| blocks | 10 | 0.44 | 0.86 | 7.53 | 0.44 | 0.86 | 7.56 | 0.47 | 0.92 | 9.83 | 0.06 | 0.17 | 1.44 | 0.13 | 0.47 | 4.06 | 0.38 | 1.0 | 18.14 |
| 30 | 0.46 | 0.78 | 2.5 | 0.44 | 0.86 | 4.67 | 0.45 | 0.92 | 5.56 | 0.21 | 0.39 | 1.17 | 0.3 | 0.75 | 2.94 | 0.24 | 1.0 | 15.25 | |
| 50 | 0.59 | 0.89 | 3.03 | 0.52 | 0.89 | 3.86 | 0.62 | 0.97 | 3.69 | 0.33 | 0.58 | 1.25 | 0.37 | 0.81 | 3.08 | 0.25 | 0.97 | 12.17 | |
| 70 | 0.85 | 0.97 | 1.83 | 0.76 | 0.97 | 2.42 | 0.81 | 1.0 | 2.22 | 0.51 | 0.72 | 1.14 | 0.45 | 0.94 | 2.19 | 0.25 | 1.0 | 9.22 | |
| 100 | 0.92 | 1.0 | 1.67 | 0.92 | 1.0 | 1.67 | 0.9 | 1.0 | 2.08 | 0.59 | 1.0 | 1.67 | 0.55 | 1.0 | 1.92 | 0.31 | 1.0 | 6.42 | |
| ipc-grid | 10 | 0.87 | 0.94 | 2.67 | 0.88 | 0.96 | 2.69 | 0.91 | 1.0 | 3.23 | 0.47 | 0.75 | 2.35 | 0.55 | 0.98 | 4.38 | 0.49 | 1.0 | 6.25 |
| 30 | 0.93 | 0.96 | 1.15 | 0.94 | 0.98 | 1.17 | 0.99 | 1.0 | 1.25 | 0.85 | 0.98 | 1.52 | 0.81 | 1.0 | 1.96 | 0.64 | 1.0 | 3.17 | |
| 50 | 0.96 | 0.98 | 1.08 | 0.96 | 0.98 | 1.08 | 1.0 | 1.0 | 1.13 | 0.86 | 1.0 | 1.44 | 0.86 | 1.0 | 1.56 | 0.77 | 1.0 | 2.15 | |
| 70 | 0.97 | 0.98 | 1.06 | 0.97 | 0.98 | 1.06 | 1.0 | 1.0 | 1.04 | 0.97 | 0.98 | 1.02 | 0.97 | 0.98 | 1.02 | 0.93 | 0.98 | 1.15 | |
| 100 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | |
| sokoban | 10 | 0.39 | 0.53 | 2.08 | 0.38 | 0.61 | 2.94 | 0.4 | 0.81 | 4.86 | 0.28 | 0.53 | 2.14 | 0.32 | 0.89 | 4.39 | 0.26 | 0.97 | 7.0 |
| 30 | 0.75 | 0.81 | 1.25 | 0.64 | 0.92 | 2.06 | 0.56 | 0.86 | 2.53 | 0.57 | 0.69 | 1.22 | 0.48 | 0.75 | 1.89 | 0.23 | 0.94 | 5.17 | |
| 50 | 0.92 | 1.0 | 1.19 | 0.83 | 1.0 | 1.39 | 0.61 | 0.86 | 2.14 | 0.61 | 0.69 | 1.42 | 0.55 | 0.81 | 2.14 | 0.28 | 1.0 | 5.08 | |
| 70 | 0.99 | 1.0 | 1.0 | 0.94 | 1.0 | 1.08 | 0.64 | 0.83 | 1.53 | 0.85 | 0.92 | 1.17 | 0.81 | 0.94 | 1.39 | 0.36 | 1.0 | 3.64 | |
| 100 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 0.67 | 0.75 | 1.17 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 0.42 | 1.0 | 2.75 | |
| Other | 10 | 0.78 | 0.89 | 3.27 | 0.78 | 0.9 | 3.38 | 0.74 | 0.93 | 3.88 | 0.4 | 0.47 | 1.67 | 0.53 | 0.77 | 3.68 | 0.46 | 0.99 | 6.43 |
| 30 | 0.81 | 0.91 | 1.77 | 0.79 | 0.94 | 2.04 | 0.69 | 0.95 | 2.67 | 0.63 | 0.73 | 1.38 | 0.57 | 0.89 | 2.54 | 0.3 | 0.99 | 5.59 | |
| 50 | 0.88 | 0.95 | 1.32 | 0.84 | 0.97 | 1.63 | 0.77 | 0.95 | 1.86 | 0.77 | 0.85 | 1.16 | 0.7 | 0.93 | 1.84 | 0.29 | 0.98 | 4.8 | |
| 70 | 0.95 | 0.99 | 1.15 | 0.94 | 0.99 | 1.23 | 0.82 | 0.96 | 1.49 | 0.88 | 0.94 | 1.13 | 0.78 | 0.99 | 1.55 | 0.35 | 1.0 | 3.92 | |
| 100 | 0.98 | 1.0 | 1.06 | 0.98 | 1.0 | 1.06 | 0.9 | 0.97 | 1.24 | 0.95 | 1.0 | 1.08 | 0.87 | 1.0 | 1.29 | 0.45 | 1.0 | 3.01 | |
| AVG | 0.86 | 0.94 | 1.79 | 0.84 | 0.95 | 1.99 | 0.77 | 0.95 | 2.39 | 0.7 | 0.79 | 1.31 | 0.67 | 0.91 | 2.22 | 0.39 | 0.99 | 5.2 | |
| Optimal | Sub-Optimal | ||||||||
| # | % | RG | POM | RG | POM | ||||
| blocks | 10 | 0.32 | 0.32 | 0.31 | 0.06 | 0.38 | 0.38 | 0.42 | 0.05 |
| 30 | 0.37 | 0.37 | 0.39 | 0.13 | 0.36 | 0.37 | 0.49 | 0.22 | |
| 50 | 0.64 | 0.64 | 0.6 | 0.37 | 0.53 | 0.53 | 0.55 | 0.28 | |
| 70 | 0.79 | 0.81 | 0.77 | 0.47 | 0.67 | 0.67 | 0.63 | 0.38 | |
| 100 | 0.88 | 0.88 | 0.89 | 0.57 | 0.78 | 0.82 | 0.74 | 0.51 | |
| ipc-grid | 10 | 0.57 | 0.57 | 0.16 | 0.38 | 0.62 | 0.62 | 0.12 | 0.54 |
| 30 | 0.85 | 0.85 | 0.28 | 0.71 | 0.68 | 0.68 | 0.08 | 0.72 | |
| 50 | 0.89 | 0.89 | 0.07 | 0.81 | 0.84 | 0.84 | 0.04 | 0.85 | |
| 70 | 0.95 | 0.95 | 0.15 | 0.93 | 0.89 | 0.89 | 0.02 | 0.9 | |
| 100 | 1.0 | 1.0 | 0.08 | 0.99 | 0.94 | 0.94 | 0.04 | 0.92 | |
| sokoban | 10 | 0.27 | 0.27 | 0.1 | 0.24 | 0.31 | 0.32 | 0.13 | 0.25 |
| 30 | 0.56 | 0.7 | 0.2 | 0.34 | 0.48 | 0.56 | 0.12 | 0.29 | |
| 50 | 0.61 | 0.82 | 0.2 | 0.57 | 0.5 | 0.73 | 0.01 | 0.46 | |
| 70 | 0.6 | 0.97 | 0.08 | 0.84 | 0.54 | 0.8 | 0.06 | 0.58 | |
| 100 | 0.66 | 1.0 | 0.04 | 0.96 | 0.35 | 0.85 | 0.04 | 0.77 | |
| Other | 10 | 0.44 | 0.44 | 0.27 | 0.27 | 0.42 | 0.42 | 0.31 | 0.31 |
| 30 | 0.57 | 0.58 | 0.32 | 0.51 | 0.6 | 0.63 | 0.36 | 0.53 | |
| 50 | 0.77 | 0.78 | 0.37 | 0.65 | 0.78 | 0.78 | 0.41 | 0.71 | |
| 70 | 0.88 | 0.89 | 0.46 | 0.8 | 0.86 | 0.88 | 0.41 | 0.79 | |
| 100 | 0.95 | 0.96 | 0.45 | 0.9 | 0.91 | 0.96 | 0.4 | 0.87 | |
| AVG | 0.71 | 0.73 | 0.35 | 0.61 | 0.69 | 0.72 | 0.34 | 0.61 | |
| ACC | 0.89 | 0.9 | 0.5 | 0.73 | 0.87 | 0.89 | 0.48 | 0.76 | |
| SPR | 1.91 | 1.78 | 1.38 | 1.3 | 1.93 | 1.72 | 1.34 | 1.31 | |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
Taxonomy
TopicsConstraint Satisfaction and Optimization · Logic, Reasoning, and Knowledge · Semantic Web and Ontologies
An LP-Based Approach for Goal Recognition as Planning
Luísa R. de A. Santos1, Felipe Meneguzzi2, Ramon Fraga Pereira3, André G. Pereira1
Abstract
Goal recognition aims to recognize the set of candidate goals that are compatible with the observed behavior of an agent. In this paper, we develop a method based on the operator-counting framework that efficiently computes solutions that satisfy the observations and uses the information generated to solve goal recognition tasks. Our method reasons explicitly about both partial and noisy observations: estimating uncertainty for the former, and satisfying observations given the unreliability of the sensor for the latter. We evaluate our approach empirically over a large data set, analyzing its components on how each can impact the quality of the solutions. In general, our approach is superior to previous methods in terms of agreement ratio, accuracy, and spread. Finally, our approach paves the way for new research on combinatorial optimization to solve goal recognition tasks.
Introduction
Goal recognition as planning consists of inferring the set of compatible goals from a set of goal candidates, given a planning task without a goal, and a sequence of observations. A solution for a goal recognition task is a subset of goal candidates that are compatible with the sequence of observations. A plan for the planning task with the reference goal, part of the set of goal candidates, generates the sequence of observations. This sequence may be partial, containing any number of observations from the plan. Existing methods on goal recognition try to cope with three main classes of observation sequences: optimal (Ramírez and Geffner 2009), sub-optimal (Ramírez and Geffner 2010), and noisy (Sohrabi, Riabov, and Udrea 2016). Since approaches to goal recognition as planning often employ standard planning technology to solve goal recognition tasks, many of them can benefit from improvements in the underlying planning technology (Ramírez and Geffner 2009; E-Martín, R.-Moreno, and Smith 2015; Pereira, Oren, and Meneguzzi 2017; Harman and Simoens 2020).color=red!60,linecolor=red!100,,size=]Changed here, makes the text less staccato
Recent developments in planning include heuristics based on the operator-counting framework, which combines the information of admissible heuristic functions through an integer program (IP) (Pommerening et al. 2014). These heuristics provide constraints that must be satisfied by every plan of the planning task. In general, the objective value of the linear program (LP), a linear relaxation of the integer program, is used as heuristic function to guide the search. A major advantage of this framework is that it enables to reason and to manipulate the information of the heuristics directly.
We develop an LP-based approach to solve goal recognition tasks, including five main contributions. First, we modify the operator-counting framework to efficiently compute solutions that satisfy the counts of observations of a goal recognition task. We also use this framework to estimate the cost of an optimal plan for each goal candidate in the task. Then, we use the information generated to solve the goal recognition task. Second, we show how to contrast the objective value of the modified linear program and the length of the sequence of observations to estimate the uncertainty of the decision of our approach which we use to improve our solution. Third, we develop an approach to explicitly address noisy observations. Given the unreliability of the sensor of observations, we create an integer program that aims to automatically ignore noisy observations when computing solutions. Fourth, we show that higher heuristic values from lower bound heuristics for the reference goal predict the quality of our solution. Finally, we modify the previous benchmarks to compare goal recognition methods by agreement ratio, showing that ours overcomes the state of the art.
Planning Task and Operator-Counting Framework
An SAS+ planning task is a tuple , where is a set of variables, is a set of operators, is an initial state, is a goal condition, and a cost function. Each variable has a finite domain . A state is a complete assignment, a partial state is a partial assignment of the variables over , is the set of variables in a (partial) state , and is the value of variable in a (partial) state . The initial state is a state, and the goal condition is a partial state. A state is consistent with a (partial) state if for all . Each operator is pair of partial states and an operator is applicable to a state if is consistent with . Applying to generates a new state such that for and for the remaining variables . Function assigns a non-negative cost to each operator – in this paper all operators have unit cost. An -plan is a sequence of operators such that there exists a sequence of states where is applicable to and produces state , and is consistent with . The cost of a -plan is defined as . An -plan or a plan is a solution to a planning task and is optimal if its cost is minimal. Figure 1 illustrates our running example where the agent performs cardinal movements and starts at . An optimal plan that reaches for this task is .
Definition 1** **(Operator-Counting Constraint).
Let be a planning task with operators , and let be one of its states. Let be a set of real-valued and integer variables, including an operator-counting non-negative integer variable for each operator . A set of linear inequalities over is an operator-counting constraint for if for every valid -plan , there exists a solution with for all – where is the number of occurrences of operator in the -plan .
In the example is an operator-counting constraint (and a landmark constraint) for goal because the agent must use one of these operators to reach .
Definition 2** **(Operator-Counting IP/LP Heuristic).
The operator-counting integer program for a set of operator-counting constraints for state is
[TABLE]
The IP heuristic is the objective value of , and the LP heuristic is the objective value of its linear relaxation. If the IP or LP is infeasible, the heuristic estimate is .
Goal Recognition as Planning
We formally define the task of goal recognition as planing as a tuple , where is a planning task without a goal condition, is a set of goal candidates, and is a sequence of observations. Observation corresponds to operator . For readability, we abuse notation and equate operators to observations throughout the paper when convenient.
Definition 3** **(Observation Compliance).
Let be a plan for a planning task and a sequence of observations. Plan complies with if a monotonic function exists that maps all operator indexes in to indexes in , such that .
We define three classes of sequences of observations: optimal and sub-optimal (Definition 4) observations, and noisy optimal/sub-optimal observations (Definition 5).
Definition 4** **(Sequence of Observations).
Let be a plan for the planning task . Then, a sequence of observations is a sequence of operators extracted from the plan maintaining their relative order. The sequence may be partial, containing any number of operators from the plan . An optimal sequence of observations is extracted from an optimal plan and a sub-optimal sequence of observations is extracted from a sub-optimal plan. An optimal/sub-optimal observation is part of an optimal/sub-optimal sequence of observations.
Definition 5** **(Noisy Observations).
A noisy sequence of observations is a sequence observations extracted from that is augmented with at least one observation , which is inserted in any position of the extracted sequence.
We extend the standard definition from Ramírez and Geffner (2009) of an exact solution set for a goal recognition task to also consider sub-optimal observation sequences (Definition 6) and call it reference solution set. We define the reference solution set as a subset of the goal candidates such that there exists a complying plan as sub-optimal as or less than the plan that generated the observations for the reference goal.
Definition 6** **(Reference Solution Set).
*color=violet!20,linecolor=violet!100,,size=]changed here
Let be a goal recognition task and a planning task with the goal condition (the reference goal). Let be an optimal plan for , and let be a plan for from which is extracted. Let be the cost of an optimal plan for restricted to the set of plans that comply with , and be the cost for an optimal plan for , both with . and are equal to if no plan exists. Then, the color=violet!20,linecolor=violet!100,,size=]changed herereference solution set for the goal recognition task is*
[TABLE]
In Figure 1 we show a goal recognition task with goal candidates . Suppose that is the reference goal. Then, is an optimal sequence of observations because it is extracted from the optimal plan , and are sub-optimal sequences of observations because they are extracted from the sub-optimal plan , and is a sub-optimal and noisy sequence of observations because it was extracted from and the observation of was added. The color=violet!20,linecolor=violet!100,,size=]changed herereference solution set for goal recognition tasks with noisy observations is computed ignoring noisy observations in the sequence of observations. The color=violet!20,linecolor=violet!100,,size=]changed herereference solution set for any of these observation sequences with respective plans is . For example, , , and thus .
LP-Based Goal Recognition
We now develop an LP-based goal recognition method that expands the operator-counting framework with observation-counting constraints.
Observation-Counting Constraints
We now introduce an IP/LP heuristic which expands the operator-counting framework with a set of observation-counting constraints. Definition 7 formally introduces the set of observation-counting constraints and the integer program that ensures that the solution computed satisfies all observation counts.
Definition 7** **(Satisfying IP/LP heuristic).
Let be a set of non-negative integer variables with a variable for each operator . Let be the number of occurrences of operator in . Then, the satisfying integer program for a set of operator-counting constraints , a set of observation-counting constraints, and sequence of observations for state is
[TABLE]
The satisfying IP heuristic is the objective value of , and the satisfying LP heuristic is the objective value of its linear relaxation. If the IP or LP is infeasible, the heuristic estimate is .
In the integer program, the set of constrains (1) limits the value of each by the number of occurrences of the operator in . Next, the set of constraints (2) binds the two sets and of variables. This set of constraints guarantees that acts as an upper bound for . Thus, to increase the count of the integer program must first increase the count of which is minimized in the objective function and restricted by the set of operator-counting constraints . Finally, constraint (3) ensures all observations are satisfied, since each is limited by the number of times appears in . While simpler models can compute the same objective value, we show how explicit information about the observations enables us to reason about noisy observations.
color=red!60,linecolor=red!100,,size=]The note note note thing here is boring, I will leave it here, but we should edit this for the final version. Note that for all states of the planning task. First note that is admissible (Pommerening et al. 2014) and that a complying plan can always satisfy . Note that the only difference between and are the observation-counting constraints. These constraints only restrict the set of plans that can satisfy to the set of plans that satisfy all observations. If is an optimal -plan that complies with (), then there is a solution for where .
We use the heuristic to estimate a lower bound on the cost of an optimal plan that satisfies all observations in for each goal candidate in . However, this information is insufficient to estimate the solution set because the goal candidate with the least -value is not necessarily the most likely one. Consider a goal recognition task with two goal candidates. The first goal candidate has an optimal cost plan that can be extended with one operator to satisfy the single observation in . The second goal candidate has an optimal cost plan that complies with the observation in . In this example the plan for the first goal costs less than the plan for the second goal. In this example only the first goal candidate would be included in the solution set. However, we argue that the second goal is more likely to be part of the color=violet!20,linecolor=violet!100,,size=]changed herereference solution set since it is the only goal candidate with a complying optimal plan. Therefore, we normalize the values of with estimates of the costs of the original optimal solution – without satisfying the observations. Like previous methods, the idea is to select the goals that have plans that satisfy all observations with the least additional cost. For this, we use the value of the original operator-counting heuristic . Having and for each goal candidate we can compute the following solution set:
[TABLE]
[TABLE]
Equation 4 computes the minimum difference between the lower bound cost of an optimal plan that satisfies observations and the lower bound cost of an optimal plan (ignoring observations). The value only considers goal candidates with bounded estimates for plans that satisfy observations (). Equation 5 computes the solution set by selecting all goals with a difference between the estimates equal to . Note that is an approximated solution and not equal to the color=violet!20,linecolor=violet!100,,size=]changed herereference solution set . In our running example, consider a goal recognition task with . Then cost of and are and , and costs of and are and . Thus, equals to , and we return .
Addressing Noisy Observations
In most realistic settings, unreliable sensors may add noisy observations to the sequence of observations. Consider a goal recognition task in our running example with . Then, and . In this situation we would have , and . However, the observation is unlikely to be part of any plan that generates the sequence of observations for either of the two goals. Evaluating precisely which observations are unlikely to be part of plans for a goal is a hard problem that requires solving a planning task multiple times, or, as Sohrabi, Riabov, and Udrea (2016) do, generating multiple plans. In spite of that, we can the estimate the solution for this problem in polynomial time using the linear relaxation of an integer program. Specifically, we modify the integer program to try to automatically identify noisy observations given the unreliability of the sensors. The main modification is to replace constraint (3) in the integer program with constraint (6). We call the solution set using this heuristic \Gamma^{\text{\epsilon}}.
[TABLE]
where is the unreliability rating of the sensor that represents the expected percentage of mistaken observations. This new constraint requires that at least observations be satisfied by the solution found. color=red!60,linecolor=red!100,,size=]A note here. It should be either “This new constraint requires that at least observations be satisfied by the solution found. ” or “This new constraint requires at least observations to be satisfied by the solution found. ” If , all observations must be satisfied. If , some observations can be automatically ignored in order to minimize the objective value of for each goal candidate. Consider our running example with and . Then, the integer program has to satisfy observations. Then, and . In this situation we would have , and \Gamma^{\text{\epsilon}}=\{s^{*}_{1}\}.
Measuring Uncertainty
The main idea of this approach is that if has a lower percentage of observations we should be more careful in our decision. However, if the percentage is higher we can be more confident. A goal recognition task does not provide the percentage of observations in . However, we can estimate this information using our heuristic . Since provides a lower bound on the cost of a plan that satisfies the observations the difference (if any) between and must be due to missing observations. Note that under observability , and with lower degrees of observability may select operators that are not in to satisfy the operator-counting constraints . Thus, in lower degrees of observability the difference between and is likely to increase. This information allows us to estimate the degree of observability as follows:
[TABLE]
where is the uncertainty ratio. This value is computed by first selecting the goal candidates using Equation 5, and then selecting the goal candidate in with maximum . Having we can compute the new solution set that considers uncertainty:
[TABLE]
Consider our running example with . Then, and . In this situation we would have , and . However, we would argue that having only one observation is insufficient to make a precise decision. Using uncertainty we would have and .
Experimental Results
We conducted extensive empirical experiments to show the effectiveness of our methods in three ways. First, we evaluate how each source of operator-counting constraints impacts the quality of our solutions. Second, we assess the performance of our methods that explicitly address low observability and noise. Finally, we compare our approach with previous ones. We ran all experiments with Ubuntu running over an Intel Core i7 930 CPU ( GHz) with a memory limit of GB, all methods solved each goal recognition task under a time limit of five seconds. Our implementation uses Fast Downward version 19.06 (Helmert 2006), a Python prepossessing layer, and the CPLEX 12.10 LP solver.111Source-code and benchmark are available at: https://bit.ly/lp-goal-recognition
Benchmark Domains and Data sets
We create a new benchmark by adapting the one introduced by Pereira, Oren, and Meneguzzi (2017) to use the agreement ratio evaluation metric from Ramírez and Geffner (2009). For each domain we create three planning tasks each (except for IPC-Grid, in which we create four) with four reference goals each that we use to compute the plans from which we extract the sequence of observations. We compute optimal and sub-optimal plans for each pair of planning task and reference goal creating two data sets. To compute sub-optimal plans we use weighted with (Pohl 1970).
Following previous work, we experiment with five different levels of observability: 10%, 30%, 50%, 70% and 100%. We only generate one sequence of observations for 100% of observability, and three different random observation sequences from the same plan for other percentages, generating 208 goal recognition tasks in total for IPC-Grid and 156 for each of the other domains in each data set (optimal and sub-optimal). For each data set we also create a corresponding noisy data set by adding randomly generated observations in each sequence of observations— i.e. the fault rate of the sensor is 20%. Three different noisy sequences are generated for each original sequence. For each goal recognition task we add at least five randomly generated candidate goal conditions. In total we have goal recognition tasks divided in four data sets. In order to create the new benchmarks, we compute the color=violet!20,linecolor=violet!100,,size=]changed herereference solution set for each goal recognition task for optimal and sub-optimal data sets. Thus, for each goal candidate of each base task we solve a planning task twice.
We evaluate the methods using three metrics: agreement ratio, accuracy and spread. The agreement ratio is defined as the intersection over union of the color=violet!20,linecolor=violet!100,,size=]changed herereference solution set against the solution provided by the method. The accuracy is if the solution set chosen by the evaluated method contains the reference goal and [math] otherwise. Note that we use a slight modified of accuracy in other to compare to (Pereira, Oren, and Meneguzzi 2017). The spread is the size of the solution set chosen by the evaluated method. Table 1 summarizes the information about the data sets. The domains we use are Blocks World, Depots, Driverlog, DWR, IPC Grid, Ferry, Logistics, Miconic, Rovers, Satellite, Sokoban and Zeno Travel. Due to space restrictions, we summarize results for all domains as averages in Other, except for Blocks World, IPC Grid and Sokoban. For each domain row, is the average number of candidate goals. Columns and show the average sizes of the observations and the color=violet!20,linecolor=violet!100,,size=]changed herereference solution set, respectively. The average size of the plan with 100% of observability indicates the size of the plan computed for the reference goal. As expected, the average sizes and are larger for the sub-optimal data set than for the optimal data set.
Evaluating the Constraints
We measure how the sources of operator-counting constraints impact the quality of the solutions, and if more informed heuristics improve the solution of goal recognition tasks. The constraint sources are: state equation (Bonet 2013), landmarks (Bonet and van den Briel 2014), and the post-hoc optimization (Pommerening, Röger, and Helmert 2013).
Figure 2 shows the value of for each source of constraints. Each point is the -value for a goal recognition task with its reference goal in the optimal data set. There are four figures in each group, one for each degree of observability (10%, 30%, 50% and 70%). They show that, in general, and are more informed than , and that and are comparable. Also, as expected, the difference in the values decreases as observability increases. On average and are more informed than on 61.49% and 72.58% of the goal recognition tasks respectively. is more informed than on 31.19% of the tasks, and is more informed than on 42.96% of the tasks.
Table 2 shows the results of the agreement ratio for each source of operator-counting constraints solving goal recognition tasks in the optimal and sub-optimal data sets. The solution set is computed using , and when two or more sources of operator-counting constraints are used, they are all combined into a single integer program . The first group of columns shows the results for each source of constraints used individually, and the second combined in pairs. When the constraints are used individually and achieve the best results for different domains. For example, is the best for Blocks while is the best for IPC-Grid. When pairs of constraints are combined the results improve and again the pair formed by and provides best results. Results using all constraints are similar to using the pair and (as presented next in Table 3). There are two key conclusions of these results. First, the agreement increases with the degree of observability, but even with 100% it is still hard to obtain perfect agreement. Second, the agreement degrades in the sub-optimal data set, but our method maintains an average of .
Figure 3 shows the relation between -value and agreement for goal recognition tasks. Again, there are four Figures in each group, one for each degree of observability. Each point on the -axis shows the difference between the agreement ratio for the solution generated using for each goal recognition task in the optimal data set (-1 to 1). The -axis shows the difference of -values for the same task with its goal reference (-10 to 10). For example, in group vs. the points are clustered on right upper quadrant which shows that in general when AGR1 is higher than AGR2, is also higher than . We see the same trend in group vs. . We highlight a different situation in the group vs. since the points are clustered on the upper right and bottom left quadrants. This shows that higher -values tend to produce higher agreement ratio. Thus, these results provide evidence that more informed heuristics improve the solution of goal recognition tasks.
Evaluating Previous Methods and Uncertainty
Table 3 compares our and methods to two other polynomial time approaches from the literature, reporting agreement ratio, accuracy and spread for optimal and sub-optimal data sets with degrees of observability with 10%, 30%, 50%, 70% and 100% of the observations. Our methods use the three sources of constraints , , and . RG (Ramírez and Geffner 2009) computes a relaxed plan efficiently and returns as the goal set the goal candidates with relaxed plans that satisfy the largest number of observations. POM (Pereira, Oren, and Meneguzzi 2017) performs the recognition task by computing landmarks and returns as the goal set the goal candidates that have the highest number of landmarks satisfied by the observation. We use their goal completion heuristic for its better results. We report the results of POM-10% and POM-30%, which return larger goal sets, including those within a 10% and 30% threshold of the goals with the highest number of landmarks satisfied.
On both data sets our approach has the highest agreement ratio on average and is the best in almost all domains and degrees of observability. An exception is the domain IPC-Grid where RG has in general better results. We note that in hard domains like Sokoban, our methods have much higher agreements ratios than other approaches. For example, on the optimal data set for this domain, has average agreement ratio of 0.81 while the next best approach RG has average agreement ratio of 0.76.
Table 3 also shows accuracy and spread for all methods. It shows that many methods can achieve high accuracy while yielding a high spread, thus degrading the agreement ratio. For example, while POM-30% has a perfect accuracy on almost all domains on the sub-optimal data set, its spread is the highest. The Blocks domain has on average 20.33 goal candidates, and for POM-30% to achieve a competitive accuracy on 10% of observability it returns almost all goals with a spread of 17.53. By contrast, our method increases the accuracy without increasing the spread excessively by measuring uncertainty. This happens especially in the low observability scenarios it was designed to address. Take for example the results of Sokoban on sub-optimal data set, in which shows a substantially higher accuracy without a corresponding increase in spread, unlike other methods. Our idea to measure the uncertainty is general since it does not require linear programming heuristics and could be applied to RG and POM to improve their results.
Noisy Observations
Table 4 compares agreement ratio of our and \Gamma^{\text{\epsilon}} methods with RG and POM on noisy data sets. The last two rows show the average accuracy and spread over all domains. Again, our methods use the three sources of constraints , , and . Here most methods degrade with noisy observations, reducing their agreement ratio. \Gamma^{\text{\epsilon}}, which addresses noisy observations explicitly, has on average the highest agreement ratio and accuracy on both data sets. For example, on the Sokoban domain some noisy observations might be impossible to satisfy because they lead to unsolvable states on all plans. In this situation \Gamma^{\text{\epsilon}} substantially improves the agreement ratio.
Discussion
In this paper we developed a novel class of goal recognition methods based on linear programming models. These methods include an uncertainty measurement that increases the accuracy on low observability scenarios, as well as an efficient and automatic method to address noisy observations. We adapt and provide a benchmark to compare methods using the agreement ratio, which allows us to evaluate our methods in a number of different ways. First, we evaluate how different sources of constraints impact the quality of our solutions. Second, we assess how our additional constraints and uncertainty measurement affect performance under noise and low observability, respectively. Third, we compare our methods to previous ones, showing that ours are, in general, superior.
Acknowledgments
Felipe Meneguzzi acknowledges support from CNPq with projects 407058/2018-4 (Universal) and 302773/2019-3 (PQ Fellowship). André G. Pereira acknowledges support from FAPERGS with project 17/2551-0000867-7. This study was financed in part by the Coordenação de Aperfeiçoamento de Pessoal de Nível Superior - Brasil (CAPES) - Finance Code 001. Ramon Fraga Pereira acknowledges support from the ERC Advanced Grant WhiteMech (No. 834228) and the EU ICT-48 2020 project TAILOR (No. 952215).
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1Bonet (2013) Bonet, B. 2013. An Admissible Heuristic for SAS + Planning Obtained from the State Equation. In International Joint Conference on Artificial Intelligence , 2268–2274.
- 2Bonet and van den Briel (2014) Bonet, B.; and van den Briel, M. 2014. Flow-based heuristics for optimal planning: Landmarks and merges. In International Conference on Automated Planning and Scheduling , 47–55.
- 3E-Martín, R.-Moreno, and Smith (2015) E-Martín, Y.; R.-Moreno, M. D.; and Smith, D. E. 2015. A Fast Goal Recognition Technique Based on Interaction Estimates. In International Joint Conference on Artificial Intelligence .
- 4Harman and Simoens (2020) Harman, H.; and Simoens, P. 2020. Action Graphs for Goal Recognition Problems with Inaccurate Initial States. In AAAI Conference on Artificial Intelligence .
- 5Helmert (2006) Helmert, M. 2006. The Fast Downward planning system. Journal of Artificial Intelligence Research 26: 191–246.
- 6Pereira, Oren, and Meneguzzi (2017) Pereira, R. F.; Oren, N.; and Meneguzzi, F. 2017. Landmark-based heuristics for goal recognition. In AAAI Conference on Artificial Intelligence .
- 7Pohl (1970) Pohl, I. 1970. Heuristic search viewed as path finding in a graph. Artificial intelligence 1(3-4): 193–204.
- 8Pommerening, Röger, and Helmert (2013) Pommerening, F.; Röger, G.; and Helmert, M. 2013. Getting the most out of pattern databases for classical planning. In International Joint Conference on Artificial Intelligence , 2357–2364.
