The Romanian Crosswords Competition Problem is a challenging, NP-hard constraint optimization problem. The task is to fill a $13 \times 13$ grid with criss-crossing words and up to 26 black cells. Words from two lists, the thematic list and the regular list, can be utilized. Each thematic word adds a number of points equal to its length to the score and the objective is to maximize the score. A recent AI approach to the problem constructs seeds, partial solutions with a high density of points in a subarea of the grid. Seeds are then completed to full solutions via a stochastic search. We present an approach to significantly extend the size of a seed which makes completion via stochastic search more successful. Experiments demonstrate an improvement of the completed solutions over published state-of-the-art algorithms.

The performance of a heuristic search depends substantially on the quality of its heuristic functions. A preferred heuristic is accurate, fast to query, and takes little memory. Recent research has explored two routes for building highperformance heuristics. Memory-based heuristics use a precomputed database containing optimal distances between a set of pivot states and all other states in the search graph. More pivot states tend to increase heuristic accuracy while slowing down heuristic computation and increasing memory cost. Alternatively, formula-based heuristics produced via program synthesis capture information about the search graph in short, human-readable formulae. These formulae have negligible memory cost and are fast to query, but generally perform worse than a memory-based heuristic. This paper presents the first empirical comparison between the two approaches for pathfinding. We find that formulabased heuristics can yield better performance than memorybased heuristics with a small number of pivots while being still more compact. With more pivots memory-based heuristics yield better speed-ups but take orders of magnitude more memory. We then investigate the degradation of search performance as the map changes and find that the performance of formula-based heuristics degrades more gracefully than that of memory-based heuristics.

Heuristic search is widely used for game pathfinding with heuristic functions substantially influencing its pathfinding performance. Recent work used program synthesis to automatically generate high-performance formula-based heuristics. Their compactness and human readability offered a promise of explainability. In this paper we present an automated approach to decompose and visualize formula-based heuristics. To illustrate the explanatory power of the visualization we include it in a human-in-the-loop process to iteratively modify heuristic formulae and improve their search performance. The iterative process is meant to encourage human experimentation with the formula-based heuristics thereby increasing the understanding and trust of a game-AI developer or a heuristic search researcher.

The Romanian Crosswords Competition Problem is a challenging, NP-hard constraint optimization problem where state-of-the-art Artificial Intelligence has been lagging behind top human performance. The task is to construct a high-score grid with words from a thematic list, that changes every year, and from a regular list. Each thematic word in the solution gives a number of score points equal to its length. A recent approach to the problem generated grids with scores in the range of top human performance for the first time. However, such scores were obtained for only three years. We present new results with experiments on a larger scale, including an increase from three to eleven years. We produce grids with scores in the top-12 human range in six out of eleven years and discuss steps towards outperforming top humans.

Variants of A* search are widely used for video-game pathfinding with a heuristic function that is typically either a generic formula designed by humans (e.g., the Manhattan distance) or pre-computed for a specific video-game map. Recent work attempted to combine portability of the former and higher performance of the latter by automatically synthesizing arithmetic formulae. Such formulae are simple enough to be human-readable, portable enough to provide guidance on novel maps and yet complex enough to notably outperform a baseline. Each formula-represented heuristic was synthesized for a given map, presumably capturing some features of the map. However, maps can be non-uniform and some regions of one map may have features similar to another map. This work uses a portfolio of synthesized heuristics and selects from it on a per-problem basis. The selection is done automatically by determining the pair of map regions in which the start and the goal states of a given problem instance belong. A pre-computed database gives the highest-performing heuristic from the portfolio for that pair of regions. This heuristic is then used to guide A* to solve the problem instance. Empirical evaluation on maps from video games indicates noticeable speed-up compared to using a single synthesized heuristic for all problem instances on a map.

In constraint optimization many problem instances remain challenging to current technology. We focus on the Romanian Crosswords Competition Problem. It is a challenging, NP-hard constraint optimization problem where state-of-the-art AI has been lagging significantly behind top human performance. We present an approach that first builds a core, a portion of the problem that will have a high contribution to the objective function. A core is grown into a seed, a partial solution with a subset of variables defined and instantiated. Seeds are further extended into full solutions. Our approach takes as input the size of a rectangular core to consider, and the locations of zero or more black cells inside the core. The results advance state-of-the-art substantially. We report a boost in the scores obtained, bringing our top solutions in the vicinity of top human entries.

Heuristic search is a key component of automated planning and pathfinding. It is guided by a heuristic function which estimates remaining solution cost. Traditionally heuristic functions for pathfinding have been human-designed or pre-computed for a specific search graph. The former tend to be compact, human-readable but generic. The latter offer better guidance but require per-graph pre-computation and have a substantial memory cost. We aim to retain compactness and readability of human-designed heuristics and increase their performance. We adopt the recently published approach of representing heuristic functions as algebraic formulae and automatically synthesizing them for video-game maps. Whereas published work merely randomly sampled the space of formula-based heuristic functions, we implement and evaluate a parameterized synthesis algorithm that unifies and generalizes the stochastic sampling, simulated annealing and a basic genetic algorithm. We tune the parameters for better synthesis performance and then, using maps from multiple video games, show that heuristics synthesized for maps from one game still outperform the baseline search (A* with weighted Manhattan distance) on maps from a different game. We analyze a frequently synthesized formula and explain how, despite having a higher error than the Manhattan distance, it takes advantage of the structure in video-game pathfinding problems and speeds up A*.

Crossword puzzles are a challenging game of skill in which humans have been competing for decades. Recently a heuristic-search-based Artificial Intelligence (AI) solver for Romanian crossword puzzles achieved competition-level scores. In this work in progress we tackle procedural content generation of crossword puzzles. Using genetic algorithms we evolve crossword puzzle instances on which the AI solver can achieve a high score. Since the solver takes a substantial time to solve each instance we first train a deep neural network to predict the solution score the solver would achieve. We then run the evolution of crossword puzzles with the network as the fast proxy fitness function. We show that doing so is an effective way of procedurally generating numerous crossword puzzles.

Heuristic search is widely used in games for pathfinding and general planning. High-quality heuristic functions are key to finding a low-cost solution quickly. Commonly used heuristic functions for video-game pathfinding are either manually designed and generic or pre-computed for a specific map. The former fail to take advantage of pathfinding specifics while the latter tend to have a large memory footprint, may require substantial pre-computation and are not portable to other maps or easily presentable to humans. In this work we attempt to combine the best of both approaches by automatically synthesizing well performing pathfinding-specific yet compact and human-readable heuristics. We do so by defining a space of algebraic formulae expressing heuristic functions and then conducting an automated search of the space. To make the synthesis tractable we employ a multi-tier evaluation which allows us to quickly filter out low-quality heuristics while saving time to more thoroughly evaluate better ones. Such triage of candidate heuristics enables us to synthesize compact heuristics that outperform the standard baseline on video-game pathfinding benchmarks. By then adding the synthesized heuristics back to the synthesis space we show that synthesis on new maps can be substantially sped up to merely few minutes per map.

Heuristic search remains a leading approach to difficult combinatorial optimization problems. Search algorithms can utilize pruning based on comparing a target score with an admissible (optimistic) estimate of the best score that can be achieved from a given state. If the former is larger they prune the state. However, when the target score is too high the search can fail by exhausting the space without finding a solution. In this paper we show that such failed searches can still be valuable. Specifically, best partial solutions encountered in such failed searches can often bear a high similarity to the corresponding part of a full high-quality or even optimal solution. Thus, a new search for a full solution, with a lower target score, can start with a best known partial solution, rather than starting from scratch. We demonstrate our ideas in a constraint optimization problem modelled on the Romanian Crosswords Competition, a challenging problem where humans perform much better than computers. Utilizing partial solutions produced by a failed search cuts down the running time of an existing state-of-the-art solver by orders of magnitude on competition-level crossword puzzle instances and allows to solve more instances.

Heuristic search algorithms have long been used in video-game AI for unit navigation and planning. The quality of the solution they produce depends substantially on the quality of the heuristic function they use. Recent work automatically synthesized human-readable heuristic functions for a given pathfinding map. This enables tailoring a heuristic to the map but is expensive since each map requires an independent synthesis run. In this paper we propose and evaluate re-using elements of heuristics synthesized for one map in synthesizing heuristics for another map. We do so by adding parts of a synthesized heuristic back to the grammar that defines the space of heuristic functions for the synthesis.

Heuristic functions guide search algorithms and have a profound impact on their performance. In the context of agent-centered real-time heuristic search (RTHS), a heuristic represents the agent's initial domain knowledge which the agent then updates as it explores the search graph. An ideal initial heuristic should capture some specific domain knowledge to guide the agent effectively yet be general enough for a broad class of problems. It should also be computationally efficient, compact in its representation and human-interpretable. Traditionally initial heuristics in RTHS have been designed by humans (e.g., Manhattan distance). In this paper we explore the alternative of building initial heuristics by machines. To keep them portable and human-interpretable we represent each heuristic as a closed-form algebraic formula. Yet to make the heuristics capture problem specifics and thus be more effective in guiding the search, we automatically build a heuristic tailored to a class of problems. To achieve both objectives, we propose and evaluate automatically searching the space of heuristic functions. As a preliminary demonstration, we find closed-form heuristics that outperform Manhattan distance in grid-based pathfinding. We then develop an insight on how such formula-based heuristics are able to exploit characteristics of certain pathfinding maps.

Procedural content generation (PCG) is an active area of research with the potential to significantly reduce game development costs as well as create game experiences meaningfully personalized to each player. Evolutionary methods are a promising method of generating content procedurally. In particular asynchronous evolution of AI agents in an artificial life (A-life) setting is notably similar to the online evolution of non-playable characters in a video game. In this paper, we are concerned with improving the efficiency of evolution via more effective mate selection. In the spirit of PCG, we genetically encode each agent's preference for mating partners and thereby allowing the mate-selection process to evolve. We evaluate this approach in a simple predator-prey A-life environment and demonstrate that the ability to evolve a per-agent mate-selection preference function indeed significantly increases the extinction time of the population. Additionally, an inspection of the evolved preference function parameters shows that agents evolve to favor mates who have survival traits.

Non-playable characters (NPCs) enhance a player's immersion in a video game. Communications among NPCs create atmosphere and, in some games, are a core element of the gameplay. Yet, the majority of games manually script inter-NPC communications creating only an illusion of such exchanges. Doing so is laborious and results in fixed interactions which may not respond to the player's actions or changes in the environment. In this paper we propose procedural content generation (PCG) for emergent inter-NPC languages. Indeed, recent research demonstrated that deep neural networks can be trained to develop an artificial language to communicate with each other. The work used a fixed, handcrafted network architecture identical for both the sending and receiving agents. We extend the work by using neuroevolution for both the sender and the receiver. In doing so we evolve both the architecture and weights of the agents and show that they successfully develop novel languages to communicate among themselves.

Procedural content generation (PCG) can create novel, player-specific content in video games, including behaviours of AI-controlled non-playable characters (NPC). Here we present our first results on comparing unsupervised and supervised machine learning for procedurally generated NPC behaviours. Using an artificial life environment as a stand-in for a video game, we run artificial evolution and generate AI agents with various behaviours. We then train deep variational autoencoders on commonly evolved behaviour and measure its efficacy in detecting behaviours unseen during training. As a reference, we use an off-the-shelf deep network trained in a supervised manner to detect behaviours both seen and unseen during its training. Preliminary results demonstrate promising performance that holds even when the training set contains a mixture of several types of behaviours without proper labels.

Many existing boundedly-suboptimal heuristic search algorithms are variants of best-first search. Due to memory limitations, these algorithms are unable to solve problems with extremely large search spaces. In this paper, we present a framework that allows best-first search algorithms to solve problems with such large search spaces given a (reasonable) memory bound while also preserving optimality guarantees in tree-structured search spaces. In our framework, a given algorithm is run several times. In each search episode, the algorithm expands up to a user-defined number of states. After each episode, unless the goal has been found, the heuristic values of the generated states are updated using a linear-time algorithm that preserves consistency in tree-structured search spaces. In subsequent search episodes, only the heuristic values of the states generated in the previous episode need to be kept in memory. We present experimental results where we plug A*, GBFS, and wA* into our framework to solve traveling salesman problems and compare them against benchmark linear-memory algorithms like DFBnB and wDFBnB.

Real-time search algorithms are relevant to time-sensitive decision-making domains such as video games and robotics. In such settings, the agent is required to decide on each action under a constant time bound, regardless of the search space size. Despite recent progress, poor-quality solutions can be produced mainly due to state re-visitation. Different techniques have been developed to reduce such a re-visitation with state pruning showing promise. In this paper, we propose a novel pruning approach applicable to the wide class of real-time search algorithms. Given a local search space of arbitrary size, our technique aggressively prunes away all states in its interior, possibly adding new edges to maintain the connectivity of the search space frontier. An experimental evaluation shows that our pruning often improves the performance of a base real-time search algorithm by over an order of magnitude. This allows our implemented system to outperform state-of-the-art real-time search algorithms used in the evaluation.

Heuristic search is a core area of Artificial Intelligence, successfully applied to planning, constraint satisfaction and game playing. In real-time heuristic search autonomous agents interleave planning and plan execution and access environment locally which make them more suitable for Artificial Life style settings. Over the last two decades a large number of real-time heuristic search algorithms have been manually crafted and evaluated. In this paper we break down several published algorithms into building blocks and then let a simulated evolution re-combine the blocks in a performance-based way. Remarkably, even relatively short evolution runs result in algorithms with state-of-the-art performance. These promising preliminary results open exciting possibilities in the field of real-time heuristic search.

Heuristic search is a core area of Artificial Intelligence with applications to planning, scheduling and game playing. Real-time heuristic search applies to search problems where plan execution needs to start before a complete solution can be computed. Since the inception of real-time heuristic search in the early 1990s a great number of algorithms have been proposed and evaluated. In this paper we break them down into building blocks and conduct a search in the space of such building blocks. Even simple tabulated and iterative searches find new real-time heuristic search algorithms outperforming manually crafted contemporary algorithms.

Real-time heuristic search models an autonomous agent solving a search task. The agent operates in a real-time setting by interleaving local planning, learning and move execution. In this paper we propose a simple parametric algorithm that combines weighting with learning from multiple neighbors. Doing so breaks heuristic admissibility but allows the agent to escape heuristic depressions more quickly. We prove completeness of the algorithm and empirically compare it to several competitors more than twenty years apart. In a large-scale evaluation the new algorithm found better solutions than the recent algorithms, despite not learning additional information that they do. Finally, we study robustness of the algorithms to noise in the heuristic function — a desirable property in a physical implementation of real-time heuristic search. The new algorithm outperforms its contemporaries.

Real-time agent-centered heuristic search is a well-studied problem where an agent that can only reason locally about the world must travel to a goal location using bounded computation and memory at each step. Many algorithms have been proposed for this problem and theoretical results have also been derived for the worst-case performance with simple examples demonstrating worst-case performance in practice. Lower bounds, however, have not been widely studied. In this paper we study best-case performance more generally and derive theoretical lower bounds for reaching the goal using LRTA*, a canonical example of a real-time agent-centered heuristic search algorithm. The results show that, given some reasonable restrictions on the state space and the heuristic function, the number of steps an LRTA*-like algorithm requires to reach the goal will grow asymptotically faster than the state space, resulting in ``scrubbing'' where the agent repeatedly visits the same state. We then show that while the asymptotic analysis does not hold for more complex real-time search algorithms, experimental results suggest that it is still descriptive of practical performance.

Storytelling plays an important role in human life, from everyday communication to entertainment. Interactive storytelling (IS) offers its audience an opportunity to actively participate in the story being told, particularly in video games. Managing the narrative experience of the player is a complex process that involves choices, authorial goals and constraints of a given story setting (e.g., a fairy tale). Over the last several decades, a number of experience managers using artificial intelligence (AI) methods such as planning and constraint satisfaction have been developed. In this paper, we extend existing work and propose a new AI experience manager called player-specific automated storytelling (PAST), which uses automated planning to satisfy the story setting and authorial constraints in response to the player's actions. Out of the possible stories algorithmically generated by the planner in response, the one that is expected to suit the player's style best is selected. To do so, we employ automated player modeling. We evaluate PAST within a video-game domain with user studies and discuss the effects of combining planning and player modeling on the player's perception of agency.

Real-time agent-centered heuristic search is a well-studied problem where an agent that can only reason locally about the world must travel to a goal location using bounded computation and memory at each step. Many algorithms have been proposed for this problem, and theoretical results have also been derived for the worst-case performance. Assuming sufficiently poor tie-breaking, among other conditions, we derive theoretical best-case bounds for reaching the goal using LRTA*, a canonical example of a real-time agent-centered heuristic search algorithm. We show that the number of steps required to reach the goal can grow asymptotically faster than the state space, resulting in a "scrubbing" when the agent repeatedly visits the same state. This theoretical result, supported by experimental data, encourages recent work in the field that uses novel tie-breaking schemas and/or perform different types of learning.

Hiding and seeking are cognitive abilities frequently demonstrated by humans in both real life and video games. To determine to which extent these abilities can be replicated with AI, we introduce a specialized version of the Turing test for hiding and seeking. We then develop a computer agent that passes the test by appearing indistinguishable from human behavior to a panel of human judges. We analyze the AI techniques that enable the agent to imitate human hide-and-seek behavior and their relative contribution to the agent's performance.

Automated sports commentary is a form of automated narrative. Sports commentary exists to keep the viewer informed and entertained. One way to entertain the viewer is by telling brief stories relevant to the game in progress. We present a system called the sports commentary recommendation system (SCoReS) that can automatically suggest stories for commentators to tell during games. Through several user studies, we compared commentary using SCoReS to three other types of commentary and show that SCoReS adds significantly to the broadcast across several enjoyment metrics. We also collected interview data from professional sports commentators who positively evaluated a demonstration of the system. We conclude that SCoReS can be a useful broadcast tool, effective at selecting stories that add to the enjoyment and watchability of sports. SCoReS is a step toward automating sports commentary and, thus, automating narrative.

Real-time heuristic search algorithms satisfy a constant bound on the amount of planning per action, independent of the problem size. These algorithms are useful when the amount of time or memory resources are limited, or a rapid response time is required. An example of such a problem is pathfinding in video games where numerous units may be simultaneously required to react promptly to a player's commands. Classic real-time heuristic search algorithms cannot be deployed due to their obvious state revisitation (“scrubbing”). Recent algorithms have improved performance by using a database of precomputed subgoals. However, a common issue is that the precomputation time can be large, and there is no guarantee that the precomputed data adequately cover the search space. In this paper, we present a new approach that guarantees coverage by abstracting the search space, using the same algorithm that performs the real-time search. It reduces the precomputation time via the use of dynamic programming. The new approach eliminates the learning component and the resultant “scrubbing.” Experimental results on maps of tens of millions of grid cells from Counter-Strike: Source and benchmark maps from Dragon Age: Origins show significantly faster execution times and improved optimality results compared to previous real-time algorithms.

Game Artificial Intelligence (Game AI) is a sub-discipline of Artificial Intelligence (AI) and Machine Learning (ML) that explores the ways in which AI and ML can augment player experiences in computer games. Storytelling is an integral part of many modern computer games; within games stories create context, motivate the player, and move the action forward. Interactive Narrative is the use of AI to create and manage stories within games, creating the perception that the player is a character in a dynamically unfolding and responsive story. This paper introduces Game AI and focuses on the open research problems of Interactive Narrative.

Real-time heuristic search algorithms that precompute search space-specific databases have demonstrated exceptional performance in video-game pathfinding. We discuss the first steps towards extending these algorithms to other search spaces that also benefit from the real-time property. We present our initial progress in characterizing the performance of current algorithms based on the features of a search space, and discuss future directions of this research.

Real-time agent-centric algorithms have been used for learning and solving problems since the in-troduction of the LRTA * algorithm in 1990. In this time period, numerous variants have been pro-duced, however, they have generally followed the same approach in varying parameters to learn a heuristic which estimates the remaining cost to arrive at a goal state. Recently, a different ap-proach, RIBS, was suggested which, instead of learning costs to the goal, learns costs from the start state. RIBS can solve some problems faster, but in other problems has poor performance. We present a new algorithm, f-cost Learning Real-Time A * (f-LRTA*), which combines both ap-proaches, simultaneously learning distances from the start and heuristics to the goal. An empiri-cal evaluation demonstrates that f-LRTA * outper-forms both RIBS and LRTA*-style approaches in a range of scenarios. 1

Real-time heuristic search algorithms satisfy a constant bound on the amount of planning per action, independent of problem size. As a result, they scale up well as problems become larger. This property would make them well suited for video games where Artificial Intelligence controlled agents must react quickly to user commands and to other agents' actions. On the downside, real-time search algorithms employ learning methods that frequently lead to poor solution quality and cause the agent to appear irrational by re-visiting the same problem states repeatedly. The situation changed recently with a new algorithm, D LRTA*, which attempted to eliminate learning by automatically selecting subgoals. D LRTA* is well poised for video games, except it has a complex and memory-demanding pre-computation phase during which it builds a database of subgoals. In this paper, we propose a simpler and more memory-efficient way of pre-computing subgoals thereby eliminating the main obstacle to applying state-of-the-art real-time search methods in video games. The new algorithm solves a number of randomly chosen problems off-line, compresses the solutions into a series of subgoals and stores them in a database. When presented with a novel problem on-line, it queries the database for the most similar previously solved case and uses its subgoals to solve the problem. In the domain of pathfinding on four large video game maps, the new algorithm delivers solutions eight times better while using 57 times less memory and requiring 14% less pre-computation time.

Incomplete single-agent search methods are often better suited to real-time pathfinding tasks than complete methods (such as A*). Incomplete methods conduct a limited-depth lookahead search, i.e., expand a part of the space centered on the agent, and heuristically evaluate the distances from the frontier of the expanded space to the goal. Actions selected this way are not necessarily optimal, but it is generally believed that deeper lookahead increases the quality of decisions. However, in two-player games, where similar methods are used, it has long been known that this is not always the case [7, 1]. This phenomenon has been termed minimax pathology. More recently pathological behavior was discovered in single-agent search as well [3]. Some attempts to explain it have been made [5, 6], but the pathology in single-agent search is largely still not understood. In this paper we investigate lookahead pathology in real-time pathfinding on maps from commercial computer games. First, we present an empirical study showing a degree of pathology in over 90% of the problems considered. Second, we give four explanations for such wide-spread pathological behavior.

Real-time heuristic search is a challenging type of agent-centered search because the agent's planning time per action is bounded by a constant independent of problem size. A common problem that imposes such restrictions is pathfinding in modern computer games where a large number of units must plan their paths simultaneously over large maps. Common search algorithms (e.g., A*, IDA*, D*, ARA*, AD*) are inherently not real-time and may lose completeness when a constant bound is imposed on per-action planning time. Real-time search algorithms retain completeness but frequently produce unacceptably suboptimal solutions. In this paper, we extend classic and modern real-time search algorithms with an automated mechanism for dynamic depth and subgoal selection. The new algorithms remain real-time and complete. On large computer game maps, they find paths within 7% of optimal while on average expanding roughly a single state per action. This is nearly a three-fold improvement in suboptimality over the existing state-of-the-art algorithms and, at the same time, a 15-fold improvement in the amount of planning per action.

Real-time heuristic search methods are used by situated agents in applications that require the amount of planning per move to be independent of the problem size. Such agents plan only a few actions at a time in a local search space and avoid getting trapped in local minima by improving their heuristic function over time. We extend a wide class of real-time search algorithms with automatically-built state abstraction and prove completeness and convergence of the resulting family of algorithms. We then analyze the impact of abstraction in an extensive empirical study in real-time pathfinding. Abstraction is found to improve efficiency by providing better trading offs between planning time, learning speed and other negatively correlated performance measures.

Action set selection in Markov Decision Processes (MDPs) is an area of research that has received little attention. On the other hand, the set of actions available to an MDP agent can have a significant impact on the ability of the agent to gain optimal rewards. Last year at GECCO'05, the first automated action set selection tool powered by genetic algorithms was presented. The demonstration of its capabilities, though intriguing, was limited to a single domain. In this paper, we apply the tool to a more challenging problem of oil sand image interpretation. In the new experiments, genetic algorithms evolved a compact high-performance set of image processing operators, decreasing interpretation time by 98% while improving image interpretation accuracy by 55%. These results exceed the original performance and suggest certain cross-domain portability of the approach.

Real-time search methods are suited for tasks in which the agent is interacting with an initially unknown environment in real time. In such simultaneous planning and learning problems, the agent has to select its actions in a limited amount of time, while sensing only a local part of the environment centered at the agent's current location. Real-time heuristic search agents select actions using a limited lookahead search and evaluating the frontier states with a heuristic function. Over repeated experiences, they refine heuristic values of states to avoid infinite loops and to converge to better solutions. The wide spread of such settings in autonomous software and hardware agents has led to an explosion of real-time search algorithms over the last two decades. Not only is a potential user confronted with a hodgepodge of algorithms, but he also faces the choice of control parameters they use. In this paper we address both problems. The first contribution is an introduction of a simple three-parameter framework (named LRTS) which extracts the core ideas behind many existing algorithms. We then prove that LRTA*, epsilon-LRTA*, SLA*, and gamma-Trap algorithms are special cases of our framework. Thus, they are unified and extended with additional features. Second, we prove completeness and convergence of any algorithm covered by the LRTS framework. Third, we prove several upper-bounds relating the control parameters and solution quality. Finally, we analyze the influence of the three control parameters empirically in the realistic scalable domains of real-time navigation on initially unknown maps from a commercial role-playing game as well as routing in ad hoc sensor networks.

Recent adaptive image interpretation systems can reach optimal performance for a given domain via machine learning, without human intervention. The policies are learned over an extensive generic image processing operator library. One of the principal weaknesses of the method lies with the large size of such libraries, which can make the machine learning process intractable. We demonstrate how evolutionary algorithms can be used to reduce the size of the operator library, thereby speeding up learning of the policy while still keeping human experts out of the development loop. Experiments in a challenging domain of forestry image interpretation exhibited a 95% reduction in the average time required to interpret an image, while maintaining the image interpretation accuracy of the full library.

Adaptive image interpretation systems can learn optimal image interpretation policies for a given domain without human intervention. The policies are learned over an extensive generic image processing operator library. One of the principal weaknesses of the method lies with the large size of such libraries which can make machine learning process intractable. In this paper we demonstrate how evolutionary algorithms can be used to reduce the size of operator library thereby speeding up learning of the policy while still keeping human experts out of the development loop. Experiments in a challenging domain of forestry image interpretation exhibited a 93.3% reduction in the execution time, while maintaining the image interpretation accuracy within 5.5% of optimal.