JP2624751B2 - High-speed inference method for compiled knowledge processing tools - Google Patents

Description

Description: BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a high-speed processing method of an expert system, and in particular, to an inference processing method of realizing high-speed inference by converting rules and facts into a machine language instruction sequence of a computer. About.

[Conventional technology]

Conventionally, a method for constructing a high-speed inference engine of an expert system using a pattern matching function of a logic language is described in Logic Programming Conference '87, 1987, pp. 233 to 242 (The Logic Programm.
ing Conterence '87 (1987) pp233-242).

[Problems to be solved by the invention]

The above prior art uses a logical language PROLOG,
It aims to build a high-speed inference engine by effectively using the pattern matching function and the backtracking function of the language itself (PROLOG is described in detail in the literature: Nakajima: PROLOG Kyoritsu Publishing). is there. For this reason, there is a problem that the essential function of the inference engine, that is, a function of “finding all solution information including combinations of executable rules and facts satisfying the conditions and generating a solution information set” cannot be efficiently realized. . That is, PROLOG
Is based on finding only one executable rule by using a pattern matching function to set a value to a variable called unification and a backtrack function to automatically go back and select another rule. The reason for this is that the essential function of the inference engine, "Finding all executable rules", is inherently weak. In the prior art, the solution information set is realized by a PROLOG fact statement, and the fact statement is
It was necessary to add using OG assert, and remove certain fact sentences using retract. For this reason, in the generation and deletion processing of the solution information, it was necessary to convert the solution information in the work area of the PROLOG into a machine language instruction or into an intermediate language expression form of the PROLOG. Furthermore, since the converted machine language instruction or intermediate intermediate has to be copied to an instruction code storage area or intermediate intermediate storage area, high-speed processing has been difficult.

SUMMARY OF THE INVENTION An object of the present invention is to provide a high-speed inference method in a compile-type processing tool that is a basic function of an inference engine that performs forward inference and that can obtain all executable rules and update each piece of solution information at high speed. To provide.

[Means for solving the problem]

The object is to convert a knowledge base consisting of knowledge of facts and rules into machine language instructions for a computer to execute, and execute the converted machine language instruction sequence and the converted machine language instruction sequence. An inference method in an inference system that executes a solution information selection machine language instruction sequence to select one of generated solution information and performs inference, using the solution information selected using the solution information selection machine language instruction sequence. A fact change procedure for updating the fact by changing the data part of the machine language instruction sequence converted from the fact, and further, a machine language instruction sequence corresponding to a rule that refers to the updated fact, into a fact management table. This is achieved by a procedure performed using

[Action]

In order to generate a solution information set at high speed, first, using the solution information selected using the solution information selection machine language instruction sequence,
The fact changing procedure for changing the data part of the machine language instruction sequence converted from the fact makes it possible to update the fact at high speed.

Furthermore, by using the fact management table of the table that manages the machine language instruction sequence corresponding to the rule that refers to the updated fact, the machine language instruction sequence that needs to be executed again by updating the facts can be quickly obtained. Can be executed.

According to the above procedure, after selecting the solution information, the fact is updated at a high speed, and then all other executable rules are obtained one after another, so that each piece of the solution information can be generated at a high speed.

〔Example〕

First, an example of knowledge of rules and facts is shown in FIG. 2, and the execution process will be described with reference to FIG.

FIG. 2A shows an example of the knowledge of the judgment. That is, if there is a fact X whose attribute “value” is “human”, the rule is a word that the attribute “value” of the fact X should be changed to “die”. In the example, Socrates means having "human" as the attribute "value".

As shown in FIG. 3, the execution process of the inference engine using this example assumes that
Check whether (C) satisfies the condition (D1) of the rule, and if it is satisfied, hold solution information consisting of rule 1, fact 1, and the value of variable X (rule 1, fact 1, X = Socrates) Hold to area. In this example, the only rule that has no solution information and can be executed is the rule in the above solution information. Therefore, the execution process of the next rule follows (D2), and is the fact that Socrates The process of changing the value of the attribute “value” to “die” is performed. As a result, a new fact (E) (fact 2: Socrates value = die) is created. Next, a process of deleting the solution information having the fact 1 before the change from the solution information holding area is performed. As a result, no solution information exists in the solution information holding area. Next, if it is checked whether the condition (D1) of the rule is satisfied using the new fact 2, the rule is not satisfied, so that all rules are not satisfied, and the process is terminated because the solution information holding area has no solution information. I do.
As a result, only the fact 2 in FIG. 3E is obtained from the forward inference.

In general, since there are a plurality of rules and facts, the above-mentioned solution information explosively increases, and in such forward inference, speeding up the processing for obtaining all the solution information is a major problem.

FIG. 4 shows a forward inference execution mechanism of the inference engine. Here, F1 performs a pattern match between the rules of F5 and the facts of F4, finds all solution information that satisfies the condition part of the rules of F5, adds it to the solution information set, and in the next conflict resolution process of F2, Only one rule is selected based on the rule.
For example, there are a strategy for preferentially selecting a rule established by the most recent fact, and a strategy for preferentially selecting a rule having the largest number of conditions. Next, the execution unit of the rule selected in F3 is executed, the fact is changed, a new fact is generated or the fact is deleted, and the solution information established under the fact before the change is obtained from the solution information set. In addition to the deletion, the pattern matching process F1 for obtaining all rules that are newly established under the changed or newly added fact is repeated again.

As described above, the inference engine repeats the execution until the solution information set becomes an empty set.

FIG. 5 is a hardware configuration diagram for realizing one embodiment of the present invention. Here, H is a computer for executing a program stored in the recording device G.
The machine language instruction is Abstract PRO written by DHD Warren.
LOG Instruction Set, SRI Intrnationl Technical No.3
Assume that it has at least the machine language instructions described in 09,1983. G is a storage device, G1 is a storage area for storing a knowledge base consisting of rules and facts shown in FIG. 1, G2 is a storage area for storing a program for realizing the means of the present invention, G3 is G1 by G2 program
G4 is a storage area for storing a machine language instruction sequence converted from the knowledge base of GHD, and G4 is a work area used when the machine language instruction sequence of G3 is executed.
In the literature of en, it means an area called Heap. G5 is a solution information holding area newly established to realize one means of the present invention, G6 is a control area used by the machine language instruction sequence of G3, and means an area called Stack in the above document. I do. G7 is a storage area for storing the address of a variable in order to return the variable to its original value when a backtrack occurs, and is a storage area called a Trail Stack in the above document. G8 is a work area used by the conversion program of G1.

FIG. 6 shows the overall configuration of a program for realizing the means of the present invention. Here, I1 is a program for converting knowledge of the facts in FIG. 2 into a machine language instruction sequence, I2 is for converting a condition part of a rule into a machine language instruction sequence, and I3 is a program for converting a rule execution part into a machine language instruction sequence. A program that converts to columns
I4 is a processing program for creating a fact management table.

FIG. 7 shows I2 in more detail, where I20 is
I21 is a machine language instruction sequence generation program having a function of generating solution information, which is an important means of the present embodiment, which is a main body of a program for converting a condition part of a rule into a machine language instruction sequence.

FIG. 8 shows I3 in more detail. I30 is a program for converting a rule execution section into a machine language instruction sequence, and I31 is an attribute obtained by executing the machine language instruction sequence generated by I30. This is a program for generating a machine language instruction sequence for deleting all the solution information having the fact that the value has been changed from the solution information holding area.

Hereinafter, the configuration of each program will be described in detail. FIG. 9 shows a general expression of knowledge of facts. In the present invention, in order to speed up the pattern matching process of F1 in FIG. 4, knowledge of the facts in FIG. 9 (J) is obtained by using "get-constant fid, A1", "get −con
stant time-tag, A2 "," get-constant Vi, A _{i + 2} "(i =
1 to n) Experiment high-speed pattern matching by converting to a set of instruction sequence and “Proceed” instruction.

Here, the above-mentioned get-constant instruction is a constant and an argument register A _i (referred to as an Argumeut register in the above document).
This is an instruction to perform a pattern match. Fid is an identification number for uniquely identifying a fact, and time-tag
Is a time flag indicating the newness of the fact. That is, the larger the value of the time-tag, the newer the fact. Further, V _i (i = 1 to n) is
Attribute value of the fact, the “Proceed” instruction
This instruction is executed only when the pattern matching of the get-constant instruction succeeds.
This is an instruction to jump to the address specified by the ntinuous pointer. That is, the program I10 in FIG.
FIG. 9 shows means for converting (J) in FIG. 9 into a machine language instruction sequence of (K) and storing it in the storage area G3 in FIG. I101 means the processing of I1. That is, in I101, the “ge” is transferred to the location specified by Code-Pr indicating the top address of G3.
Perform processing to write the t-constant fid, A1 "instruction.
In 102, Code-Pr is incremented by the size α of the instruction. In the next I103, a process of writing the “get-constant time-tag, A2” instruction to the location specified by Code-Pr is performed. In the next I104, only the instruction size α
Code-Pr is incremented. In the next I105, I1
06 and I107 are executed n times for the number of attributes of the fact.
To the address designated by Pr, the above “get-constant Vi, A
_In the next I107, the Code-Pr is incremented by the instruction size α. In the next I108, the “Procee” is moved to the location specified by the Code-Pr.
d ”instruction is written, and finally Code-Pr is changed to“ Procee ”at I109.
The d "instruction is incremented by the size β and the processing is terminated.

FIG. 11 shows a configuration diagram of a fact management table created at I4 in FIG. That is, the fact is
Not only is it referenced in the pattern match processing F1 in the figure,
F3 also changes the attribute value of the fact. This fact management table is used to quickly change the attribute value in F3 above and to quickly check the feasibility of the rule that refers to the fact in the condition part in F1 when the change occurs Used.

That is, as shown in FIG. 11, the fact management table FT
Is a pointer 1hs-tbl-adr to a table 1hs-tbl composed of the addresses of machine instructions converted by I2 from the condition part of the rule referred to by the fact and the condition part for each fact
And the number of attribute n-slot of the fact, the fid information for uniquely determining the fact, and the fact-P to the machine language instruction sequence corresponding to the fact
It consists of r.

Next, the condition part processing program of the rule in FIG. 7 will be described in detail. I20 is a program for converting a condition part into a machine language instruction sequence, and I21 is a program for generating a machine language instruction sequence having a function of generating solution information, which is the most important means in the present invention. Before explaining the above program,
Using FIG. 12, a description will be given of what machine language instruction is used to convert the condition part of the rule.

A12 is a condition part of a rule composed of n conditions.
Generally, each of these conditions refers to the attribute value of a fact, and is based on the relationship between the attribute values of the fact. In addition, general conditions can be described, and each attribute may include a variable as in the rule conditions in FIG. In the means of the present invention, the condition part of such a rule is converted into the machine language instruction sequence shown in FIG. 12 by the number of facts referred to in each condition. For example, if K conditions are referenced in the condition part of A12, K kinds of machine language instruction sequences in FIG. 12 are created. The machine language instruction sequences B12 to H12 show the instruction sequence when the fact (J) shown in FIG. 9 is referred to in the condition part of A12. Hereinafter, the function of the machine language instruction sequence in this case will be briefly described.

First, as described in detail in the above-mentioned document by DHD Warren, the machine language "allocate l" instruction is used to transfer the 1 area of the number of variables included in the condition part of A12 to the control area G6 of FIG. Secure and store control information. Next B12
In holds modified facts attribute values and time tag to V _{i (i} = 1~w) above that the T-tag variable region, respectively. Fid is also used to find out if the identity of the changed fact is fid. "Ge used at this time
The “t-constant” instruction and the “get-variable” instruction are as described in the above-mentioned document.In the next C12, assignment of attribute values to variables in a machine language instruction sequence corresponding to the conditional part of A12 And a machine language instruction sequence corresponding to a comparison between the assigned value and another attribute value, etc. The following D12 is a machine language instruction sequence that plays an important role in the present invention, and B12 to C12 are work areas.
While processing is performed using G4 and control area G6, D12 transfers the value of register H indicating the top address of G4 to temporary holding register SH, and a "move H, SH" instruction and solution information holding area. The "move K, H" instruction transfers the value of the register K indicating the top address of the register K to the register H. This means that the solution information generated in the following E12 to F12 is generated not in the work area G4 but in the solution information holding area G5. That is, the "put-list" and "unify-value" instructions used in E12 and F12 are described in the above-mentioned document by DHD Warren by the register H and the list data and variable values indicated by the operands of each instruction. In order to generate the solution information at the specified location, the register H is changed in D12 to indicate the top address of the solution information holding area, and the solution information is generated in the solution information holding area G5 by the above instruction.

In the next E12, a list pointer indicating the top address of the solution information holding area G5 is written into the register A1 by "put
-List "instruction and an" unify-value "instruction for writing a variable VV _i (i = 1 to p) into the solution information holding area. In the next F12, register A
2, a "put-list" instruction for writing a list pointer indicating the top address of the solution information holding area G5 and a time tag T-tagi (i = 1 to q) of a fact satisfying the condition of C12 are written to the solution information holding area. It consists of an "unify-value" instruction. Thereby, the time tag information, which is a part of the solution information, can be written to the solution information holding area. Next G1
In step 2, since the processing for generating the solution information in the solution information holding area is completed, the processing instruction add for registering the generated variable information list V-list and time tag list T-list in the rule management table RCT as shown in FIG. Execute -cs. Here, rid is a number for uniquely determining a rule.

In addition, V-list (i = 1 to r) and T-list (i =
1 to r) mean solution information lists already registered in the rid entry of the RCT. Newly generated solution information V-li
The st, T-list is the contents of the rid entry of the RCT to the pointer cell (location indicated by the register H) of the solution information newly added by the add-cs instruction as shown in FIG. Write a certain rid-pr, then use rid-pr
To the register K. As a result, new solution information can be registered in the rule management table and the entry of rid. This processing is performed by using the add
This is shown in the processing flow of the -cs instruction. H12 in Fig. 12
Then, processing for returning the register H from the solution information holding area to the work area is performed. That is, the contents of the register H are transferred to the register K, and the contents of the next register SH and the register H are transferred.
Then, in the subsequent processing, the register H operates the work area. Next “deallocate”
And the "fail" instruction perform control to release the control information and the variable area from the area under control as described in the above-mentioned document by DHD Warren, and to forcibly generate a backtrack. As a result, the solution information can be stored in the solution information holding area which is not affected by the backtrack (that is, is not released even by the backtrack). Since another rule and condition part can be executed one after another, all the solution information can be efficiently stored in the solution information holding area. Further, in the present invention, as shown by D12 and H12, the work area and the solution information holding area can be switched by simple control, and the solution information is generated in the work area as shown by E12 and F12, and thereafter, Instead of copying to the solution information area,
The feature is that it can be directly generated in the solution information holding area. Also, as shown in FIG. 14, newly generated solution information can be registered in the rule management table by means of J100 and J200 using the registers K and H. Note that the conflict set is generated in the solution information holding area G5 as described with reference to FIG. Therefore, it is managed by the rule management table RCT. The time tag information is used to preferentially select a rule that is established based on the latest fact and execute an execution unit of the rule.

The above is the contents of the processing to be performed according to FIG. 7 I20 and I21. That is, in I20, the condition part of the rule is
To the machine language instruction sequence of C12.
This is a processing program for converting into a machine language instruction sequence of D12 to H12.

As a result, it becomes possible to execute a rule having a condition referring to the changed fact, and efficiently hold all the solution information in the solution information holding area. This means that the pattern matching process of F1 in FIG. 4 has been completed. Next, it is necessary to determine one rule to be executed by the conflict resolution processing of F2. However, since this processing is not directly related to the present invention, here, the rid number for uniquely specifying the rule is used. The solution information ((VV1, ..., VV
It is assumed that p) and T-list) are selected from the solution information holding area. If there is no solution information in the solution information holding area, all inference processing has been completed.

Here, the data structure stored in the work area G4 and the solution information holding area G5 will be described using a specific example.

The data stored in the work area G4 will be described using the fact shown in FIG. 9 and B12 and C12 in FIG. It is assumed that the fact in FIG. 9 is Fact: Value 1 = 1.5, Value 2 = 2.5, and C12 in FIG. 12 is greater-than2.0> A3 + A4, and B12 in FIG. The real number 1.5) and the contents of A4 (real number 2.5) are stored in the variable areas V1 and V2. First
At C12 in FIG. 2, a value 4.0 obtained by adding A3 and A4 is generated in the work area G4. This result register H points to the position shown in FIG. Next, since the condition is not satisfied by comparing 4.0 with the constant 2.0, the value of the register H is changed again to the previous value of H shown in FIG. Thus, data exceeding the 4-byte length is stored in the work area G4. On the other hand, as for the structure of the data stored in the solution information holding area G5, the data structure of FIG. 25 is generated by executing the instruction sequences E12 and F12 of FIG. In the present embodiment, this data structure is simply referred to as ((VV1, VV2,... VVp), (Ttag1, Ttag2,.
q)). Further, by executing the instruction of G12, the last address rid-pr of the above data structure is written (J100 in FIG. 14), and rid-pr is the solution information of this rule as shown in FIG. Address. as a result,
The above data structure is ((VV1, VV2, ..., VVp), (Ttag1,
Ttag2, ..., Ttagq), rid-pr).

As for the solution information adding process, the start address (rid-pr) of other solution information is added to the end of the data structure generated as described above (at the location specified by the register H) (FIG. 14). J100). Next, the value of the register K indicating the start address of the generated data structure is written to the rule management table CRT (J200). As a result, they are added in the form of a list as shown in FIG.

Next, the execution part processing of the rule shown in FIG. 8 will be described in detail. First, what kind of machine language instruction sequence is converted into a rule execution unit will be described with reference to FIG. In this figure, the execution part of the rule is “modify (X, value = die)”, which is the process of changing the attribute “value” of fact X to die. First, a "get-constant rid, A1" instruction is an instruction for performing a pattern match between the argument register A1 which also holds a rule number and the number rid of this rule. Thus, this rule can be executed only when the rule to be executed is rid.

Next get-list, unify-value VV1, ..., unify-value V
The Vp instruction is an instruction for referring to the variable information VV1,..., VVp in the solution information. That is, the reason that the variable that appears as a variable in the condition part of the rule and also appears in the execution part is stored in the solution information holding area is to be referred to by the execution part. In this example, it is assumed that VVl (1 ≦ l ≦ P) is a variable that stores the fid of the changed fact. The next get-variable A3 command is a command for obtaining time tag information in the solution information. Since it is not necessary here, it is only stored in the argument register A3.
The next read-time-tag VVl, T-tag instruction is an instruction for storing the time tag of the changed fact in the variable T-tag, which will be described in detail with reference to FIG. The following modify-frame-slot instruction:
This is an instruction for changing the value of the attribute number slot-no of the fact VVL to be changed to the value and updating the time tag. The next fr-rule VVl, list-pointer instruction obtains the changed fact from the rule frame table held by the rule referring to the condition part, and stores the list data in the variable list-pointer. It is. That is, if only rules that exist in list-pointer are executed,
Know all the rules that hold under the changed facts. The next cut-cs instruction is a time tag T-ta indicating the fact before the solution information in the solution information holding area is changed.
This is an instruction to check if it has g. That is,
In this instruction, a process of deleting all the solution information having a T-tag in the solution information holding area is performed. Next make-go
al-jump instruction, the argument of the facts has changed VVL, i.e. load each attribute value to the argument register A _i, processing for sequentially executing the machine language instruction sequence for the condition part of the rule that refer to that fact I do. That is, the pattern matching process of the condition part of the rule is called. As described above, the present invention is characterized in that, as described above, the compile method can efficiently obtain solution information.

Hereinafter, "read-time-tag" will be described with reference to FIG. First, in A16, FT-top indicating the top address of the fact management table in FIG. 11 and ft-p from VVl indicating the fid of the fact are shown.
Find r. This ft-pr is composed of four information 1hs shown in FIG.
-Tbl-adr, n-slot, fid, address indicating the top of fact-pr. In B16, processing is performed to substitute the contents of the table obtained by adding 3 to ft-pr, that is, the address indicating the actual machine language instruction sequence, into fact-pr. Next C16
In order to load the value of the time-tag in FIG. 11 into the T-tag, the contents of the address fact-pr + α + γ obtained by adding the ossets of the instruction size α and the operand size γ are stored in the T-tag.
Loading to tag. This means that the time tag has been loaded into the variable T-tag.

FIG. 17 shows the flow of the modify-frame-slot instruction. In A17, FT-top and VVl use the f
Information area address ft-top for id is required.
In the next B17, the address fact-pr to the actual machine language instruction sequence
Seeking. In C17, the top address wk of the machine language instruction having the attribute to be changed is obtained using the attribute number slot-no and the instruction size α. In the next D17, the value of the instruction to be changed is written to the operand of the machine language instruction, that is, the attribute value address. In the next E17, since the fact has been changed, the time tag is updated. Write the contents of the global-time-tag holding the latest time tag uniquely to the address of the time tag, fact-pr + α + γ, and in the next F17, the global-time -Tag value is updated.

Next, before describing the fr-rule instruction, before that, the configuration of a rule frame table that holds, for each fact, a rule that refers to the fact in the condition part of the rule will be described. FIG. 18 shows a rule frame table RET, an FR-top indicating its top address, and a list-pointer indicating a list of rules referencing each fact fid. The rules referred to are linked by numbers rid1 to ridm that can uniquely specify the rule.
In this example, the fact that fid appears in m rule condition parts from rid1 large 1 to ridm. With the above preparation, the fr-rule instruction will be described with reference to FIG.

In A19, using the top address FR-top of the rule frame table and VVl indicating the fact fid, the list address of the rule that refers to the fact in the condition part is listed.
Loading to -pointr.

Next, the solution information deletion distance (cut-cs command) will be described with reference to FIGS. 20 and 21. FIG.

In A20, list-pointe in rule frame table RFT
Substitute the rule id specified by r into rid. This allows
A rule referring to the changed fid can be set to rid. In B20, the content of the address next to the list-pointer, that is, the address of another rule
Assign to er. At C20, 1 is substituted for a variable j. This is F
This is set for reference at 20. In D20, a value obtained by adding the start address Rid-top and rid of the rule management table RCT is substituted for rid-pr. rid-pr indicates an entry address of the rule management table RCT. In E20, a value obtained by adding 1 to the contents of the rule management table RCT is substituted for T-listj. As a result, T-listj holds the address of the time tag list T-list. Next, at F20, cut-
It is determined whether the T-tag specified by cs is included in the list T-list, and if it is, it is deleted. Ga20
Then, the next solution information list address is obtained from T-listj after the process of F20 is completed, and is substituted into r-pr. At G20, determine whether there is any other solution information, and if not, at H20,
Determine if another rid exists. Conversely, if it exists, l
At a20, the next rule id address rid-pr is obtained, j is added at l20, and E20 is executed again.

FIG. 21 is a flowchart of the T-listj processing (F20) in FIG. In A21, the head element of the time tag list designated by T-listj is substituted for t-tag. In B21, the specified T-tag and t-tag are compared and if they match, C2
Execute 1 and if they do not match, execute F21. C21
Indicates that a matching t-tag was obtained by substituting 0 into j. In F21, it is determined whether all the elements of the time tag list have been checked. If it is correct, Ha21 is executed, and if it is not correct, G21 is executed. In Ha21, j is determined to be 0, and if it is 0, it means that the T-tag was not in the time tag list, and the processing ends without deleting. On the other hand, if it is not 0, the deletion process is executed at H21. That is,
The pointer (T-listj + 2) to the next solution information is rid-pr
The solution information is deleted by storing the information at the address specified in step (1).

Thus, the T-listj process ends. For reference, 22nd
The figure shows a list configuration example of T-listj. in this way,
T-listj itself has been described as having a list structure.

FIG. 23 shows an operation code (FIG. 12) for the condition part of the rule in order to obtain solution information again under the changed fact.
Make-goal-ju machine instruction for executing the following
It is a flow of an mp instruction.

First, in A22, the information address fid-pr relating to the fact is obtained from the top address FT-top of the fact management table in FIG. Next B22
Then, the actual machine language instruction string address is loaded into the variable fact-Pr. In C22, each attribute value is stored in the argument register Al (l = 1 to n
−slot) to load zero into variable l. In the next D22, the operand of each machine language instruction, that is, the attribute value is loaded into the argument register Al. Here, α is the machine instruction size, and γ is the offset up to its operand. At E22, the variable 1 is counted up, and at next F22, (fact-Pr + 1), that is, n-slot
It is checking whether only 1 has been counted up. Thereby, all attribute values are stored in the argument register Al (l = 1 to n-slo).
t) can be loaded. If no, repeat D22. If yes, then at G22 (fid-P
r), that is, the address of the table that holds the address of the machine instruction sequence in the condition part of the rule is set to the variable 1hs-tbl-adr
And finally branch to the instruction sequence at the address indicated by the operand in the execute instruction at H22.

Thus, the first argument register A1 always holds fid, the second argument register A2 holds the time tag of the fact, and the argument registers after 3:00 hold the attribute value of the fact, Consistency with the machine language instruction sequence for the condition part of the rule in FIG. 12 can be obtained. Although not described in detail in the present invention, immediately before the machine language instruction code for each conditional part in FIG. 11, an instruction for creating control information shown in a document by DHDWarren in an instruction sequence. tr
Immediately before the y-me-else instruction, the retry-me-else instruction, and the machine instruction sequence in the last conditional part, trust-me-fail
It is assumed that an instruction has been generated. The fail instruction and three control instructions added to the end of the converted machine language instruction sequence are repeatedly executed together with the execute instruction. As a result,
It is possible to directly generate all the solution information satisfying the condition part of the rule in the solution information holding area while generating a backtrack one after another.

Finally, the flow of FIG. 1 showing the means for generating the most important machine language instruction sequence of FIG. 12 in this embodiment will be described.

First, in A1, it is checked whether or not a machine language instruction sequence has been generated for only the types of facts referred to in the condition part of the rule. If it has been generated, the process ends. In B1, the number of attributes of the fact being referred to is assigned to a variable l, and an allocate l instruction is generated in the pair C1. Next, it is determined whether the fact referred to in D1 is expressed as a variable or the fact name is specified.
get-variable Fid, A1 instruction and get-variable T-tag, A2
Generate instructions. On the other hand, if it is not a variable, the get-constant fid, A1 instruction and g
Generate an et-variable T-tag, A2 instruction. Next, in G1, the number of actual attributes K is get-variable Vi, A _{i + 2} (i = 1 to
K) Generate an instruction, and generate a machine instruction sequence for the condition part of the rule at H1. In the next I1, an instruction to switch from the work area to the solution information holding area is generated by switching the register H from G4 to G5 in FIG. Next J1
And K1, respectively, generate a machine language instruction sequence for generating variable information and time tag information in the solution information holding area,
In the next L1, an instruction for registering the newly generated solution information in the rid is generated. Finally, in M1, a move H, K instruction and a move SH, H instruction are generated to switch from the solution information holding area to the work area, and a deallocate instruction and a fail instruction for forcibly generating a backtrack are generated. next
Execute A1 repeatedly.

〔The invention's effect〕

According to the present invention, the process of obtaining all the solution sets with the heaviest loads in inference can be performed at high speed, so that the inference speed of an expert system or the like can be greatly improved. In other words, by expressing facts as machine language rather than data, pattern matching with facts becomes possible at high speed, all solution information for the condition part of the rule is obtained at high speed, and another rule is successively added. Can be significantly faster than most conventional inference engines have interpreted rules.

[Brief description of the drawings]

FIG. 1 shows a means for generating a machine language instruction sequence for efficiently obtaining all solution information, which is one means of the present invention. FIG. 2 is an example of an inference sole program before being converted by the means of the present invention. FIG. 3 shows the execution. FIG. 4 shows a general inference mechanism. FIG. 5 shows a computer and a storage device necessary for executing the present invention. FIG. 6 to FIG. 23 are diagrams detailing one embodiment of the present invention. FIG. 24 is an explanatory diagram of the data structure stored in the work area in the present embodiment. FIG. 25 is an explanatory diagram of the data structure stored in the solution information holding area in the present embodiment. I1 ... Process to change from work area to solution information holding area, J1 to L1 ... Process to generate and register new solution information in solution information holding area, M1 ... Change from solution information holding area to work area and Processing to generate a machine language instruction sequence for forcibly generating a backtrack.

 ──────────────────────────────────────────────────続 き Continued on the front page (72) Inventor Tadaaki Bando 4026 Kuji-cho, Hitachi City, Ibaraki Prefecture Inside Hitachi, Ltd. Hitachi Research Laboratory, Ltd. (72) Inventor Toshihiko Nakano 5-2-1 Omika-cho, Hitachi City, Ibaraki Prefecture Co., Ltd. (72) Inventor Toshihiro Hayashi 5-2-1, Omika-cho, Hitachi City, Ibaraki Prefecture In-house Omika Plant, Hitachi, Ltd.

Claims (1)

(57) [Claims] 1. A computer for executing a program stored in a storage unit, and a program for converting a knowledge base composed of knowledge of facts and rules into machine language instructions to be executed by the computer. An inference method in an inference system that performs inference by executing a set of machine language instruction sequences, wherein the program stores facts and an instruction portion of a machine language instruction that performs pattern matching with a value stored in a register. When converting a code area and a machine language instruction string having a machine language instruction having an operand area for storing an operand of the machine language instruction corresponding to a value of a fact, A command for securing an area for holding a value of a variable to be used as a first area in a work area provided in the storage unit; And a branch instruction for calling a machine instruction sequence converted from the fact after setting a value in a predetermined register, and a predetermined second in the storage unit in which the information is retained even when the backtracking is performed on the solution set. An instruction to be generated in an area, a branch instruction to a machine language instruction string to be converted from an execution part of a rule, and the first area is set to an unused state when a condition defined in a condition part of the rule is satisfied. After that, it is converted into a machine language instruction sequence having an instruction to perform backtracking, and the execution part of the rule is one of the solution information generated by executing the machine language instruction sequence in which the condition part of the rule is converted. Is converted into an instruction to execute a solution information selection machine language instruction sequence and a machine language instruction including an instruction to perform an operation defined by the rule execution unit, and perform the operation defined by the rule execution unit. The instruction is executed by the rule execution section. In a case where the defined operation is an operation that changes a fact, it has an operand change machine language instruction sequence consisting of a naming that changes an operand area of the machine language instruction sequence converted from the fact, and the converted machine The inference method of storing a word instruction sequence in a predetermined third area in the storage unit in advance and executing the stored machine instruction sequence comprises: a machine language instruction sequence stored in the third area. When executing the machine language instruction sequence converted from the condition part of the rule,
By executing an instruction to generate a solution set in a predetermined second area of the storage unit in the machine language instruction sequence converted from the condition part of the rule, the solution set obtained at the time of execution is converted to the second set. After generating in the area, perform backtracking to obtain all solution information, execute the solution information selection machine instruction sequence, and use one solution information selected from all the solution information obtained above. A fact change process for updating a fact by executing an operand change machine language instruction sequence of a machine language instruction sequence converted from the fact and changing an operand area; Using a fact management table that associates the identification information with the machine language instruction sequence converted from the condition part of the rule that calls the machine language instruction sequence converted from the fact, changes from the fact changed by the above fact change process. Machine instruction fast inference methods compiled knowledge processing tool, characterized in that it has a process for executing the converted machine language designated column from the condition part of the rule to execute the columns.