JPS63229528A - Knowledge base processor - Google Patents

Abstract

PURPOSE:To narrow a searching space and to increase the processing speed with a knowledge base processor by using a knowledge filter and a memory means and obtaining an answer out of a knowledge base via an arithmetic processing part and the knowledge filter with use of the horn nodes stored in the memory means. CONSTITUTION:A search tree of a knowledge base 4 is decided when a certain inquiry is received. Thus it is possible to previously choose such nodes that are possibly used in an inference process before execution of the deductive inference out of the base 4 when said inquiry is received. When the inquiry is received, a knowledge filter 1 extracts all horn nodes with which the higher and lower rank relations can be unified out of the base 4 based on the search tree of the base 4. These extracted nodes are stored in a primary memory part 5. An arithmetic processing part 6 chooses the desired nodes out of a small search space narrowed previously at the part 5 and carries on the arithmetic processing.

Description

[Detailed Description of the Invention] [Objective of the Invention] (Industrial Field of Application) The present invention relates to a knowledge base processing device that processes knowledge expressed in the Horn clause format in PROLOG, and particularly to a knowledge base processing device that processes knowledge expressed in a horn clause format in PROLOG. The present invention relates to a knowledge base processing device that is capable of processing data.

(Prior Art) In this type of knowledge base processing device, knowledge is given in the form of rules and facts in the form of Horn clauses (hereinafter simply referred to as "clauses"), and these are stored in the knowledge base. and,
When a certain query is given, PROLOG's deductive mechanism makes inferences and obtains the solution to the query.

That is, the query entered into the system is PROLOG
At the goal section, ? Series word name A (argument al, argument a2...), predicate name B (argument bl, argument b2...), ... (1);-
Predicate name A (argument a1. argument a2...), predicate name B (argument bt, argument b2...), ... (2) fact> predicate name C (argument cl, argument c2) ．・・・）, ・・・
It is given in the form (3). Here, “predicate name
・)"(X-A, B, C,...) are called terms, and especially the "predicate name C(
...)°, which is added before the expression, is the head of the clause, and is the predicate name A( in (1) and (2) above.
What is added after the expression, such as "Predicate name B(...)", is called the body part of the clause.

Conventionally, when a certain query is given, the PROLOG processing system in the system searches the knowledge base for the clauses necessary to solve the query, follows the path that makes the logical formula hold, and finally solves the query. I was looking for an answer to an inquiry.

However, in general, the amount of knowledge in the knowledge base is often large, and the knowledge search space is very wide, so there is a problem that it takes time to find a solution. It is clear that such problems will become even more prominent in the future as the amount of knowledge in the knowledge base increases.

There was a problem.

The present invention was made in consideration of such circumstances, and
The purpose is to provide a knowledge base processing device that can process a large amount of knowledge in a knowledge base at high speed.

[Structure of the Invention] (Means for Solving the Problems) The present invention includes a knowledge base that stores knowledge expressing rules or facts in a Horn clause format, and a method for deducing queries using the knowledge of the knowledge base. A knowledge base processing device comprising a deductive processing unit that performs processing to obtain a solution to the query, based on a search tree in the knowledge base determined by the content of the query,
A knowledge filter for extracting Horn clauses whose lower-order relationships can be unified from the knowledge base, and a storage means for storing the Horn clauses extracted by the knowledge filter, and the deduction processing unit The decision is made at a stage characterized in that a deductive process is performed from the knowledge base using the Horn clause stored in the storage device via the knowledge base. Therefore, at the stage when a query is given, it is possible to select in advance clauses that may be used in the inference process from the knowledge base before performing deductive inference.

- In the present invention, when a query is given, the knowledge filter extracts from the knowledge base all Horn clauses whose upper/lower relationships can be unified based on the search tree in the knowledge base. The extracted clauses are stored in the storage means. The deduction processing section selects a necessary node from a narrow search space narrowed down in advance in the storage means and proceeds with the process.

(Example) Hereinafter, an example of the present invention will be described based on the drawings.

FIG. 1 is a block diagram showing the configuration of a knowledge base processing device according to an embodiment.

The knowledge filter 1 extracts necessary knowledge from the knowledge base 4, which is a secondary storage unit, via the disk control device 3 based on the knowledge base index 2 in response to the input inquiry, and stores it in the secondary storage. output to section 5. Deduction processing unit 6
is the above-mentioned -next storage section 5, that is, the inquiry is given to one input of the selector 11. The output of this selector 11 is given to a buffer 12 that is a first buffer, and the output of a buffer 13 that is a second buffer is introduced to the other input of the selector 11. The output of the buffer 12 is input to the duplication checking unit 14, where it is checked to see if it overlaps with the extracted terms registered in the register 15, and then stored in the buffer 16. The output of the buffer 16 is manually input to the unification inspection section 17.

This unification checking unit 17 is provided with nodes stored in a buffer 18 from the knowledge base 4 via the disk control device 3, and here unification (unil'1cation) is provided.
) is inspected, and those that can be unified are sent to the duplicate inspection section 19.
is given to. This duplication checking unit 19 is given the clauses stored in the -next storage unit 5, and is checked to prevent the clauses stored in the -next storage unit 5 from being stored in the -next storage unit 5 again. Ru. The nodes that have been checked by the duplication checking section 19 are stored in the -order storage section 5 and the buffer 13. In addition, this duplication is checked by a p module that inputs the inspection results from the two duplication inspection sections 14 and 19 and the unification inspection section 17, and controls the sending of data to the next stage according to the inspection results. ing.

The operation of the system configured as described above is shown in Figures 2 to 4.
This will be explained based on the flowchart shown in the figure.

First, when an inquiry in the format (1) is input, (31)
, the selector 11 selects this query, extracts the term of its body part, and writes it to the buffer 12 (3
2). Here, the structure of the buffer 12 is a queue (F
I F O; f'1rst 1nrlrst ou
t).

Next, the duplication checking unit 14 checks whether the term read from the buffer 12 overlaps with the term in the register 15 (33). That is, in register 15,
The terms are stored in a hash table in code form, and whether or not the term read from the buffer 12 overlaps with the term in the register 15 is checked by referring to this hash table.

When the term read from the buffer 12 does not overlap with the term in the register 15, the duplication check unit 14 controls the control unit 2.
A 1-bit signal °1° is sent for each 1, and when there is a duplicate, a 0 is sent. Do not send control write commands (34
). Here, the structure of the buffer 16 is a queue (F I FO) like the buffer 12.

Note that in the initial state, nothing is stored in the register 15, so no duplication is detected and the signal is "1".

When the duplication check is completed for the first term read from the buffer 12, the duplication check unit 14 calls the next term from the buffer 12 and performs the duplication check again. This process is repeated until the buffer 12 is empty (36).

Next, the control unit 21 uses the knowledge base index 2 to search the knowledge base 4 for a clause whose head part has a predicate name that matches the term written in the buffer 16 (41).
, and write to the buffer 18 (42). Knowledge base index 2 stores the code of a predicate name and the address of a node in knowledge base 4 that has that predicate name in its head in the form of a hash table. It is checked whether the clauses in the section can be unified with the terms classified and stored in the storage 43), and if they can be unified, a 1-bit signal "11" is sent to the control section 21. When the signal is “1”, the control unit 21 instructs the unification check unit 17 to send a field, and sends a clause to the special check unit 19 “. 5end" is sent (44, 45), and when the signal is "Om", the sending command of the clause "f"" is not sent (44).

When the unification check is completed for the first node read from the buffer 18, the unification check section 17 calls the next node from the buffer 18 and performs the unification check again. This process is repeated until buffer 18 is empty (46).

Next, the one multiple 1M checking unit checks whether the node sent from the unification checking unit 17 overlaps with the node in the primary storage unit 5 (51).

That is, in the -order storage section 5, the clauses are stored in a hash table in code format, and the clauses sent from the unification check section 17 are stored in the primary storage section 5, and the duplication check section 19 stores them in the control section. A 1-bit signal "1" is sent to the 21, and if there is a duplicate signal, a "0" is sent. When the signal is "1", the control section 21 sends a write command "Write" to the duplication checking section 19 to write a clause to the buffer 13 and the next storage section 5 (52°53), and the signal becomes "0". At this time, no write command is sent (52). Here, the structure of the buffer 13 is also a queue (FIFO).

Note that in the initial state, nothing is stored in the -order storage unit 5, so no duplication is detected and the signal is "1".

When the duplication check is completed for the first clause sent out from the unification check unit 17, the duplication check unit 19 performs the unification check unit 17.
Read the next section from and perform the duplicate check again. This process is repeated until no clauses are sent from the unification checker 17 (54).

The body section of the clause written in the buffer 13 is read out and written into the buffer 12 through the selector 11. Here, the selector 11 selects inquiry or writing from the buffer 13, and when the knowledge is read from the knowledge base 4 and written to the primary storage section 5, When there are no equivalent changes (no new writes have been made), the cycle stops and the selection of knowledge from the knowledge base 4 ends.

Therefore, it is necessary to check the state of the primary storage section 5 every cycle.

LFP (1east Nxed point)
The inspection section 2'0 inspects the state of this secondary storage section 5.

Here, after the end of one cycle, it is checked whether new writing has been performed on the -next storage unit 5, and if writing has been performed, a signal of "0°, otherwise 1" is output. The data is sent to the duplication checking section 19 to instruct whether or not to perform the next cycle. When it is "1", it outputs that the selection from the knowledge base 4 to the primary storage unit 5 has been completed (55).

On the other hand, when it is "0", the node in the buffer 13 is read out (56) and written into the buffer 12 via the selector 11, and the same operation is repeated thereafter.

Please explain the operation above ξi with a more concrete example."f
It will be less than 1. That is, for example, when knowledge base index 2 is in the state shown in FIG. 5, query ?-ancestor (taro, A), m
ale (A).

, are shown in FIGS. 6 to 8.

FIG. 6 shows the first cycle.

First of all, please inquire “? -ancestor (taro,
A).

male (A), ``ancestor''
(taro, A) -ANI”, “fflale(
A)-MA” is written to the buffer 12, and the duplication check unit 1
4, the overlap with the term in register 15 is checked. In the initial state, no term is stored in register 15, so as a result of the check, register 15. Buffer 16
The term “ancestor (taro, A)”, “
"male (A)" is written. Next, the term "ancestor (Laro, A)" is written through the control unit 21.
, male(A)” and the same predicate name “ancest”
or”, the clause with the head “male” is searched from the knowledge base by referring to the knowledge base index,
As a result, the node ■■■■■ is written into the buffer 18.

Among these, the term “ancestor(taro, A)
, "male(A)" and a node with a head part that can be unified is extracted by the unification checker 17 and sent to one duplication checker.In the initial state,
Since no clause is stored in the -next storage unit 5, the clause ■■■■ is written in the -next storage unit 5 and buffer 13 as a result of the inspection. In this recital, since the clause has been written to the -next storage section 5, the LFP inspection section 20 instructs to perform the next cycle.

FIG. 7 shows the second cycle.

First, in the initial state, the buffer 13 stores nodes ■■■■, among which the term “parent(X, Y)
-PAL', "parent(X,Z)-PA2"
-”ancestor (Z, Y)-AN2′ is written into the buffer 12. The duplication checking unit 14 writes “parent
(X, Y)” is checked for duplicates and written to register 5, “parent (X, Z)” is checked for duplicates, but “parent (X, Z)” is
nt(X, Y)", so it is removed in the duplication checking unit 14.Finally, the register 5 and buffer 16 contain the terms "parent (X, Y)" and "anc
estor (Z, Y)' is written. Next, the term “parent (X, Y)
“.

The predicate name "parent" is the same as ancestor (Z, Y)'.

A clause having the head part of "ancestor" is retrieved from the knowledge base 4 with reference to the knowledge base index 2, and as a result, the clause ■■■■■■: is written in the buffer 18. Here, all head parts i1 of these clauses, the term “
parent (X, Y)” or “ancestor”
Since they can be unified as "pZ, Y)", all of those clauses are sent to the duplication checker 14. Here, since the -next storage unit 5 stores the clause ■■■■ selected in the previous cycle, the duplication check unit 19 removes ■■ and
■■ is written to the temporary storage and buffer 13. Since the clause has been written to the primary storage unit 5 in this cycle as well, the LFP inspection unit 20 instructs the next cycle to be performed.

FIG. 8 shows the third cycle.

First, in the initial state, the buffer 13 contains nodes ■■■
■ is stored, among which the term “father (X
, Y) -F A" is written into the buffer 12. The duplication check unit 14 checks father (X, Y)', and the term "f'atbe
r (X, Y)" is written. Next, the control unit 21
, a clause with the same predicate name "f'ather" as the term "f'ather (X, Y)" is referenced in knowledge base index 2, but such a clause does not exist in knowledge base 4. , no writing is performed to the buffer 18. Therefore, the unification checker 14, 'L F P
The inspection unit 20 detects that writing to the primary storage unit 5 has not been performed in this cycle, and instructs the end of the cycle.

Inquiry, by such steps? -ancestor (taro, A), l
1ale (A).

In contrast, the section from knowledge base 4 which is the secondary storage part■■■■
■■■■ is selected and stored in the -next storage unit 5, and the process ends.

In the above system, since the knowledge filter 1 can be controlled by a processor independent of other processors, parallelization with other processors is possible.

Furthermore, as is clear from the above embodiments, since there is little interdependence between the respective constituent elements, pipeline processing is possible and speeding up of processing can be realized.

Note that if the knowledge base is divided into rules and facts and managed, processing efficiency in knowledge selection can be improved, and processing speed can be further increased.

Furthermore, when the number of terms in a query is large, it may be possible to select knowledge in parallel by preparing a plurality of knowledge filters.

1. In short, the present invention can be implemented with various modifications without departing from the gist thereof.

[Effects of the Invention] As explained above, the present invention uses a knowledge filter that selects knowledge that may be used for subsequent inference in response to a certain query from the knowledge base and transfers it to the storage means. Therefore, it is possible to make inferences regarding the query using the knowledge in the storage means selected from the knowledge base,
Compared to conventional methods that extract knowledge directly from a knowledge base and perform inference processing, it is possible to narrow down the knowledge search space.
As a result, it is possible to speed up the processing of inquiries.

[Brief explanation of the drawing]

FIG. 1 is a block diagram showing the configuration of a knowledge base processing device according to an embodiment of the present invention, FIGS. 2 to 4 are flowcharts for explaining the operation of the device, and FIG. Figures showing specific contents of the base index and knowledge base, and Figures 6 to 8 are timing charts for explaining the operation of the device. ) 1...Knowledge filter, 2...Knowledge base index I, "Applicant Kozo Iizuka, Director General of the Agency of Industrial Science and Technology"

Claims (3)

[Claims] (1) A knowledge base that stores knowledge expressing rules or facts in a Horn clause format, and a deductive processing unit that performs deductive processing on an inquiry using the knowledge of the knowledge base to find a solution to the inquiry. The knowledge base processing device includes a knowledge filter that extracts Horn clauses whose upper and lower relationships can be unified from the knowledge base based on a search tree in the knowledge base determined by the content of the inquiry. , a storage means for storing the Horn clause extracted by the knowledge filter, and the deduction processing unit performs a deduction process using the Horn clause stored in the storage device from the knowledge base via the knowledge filter. A knowledge base processing device characterized by performing the following. (2) The knowledge base processing device according to claim 1, wherein the knowledge filter includes a duplication check unit that prevents the same horn clause from being extracted from the knowledge base. (3) When the horn clause is composed of one or more terms, and the first term is the head part and the second half term is the body part, the knowledge filter extracts from the query or the knowledge base. A first buffer that stores terms in the body part of the horn clause that has been stored, and a horn clause that has the same predicate name as the term stored in this first buffer in the head part and can be unified with the above term. a second buffer for storing the body part of the horn clause extracted by the extracting means and outputting it to the first buffer; 3. The knowledge base processing device according to claim 1, further comprising: an LFP inspection unit that outputs a selection end signal when the selection end signal is no longer stored.