JPH021021A - Retrieval processing system for high level-priority state transition - Google Patents

Abstract

PURPOSE:To efficiently obtain a solution by hierarchically arranging processes for processing in a tree structure and allowing states to correspond to processes and preferentially developing the state having a high evaluation function value. CONSTITUTION:Plural processes for state transition and processes for management of the execution order are generated and are hierarchically mapped into a tree structure. The tree consists of nodes and branches, and nodes are a root node RN1, branch nodes BN1-BN3, and leaf nodes LN1-LN4 in order from the top. Messages can be transferred only between nodes connected by branches. In a state space SP, transition from one state to the next state is performed in leaf nodes LN1-LN4, and generated state information flows between processors as a message. Branch nodes BN1-BN3 transfer information having a higher evaluation function value out of state information to corresponding leaf nodes LN1-LN4 as the state to be next processed, and the state transition is performed. Thus, the load of the management processing is distributed to efficiently obtain a solution.

Description

[Detailed Description of the Invention] [Summary] When realizing an expert system etc. on a parallel computer, execution priorities of transitioning states are managed hierarchically,
This paper relates to a superior priority state transition search processing method that decentralizes management by partially determining priorities based on state evaluation function values.

The aim is to increase the parallelism of processing related to state transitions, distribute the management processing load, and provide a means for efficiently finding solutions. A branch node process that manages the allocation priority of states to be processed in leaf node processes using the evaluation function value of the state, and a root node process that manages the entire process, and the root node process, one or more stages of the The branching node process and the leaf node process are configured as a tree type process, and each state is expanded in parallel by each leaf node process according to a priority partially determined from the order of partial evaluation function values. do.

[Industrial application field]

When implementing an expert system etc. on a parallel computer, the present invention hierarchically manages the execution priorities of transitioning states, and partially determines the priorities based on the evaluation function value of the state. This paper relates to a decentralized superior priority state transition search processing method.

One of the very important elemental technologies of knowledge engineering systems called expert systems is to use one operator (e.g. production rule/IF-THEN rule) to transition states one after another from a given initial state. There is a mechanism that leads to a procedure that leads to a termination state that satisfies termination conditions.

In searching for such state transitions, there is a need for a method that improves parallel execution and performs inference efficiently.

[Conventional technology and its problems]

FIG. 6 shows an example of a general inference system, and FIG. 7 shows an example of a state transition diagram.

In FIG. 6, 60 represents a processing device consisting of a CPU and memory, etc., 61 represents a state transition control unit that controls state transitions, 62 represents a work space that stores state information, and 63 represents a set of operators given as a knowledge base. .

In the inference system shown in FIG. 6, applicable operators from a set of operators 63 given as a knowledge base are used to transition states one after another from an initial state, until a given termination condition is satisfied. The inference cycle is repeated until a final state is reached.

Under such a state transition control mechanism, multiple operators can be used for a given state.2For example, as shown in FIG. A transition to the state is possible. In FIG. 7, a circle represents one state, and an arrow represents a state transition.

In particular, So is the initial state, and S7 is the end state that satisfies the end condition. In this way, the state space as a whole forms one search tree.

The goal is to find a path from the initial state S0 to the final state aS7 on this search tree. but.

In many cases, the size of the search tree grows exponentially, so unless some kind of search control is used, it takes a lot of time and it becomes impossible to actually derive the answer path.

Therefore, conventionally, an evaluation function is calculated for each state.

This method involves selecting the technique with the highest (good) evaluation function value among your techniques, and cutting out the other techniques.

That is, a method of performing conflict resolution has been used.

In this method, only one state exists at a given time (or at most the number of states to which the state transitions from itself), so there is almost no parallelism. Re is famous for its efficient search method.
As a result of measurement using a system using the te algorithm, 1
It has been reported that there was only an order of magnitude parallelism (Reference: Gupta.

A, Porgy, C, et al: Paral
lel Algorithms and Architecture
tures for Ru1e-Based Sys
tems, Proc.

of 13th Int, Sympo, on Co
Mputer Architecture pp2B-3
7, 1986).

Another drawback is that even though there is a path that can reach the final state from the initial state, a solution cannot always be obtained. In other words, since it is not guaranteed that the evaluation function value of the answer path will always be the highest at that branch point, the answer path may be pruned. -If you get cut down.

Since the technique is never deployed again, it becomes impossible to reach the final state.In this way, conventional search methods
There was a problem that there was little parallelism and there were cases where a solution could not be obtained.

In order to increase parallelism, a method can be considered in which each state is associated with one processor and executed in parallel. In this way, a large number of states can exist at the same time, and there is basically no correlation between horizontal states, so a very high level of parallelism can be achieved. However, in this case as well, the number of states increases exponentially with the depth of the search tree, so simply assigning each state to a processor will reduce the number of processors. No matter how much you have, it will never be enough.

Therefore, the present inventors developed a method in which each state is associated with a process, and the evaluation function value of each state is used to manage execution priority while limiting the number of processes, and the state space is expanded in parallel. thinking. In this method, a state with a high evaluation function value is dispatched as a high priority process, and a state with a low evaluation function value is saved as a process whose execution has been interrupted.

However, even in this case, if the evaluation function values are managed centrally, the load of management processing increases when the number of processes is increased, and there is a drawback that the effect of parallelism does not appear beyond a certain point.

The purpose of this book is to solve the above-mentioned problems by increasing the parallelism of processing related to state transitions, distributing the load of management processing, and providing a means for efficiently finding solutions.

[Means to solve the problem]

FIG. 1 is a diagram for explaining the present invention in detail.

In FIG. 1, RNI is a root node, BNI to BN3 are branch nodes, and LNI to LN4 are leaf nodes.

sp represents state space.

The present invention focuses on avoiding concentration of management when developing states in parallel according to evaluation function values. In particular, execution priority management is not determined after collecting all priority information, but is determined appropriately from one piece of information, and when viewed as a whole, processes with relatively high priorities are executed preferentially. Achieve a state like that. For this reason, instead of centrally and strictly managing the unfolding state, a method is adopted in which it is managed in a two-layered manner, as will be described later.

First, we create multiple processes that perform state transitions and processes that manage execution priorities, and map them into a tree structure.

A tree is made up of nodes and techniques, and in particular, the root node is the root node, and the leaf node is the tip node.

Other nodes will be called branch nodes.

One node corresponds to one process. Enable message communication between processes connected by branches. The process of transitioning from one state to the next is performed by each leaf node process. The generated state information flows between processes as a message.The 0-branch node determines the state to be processed based on the evaluation function value of the state in the flowing state information, and sends it to the node below it. Make sure to pass it on.

What is the correspondence between the process configuration and state space according to this method?

The result is as shown in FIG. In particular, the upper half of FIG. 1 shows a tree-shaped process configuration, and each node corresponds to a process. Among these, RNI is the root node, BNI to BN3 are branch nodes, and LN1 to LN4 are leaf nodes. Messages are transferred only between processes connected by branches.

The lower half of FIG. 1 shows the transition of states processed in this process configuration. Condition A to condition B B
, transitions to state C, then transitions from state B to state E
from state C to state F to state G.

Here, the broken line arrow from each leaf node to the arrow indicating the transition between states indicates which leaf node the state transition takes place.

Leaf nodes LNI to LN4 are associated with processes that transition states. Zero-branch nodes BNI to BN3 are processes that manage the allocation priority of states processed by each leaf node process using evaluation function values of the states. can be mapped to. The m-node RNI is located at the top level and is associated with a process that manages the entire system.

The branching nodes BNI-BN3 hierarchically manage the execution priorities of the transition states, and the processes of each leaf node LNI-LN4 manage the execution priorities of the transition states according to the priorities partially determined from the order of the partial evaluation function values. , each state is expanded in parallel.

[Effect]

For example, in FIG. 1, the transition from state aA to state 6B and state BC is handled by the process of nine leaf nodes LNI. The state information regarding the state BB and state LiC generated here is 1
It will be sent to branch node BN2. This state information is managed at the first branch node BN2 according to the priority order based on the evaluation function value, and the state BB is sent to the first leaf node LN2, and the state Bc is sent to the first leaf node LN2.
It is passed through branch node BNI and branch node BN3 to trifoliate node L N 4.

With 9 leaf node LNI for warm management.

When choosing the next state to expand, locally state E and state L
The 3iD evaluation function values are compared and state E is expanded next. At this time, there may be another state (for example, state LiF) that has a better evaluation function value than state BB from the perspective of the whole, but it is determined locally and processing of state E is performed first. In other words, in order to increase parallelism, the best state is not necessarily selected, but the state with the best evaluation function value is selected as much as possible.

If you try to strictly manage it, all the state information will be transferred to the root node (or branch node on the turret),
Therefore, it is necessary to collect the states with the best evaluation function value from among all the states. In this case, it takes time to process the data until it is transferred to the root node, and the management processing of the evaluation function value is concentrated on the root node, making it impossible to achieve the problem that is being attempted. In other words, since the load of management processing is too large, sufficient parallel processing cannot be performed.

Therefore, by managing the state evaluation function values locally at each branch node, the management of state evaluation function values is prevented from being concentrated in one place and becoming a bottleneck.

It is preferable to allocate processing to leaf nodes on a request-driven basis. In other words, when a second leaf node becomes free, it issues a work request to the branch node above it and receives the state to be processed. Make it. The state information newly generated at the leaf node is passed to the branch node in the order it is created. A branch node can only change its own state if there is a request from below and it has its own state information.

Those with good evaluation function values are passed down. When state information is sent from below, it stores that information and forwards it to the upper branch node using an appropriate strategy. By doing this,
Resources can be managed efficiently.

The root node performs overall management such as providing an initial state and instructing the entire process to terminate. If requests from all leaf nodes reach the root node, there are no more states to process, so the process ends.

By doing this, management is distributed among the branch nodes, and the load of management processing does not become too large.

What should be noted here is that rather than performing strict management that determines the state to be processed based on the overall priority, loose management is performed by determining local priorities.

In searching the state space, search 1, in which the state with the best evaluation function value is expanded first, is a best-first search (Bes
It is called t-First 5arch). Here, it is not clear whether it is the best or not, but since the evaluation function values are developed first from the surroundings, it is called a better-first search.

〔Example〕

Fig. 2 is an example of the hardware configuration of a system to which the present invention is applied, Fig. 3 is a processing flow of a leaf node process according to an embodiment of the present invention, and Fig. 4 is a branching according to an embodiment of the present invention. Node Automaton FIG. 5 shows the processing flow of a branch node process according to an embodiment of the present invention.

The system shown in FIG. 2 is a system in which a plurality of processors P1 to P4 have a shared memory MEM.

The invention can be implemented on one such multi-processor system, for example, but is not limited thereto.

It is also possible to implement it on various types of parallel hardware.

Each node process is placed on a respective processor Pi to P4. There is no need for a one-to-one correspondence between processes and processors. In this example.

Processor P1 has four processes, processor P2 has one process, processor P3 has two processes, and processor P4 has one process.

Furthermore, in this example, messages are communicated between processes via a shared memory. In addition, a method of attaching hardware dedicated to message communication may also be considered.

Messages basically contain state information such as state contents (changes) and evaluation function values;
There is also one for requesting transfer of state information.

The state itself is placed on the shared memory MEM and accessed by each processor in parallel. However, each state is handled according to the single assignment rule, so that although it may be read at the same time, it is never written to at the same time. In other words, when a state changes, the contents of the state are not rewritten, but a new state is generated. However, as long as access conflicts do not occur.

It is okay to share parts.

In the initial state, a leaf node process sends a message requesting the transfer of state information to the upper branch node and waits for the state information to be transferred. When state information is transferred, a plurality of new states are generated based on the state information G. As soon as the generated state is generated, it is transferred to the upper branch node as state information. When all transitionable states have been generated from the transferred state information, it issues another state information transfer request message and waits for the primary state information to be sent.

The processing flow of this leaf node process is as shown in FIG. 3, for example.

■ Send a status information transfer request message to the upper branch node.

■Receive and receive status information from the branch node above.

■ Uke applies applicable operators to the acquired state and performs a state transition. Furthermore, the evaluation function value for the generated state is determined by calculation.

■ Transfer the state information including the evaluation function value of the generated state to the upper branch node.

■ Determine whether there are other applicable operators and the transition is still possible. If it is still possible to transition, process ■
Return control to the first order transition (te).

If the transition is not possible, return to process (■).

The process of each branch node is the fourth [l! As shown in I, an automaton is configured depending on whether or not there is a request to transfer state information from a lower node, and whether or not it stores state information itself. This content is the same for branch nodes at any level of the tree structure.

When a branch node receives a transfer request from a two-leaf node in the state shown in FIG. 4(a), it passes state information and transitions to either (a) or (b). When a further request is received in (b), the process transitions to C), where the request is sent to the upper node. (c)
After receiving the state information from the leaf nodes, move to (b),
After receiving the state information from the leaf node in (b), the process moves to (a).

The processing flow of the branching node process that realizes this automaton is, for example, as shown in (1) to (2) shown in FIG.

■ Receive and receive messages from higher-level nodes or lower-level nodes.

■ The receiver determines whether the received message is status information. If it is not status information, move to process (2).

■ If it is state information, determine whether there is a request from lower nodes. If there is no request.

Process ■, if there is, move to process ■.

■ Store state information according to priority based on evaluation function value. After that, return to process (■).

■ If there is a request, pass state information to its lower nodes. After that, return to process (■).

■ If the received message is not status information, the receiver determines whether it is a transfer request. If it is not a transfer request, move to process [phase].

■ When a transfer request message is received, the device determines whether there is any status information currently being managed by itself.

If there is status information, move to process ①.

■ If state information is not available, store the request in a work area.

■ Send a request to the upper node and return to processing ■.

The receiver of the message waits for the receiver.

■ Determine whether the message is a report of an evaluation function value from a lower node. The following process.

Although it is not essential, in this embodiment, monitoring is performed periodically in order to reduce variations in the evaluation function values of the states that the lower nodes are in charge of.

Reporting the evaluation function value is a message for that purpose. If the evaluation function value is not reported, an error will occur.

■ When the evaluation function value is reported, compare the evaluation function value of the child node.

0 If the evaluation function values of the states held by the child nodes are significantly different, process 0 is executed. If there is no significant difference in the evaluation function values, store the evaluation function values and return to process (2).

■ Exchange state information so that evaluation function values are averaged as much as possible between child nodes. After that, return to processing ■.

■ In addition to processing messages by receiving and receiving messages, time monitoring is performed at appropriate time intervals in order to report evaluation function values to higher-level nodes.

■ When a predetermined period of time has elapsed, the best evaluation function value within its control is reported to the upper node.

Then wait for the next opportunity to report.

The above is the main processing flow of the one-branch node process. Here, when each branch node sends state information to the node below, it selects the one with the best evaluation function value among its own state information. It is important to let it flow. There is no need to explain the processing flow of the root node process in detail, but except for the part related to the upper node, 1
It is almost the same as the branch node process, and has other functions such as conversation processing with the user, initialization processing at the start of processing, and termination processing. Of course, nine different types of user interfaces can be prepared.

-m, various evaluation functions can be used in the state transition search.

For example, consider the problem of minimizing the total travel distance of all trucks required for delivery and the variation in travel distance of each truck when delivering newspapers from one main factory to each distributor by truck. The following evaluation functions can be selected.

The sum of the distance traveled by all trucks in a certain state is E+
, the sum of the difference between the average value and the mileage of each truck is Ex,
Es is the sum of the number of undelivered newspaper copies.

The number of times the operator has been applied up to that point is E, and the weighting for each element (E, ~E,) is W1 ~ W
4, the evaluation function is determined as follows.

B3 xw, -B, xw, -B, XW2-E4 xw
.

It goes without saying that for other problems as well, it is possible to similarly determine an appropriate evaluation function and search for superior priority state transitions using the evaluation function value.

〔Effect of the invention〕

When performing planned problem solving using state space search, a large number of expandable states can exist at the same time, so high parallelism can be achieved by associating states with processes. At this time, a solution can be efficiently obtained by preferentially expanding from a state with a high evaluation function value. In addition, because the state with a low evaluation function value is not pruned but only interrupted, no matter what evaluation function is used, the necessary path will be pruned and a solution will not be obtained. do not have.

If you try to centrally and strictly manage this evaluation function value,
The management processing load increases and parallelism is impaired. According to the present invention, the state with locally good evaluation function values is preferentially deployed, not necessarily the state with the best evaluation function value, so the management processing load is distributed and processing is performed in high parallelism. It becomes possible to do so.

By hierarchically arranging processes for management processing and processes for state transition processing in a tree structure, it becomes possible to easily implement the above-mentioned loose management using evaluation function values.

Process flow.

Figure 6 is an example of a general inference system.

FIG. 7 shows an example of a state transition diagram.

In the figure, RNI represents a root node, BNI to BN3 represent branch nodes, LNI to LN4 represent leaf nodes, and SP represents a state space.

Patent applicant Kozo Iizuka, Director of the Agency of Industrial Science and Technology

[Brief explanation of the drawing]

FIG. 1 is a diagram for explaining the present invention in detail. FIG. 2 shows an example of the hardware configuration of a system to which the present invention is applied. FIG. 3 is a flowchart of a leaf node process according to an embodiment of the present invention. FIG. 4 shows a branch node automaton according to an embodiment of the present invention. FIG. 5 shows a branch node automaton according to an embodiment of the present invention. Explanatory diagram 1st figure Hardware 411 of the present invention 1st row 2nd figure Leaf node process flow n Figure 3 Branch node automaton Branch node process process flow

Claims (1)

[Claims] An initial state, a termination condition, and a set of operators are given, an appropriate operator is selected from the set of operators, and the operators are used to generate states one after another from the initial state. In a state transition search processing method in an inference system that derives a procedure leading to a final state that satisfies A leaf node (LN) that changes state by applying an operator
1, LN2, ...) processes and branch nodes (BN1, BN2, etc.) that are located above the leaf node processes and manage the allocation priority of the states processed by each leaf node process using the state evaluation function values. ,...) process, and a root node (RN1) process that is located above the branch node process and manages the whole, and the root node process, the branch node process in one or more stages, and the leaf node process are provided. is a tree-like process structure, and each state is expanded in parallel by each leaf node process according to a priority partially determined from the order of partial evaluation function values. Transition search processing method.