Pattern knowledge and search:The SUPREM architecture

Hans Berliner, Carl Ebeling
1989 Artificial Intelligence  
We present a new problem solving architecture based upon extremely fast search and pattern recognition. This architecture, which we have named SUPREM, has been implemented in the chess machine/program Hitech, and has proven to be very successful. We describe the implementation in Hitech and the reasons for its success, and compare the SUPREM architecture to other well known problem solving architectures. Certain interesting phenomena have become exposed as the result of our work with Hitech.
more » ... most important of these is that: "The further a process can look ahead, the less detailed knowledge it needs." We have also found that patterns can be formulated for quite complex problems in relatively small pattern recognizers, by eschewing generality and concentrating on likely patterns and their redundancies. Problems in decision making are difficult because, in any problem worthy of being deemed a problem, there are either a large number of alternatives, or the implications of any number of alternatives can create trees of implications that are huge. Thus there could be many millions of leaf nodes in a search, all of which must be evaluated with respect to many factors. An immediate quandary presents itself: The more knowledge one applies to each leaf node, the slower the process goes. The slower the process, the fewer the alternatives that can be investigated. In the past, this has led to a schism between animate and machine searchers: the former opting for the few nodes, deep understanding approach, and the latter for many nodes but shallow understanding. Humans solve problems in a "knowledge-intensive" mode, applying small amounts of search when necessary. The human strategy is flexible and avoids the need to encode all knowledge. Many successful AI systems mimic the human style and rule-based systems offer the prime example. Competitive gaming systems typically employ the opposite scheme, relying primarily on search. While each approach has its advantages, their strategic asymmetry has drawbacks, too: Relying primarily on either one eventually makes continued performance gains difficult. Figure 1 illustrates the tradeoff 2 . For a given task, the constant-performance curves exhibit an approximately hyperbolic shape. Consider a system positioned at point A: Making it "smarter" can increase overall performance to point B while slightly reducing search speed. Further increasing its knowledge could lead to point C, which would require enough extra processing to degrade overall performance. In a system far out along the search speed axis, at point D, the performance gradient nearly parallels the knowledge axis and still faster searching yields only modest performance gains. Increasing the knowledge used by the search, however, could be expected to yield large payoffs. The question is how to do this without slowing the search. To date, most competent AI systems occupy knowledge/search regions near one axis or the other and further performance advances come slowly. For knowledge-intensive rule-based systems, complex interactions within the knowledge-base make adding still more knowledge increasingly difficult. The situation is a common one: Both humans and rule-based systems improve slowly when they know much and search little. For highperformance systems that rely on large searches, providing additional search capability usually means waiting for hardware advances. The deep understanding approach has been adopted by rule-based systems where human expertise in the field is captured within a knowledge base. This knowledge is then applied to the problem in much the same way as an expert would apply it. While this approach has performed reasonably well in certain domains, in the arena of chess playing programs where the criteria for performance are quite precise and the domain extremely varied (10 43 possible positions), deep understanding has not produced programs that play better than mediocre chess. Using a serial machine for searching requires one to determine the best balance between deep and shallow searching. It is possible to use a large number of serial machines to split up the task of investigating the space. However, this runs afoul of just how many machines are available, how they can be tied together, and how they can share results. The latter consideration can have a dramatic effect on the efficiency of the search process. Typically, speed-ups of more than the square root of the number of processors are difficult to achieve in chess. Experience with chess programs has shown that deep searching solves many of the problems that a shallow search with deep understanding has difficulty mastering. But deep search still requires a competent evaluation function to correctly evaluate the leaves of the search. While in theory the evaluation could be a very complex, open-ended procedure, involving changes of focus from global to local and back to global again, in most practical situations it is quite satisfactory merely to be able to apply what would pass as a first-cut approximation by a true human expert in the field. The problem is that such an expert would still understand a great amount, and this means that the evaluation of a single point in the search space can take so long that the effect of looking at millions of alternatives is to make the task intractable. The SUPREM 2 Michie makes a similar point in [5] Speed Figure 1: The know ledge/search performance tradeoff (Search Using Pattern Recognition as the Evaluation Mechanism) architecture offers a way of applying high quality knowledge very cheaply. The SUPREM Architecture The system architecture has four major parts, as Figure 2 shows: • The Oracle is SUPREM's primary knowledge repository and has all knowledge the system needs to operate. Since the knowledge is domain-dependent, each domain requires a unique Oracle. The Oracle has production-like rules which define interim goals for both sides and the patterns that are needed to recognize achievement of these goals during the search. • The Searcher is given a search task by the Oracle. It then invokes the Move Generator and the Evaluator to do the search and evaluate the leaf nodes of the search. • From a given domain state, the Move Generator generates subsequent states extremely rapidly by considering, in parallel, all feasible operators. • The Evaluator assigns numerical values to each reached domain state by comparing selected parts of the state -as patterns of state components -to pre-tabulated patterns in its memory. The four parts are organized into two separate subsystems. The Oracle is usually a general-purpose computer while the other three components comprise a special-purpose processor. 2 Oracle Overall control knowledge Task Results Searcher Forward/Backward, Figure 2: The SUPREM architecture 2.1 Operation of SUPREM The Oracle has rules that define the state-classes in the domain, and the knowledge required to properly evaluate the states likely to be reached by a search starting from the current state. Knowledge takes the form of patterns plus conditions under which the pattern knowledge can be applied. This pattern-based strategy gives SUPREM its name. The Oracle is smart but slow, and somewhat resembles a rule-based system, looking for those patterns that are most likely to be useful in the evaluation process. To do this well, the Oracle must be reasonably knowledgeable in the problem domain. At the start of each search iteration, the Oracle analyzes the problem and selects the appropriate knowledge. It then compiles the patterns into a form that can be evaluated by a simple table lookup and downloads the compiled patterns into units within the Evaluator that perform pattern recognition and evaluation. This strategy avoids the recomputation of pattern* values during the evaluation process, and so significantly speeds the evaluation. After downloading the patterns, the Oracle selects the depth of search and delegates control to the Searcher. Search then proceeds as follows: 1. At each new node, the Move Generator proposes the best operator to try next. 2. The Searcher broadcasts the candidate operator on the bus so that Pattern Recognizing and Evaluation units: "recognizers", and any other state-maintaining units, can update their individual state descriptions. 3. The Evaluator scores relevant state features via independent recognizers that consult their internal pattern tables for values. One key advantage over other searching systems derives from SUPREM's use of numerous recognizers operating in parallel. The Evaluator combines recognizer outputs in an adder tree and returns the new state's value.
doi:10.1016/0004-3702(89)90056-8 fatcat:xeijdn26g5hh5ksgnwgkbavsh4