JP3945144B2 - Inductive reasoning system - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to an inductive reasoning system, and in particular, for a target concept including one numerical information, a first-order predicate logic that inputs an example that is a sample of the target concept and outputs a rule with priority that describes the target concept. Inductive reasoning system based on
[0002]
[Prior art]
An inductive inference system based on first-order predicate logic. Inductive Logic Programming, proposed by the literature (S. Muggleton. Inductive logic programming. New Generation Computing, 8 (4): 295-318, 1991.) (Hereinafter referred to as ILP) is an example in which a sample of the target concept, background knowledge, and the like are input for the target concept, and a rule that explains the target concept is output.
[0003]
Originally, ILP was created with the intention of learning concepts represented by symbols, but there are many concepts that include numerical information in actual application situations, and learning them well is a big challenge. .
[0004]
In response to this problem, an approach that uses numerical values as symbols (for example, B. Dolsak and S. Muggleton. The application of Inductive Logic Programming to finite element mesh design. In S. Muggleton, editor, Inductive Logic Programming, pages 453- 472. Academic Press, London, 1992.). That is, learning is performed by regarding 1, 2, 3, etc. as simple symbols similar to a, b, c. However, the magnitude relationship between numerical values was not considered. There are other attempts to learn concepts that include numerical information using ILP, but this approach is usually such that only the inequality sign is introduced.
[0005]
Progol is another widely used ILP system. Progol is described in literature (S. Muggleton. Inverse entailment and Progol. New Generation Computing, 13: 245-286, 1995.). For Progol, if you want to form a rule using the numerical information included in the example, a two-argument predicate that represents equality, a two-argument predicate that represents inequality, and the right side is greater than the left side A two-argument predicate that represents and vice versa, and a two-argument predicate that represents that the right-hand side is greater than or equal to the left-hand side, and vice versa.
[0006]
The rule evaluation function used when Progol searches for a rule uses the number of positive examples covered by the rule (which can be derived using the rules), the number of negative examples, and the length of the rule. Yes. For this reason, the numerical information included in the example is not used, and there is a problem that a good rule (that is, a well-described example is well explained or prediction accuracy for an unknown example is high) may not be obtained. It was.
[0007]
[Problems to be solved by the invention]
As described above, in the conventional inductive inference system, it is difficult to learn numerical information, and as a result, the numerical information included in the example is not used and a good rule may not be obtained.
[0008]
Therefore, an object of the present invention is to provide an inductive inference system that can obtain good rules by using numerical information.
[0009]
[Means for Solving the Problems]
In order to achieve the above-described object, the first aspect of the present invention provides a first-order predicate that inputs an example that is a sample of the target concept and outputs a rule that explains the target concept for the target concept including one numerical information. A recursive inference system based on logic, wherein a storage means for storing the example, a node is generated based on the example stored in the storage means, and a standard deviation of a numerical part of the example covered by the generated node is used An inference means for calculating an evaluation value of the node by a predetermined evaluation function, and a rule including an average value of numerical values of examples covered by the node in order of the node having the highest evaluation value calculated by the inference means And an output unit that deletes an example corresponding to the output rule from the storage unit, and the order of output by the output unit is set as the priority order of the rule.
[0013]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, an embodiment of an inductive inference system according to the present invention will be described in detail with reference to the accompanying drawings.
[0014]
FIG. 1 is a block diagram showing a schematic configuration of an inductive inference system.
As shown in the figure, the inductive reasoning system includes an input unit 1, an inductive reasoning unit 2, and an output unit 3.
[0015]
The input unit 1 is a part of the user interface, and inputs examples, mode declarations, background knowledge and the like to the inductive inference unit 2. The inductive reasoning unit 2 performs a top-down search of rules, generates a rule set with a priority order that explains the target concept, and sends the rule set to the output unit 3. The output unit 103 is a part that presents the output from this system to the user.
[0016]
The inductive reasoning unit 2 includes an original example set holding unit 21, an example set holding unit 22, a mode declaration holding unit 23, a background knowledge holding unit 24, and a node buffer 25.
[0017]
The original example set holding unit 21 has a role of holding the example set as it is during the search procedure, and the example set holding unit 22 holds the example set according to the change (decrease) during the search procedure. Have a role.
[0018]
The mode declaration holding unit 23 has a role of holding a mode declaration. The mode declaration is basically the same as that of Progol (modes), and describes the predicates that define the target concept, the predicates used to generate rules, and the input / output relationships of the variables.
[0019]
The background knowledge holding unit 24 has a role of holding background knowledge. The background knowledge is basically the same as that of Progol (background knowledge), which describes the definition of predicates and the specific properties of each example.
[0020]
The node buffer 25 has a role of holding each node of the search tree and includes a row of nodes 26.
[0021]
Here, the node 26 will be described.
FIG. 2 is a diagram showing the node 26.
[0022]
The node 26 is a set of five predicates, f, σ, c, and s. In addition, information about whether or not it has been expanded (described later) is held.
[0023]
A predicate set corresponds to a rule. That is, a rule is created by placing a predicate in a set of predicates on the right side and placing a predicate corresponding to the target concept on the left side. For example, in node 26 of FIG. 2, the predicate set is {important (X)} and the predicate corresponding to the target concept is {mesh (X, N)}, so the corresponding rule is {mesh (X, N) ← important (X)}. Here, the part corresponding to the numerical information in the target concept is replaced with an arbitrary variable (N in this example).
[0024]
f represents the number of examples this node covers at that time. That is, it represents the number of examples in the example set at that time that can be derived by the rule corresponding to the predicate set of this node. In the node 26, the number of examples to cover is eleven. This is an index for the number of examples that support the rule, and the larger the number, the better the rule.
[0025]
σ represents the standard deviation of the numerical value of the numerical part of the example in the original example set covered by this node. For example, if the node 26 covers 11 examples of mesh (a3,8), mesh (a9,3), ..., the numerical value part of the example is 8, 3, 7, 2, 2, 5, 2 , 7, 3, 2, 2 and their standard deviation is 2.386. The reason why the standard deviation is used is that when the standard deviation is small, there is no variation in the numerical value portion of the example to be covered, and it can be considered as a rule that explains the example well.
[0026]
c represents the number of elements in the predicate set of this node. For example, in node 26, there is one predicate set element. c is 1. This is an index representing the length of the rule corresponding to the node, and the smaller the number, the better the rule.
[0027]
Finally, s represents the score of this node, that is, the value of the rule evaluation function. The score s is basically determined using f, σ, and c. The number F of examples in the original example set may be used instead of f. For example, in the node 26, s is −5.842.
[0028]
Next, the operation of the inductive reasoning unit 2 will be described.
FIG. 3 is a flowchart showing the flow of the search procedure of the inductive reasoning unit 2.
[0029]
The inductive reasoning unit 2 first places the example received from the input unit 1 into the original example set holding unit 21 (step 101). Then, this example set is copied, put in the example set holding unit 22 (step 102), and the node buffer 25 is emptied (step 103).
[0030]
Next, a node having the predicate set as an empty set is generated and placed at the head of the node buffer 25 (step 104). At this time, as shown in FIG. 4, the node buffer 25 is in a state where a node 26-0 whose predicate set is an empty set (Empty) is placed at the head.
[0031]
Subsequently, the node buffer 25 is examined in order from the top, nodes that have not been expanded are expanded by the expansion procedure, and the obtained nodes are added to the node buffer 25 (step 105). At this time, the node buffer 25 is always arranged in descending order of the score s. Nodes having the same score s may be arranged in an arbitrary order.
[0032]
The expansion procedure here is the same as that of Progol (refinement operator), and only the outline will be described.
The expansion procedure outputs all of the predicate sets obtained by performing any one of the following operations on the predicate set of the original node (26 etc.).
1. Add one predicate specified in the mode declaration.
2. Make two variables with different names in the predicate set the same.
3. Replace a variable in the predicate set with a constant.
[0033]
This expansion procedure is repeated until the number of nodes exceeding the number specified by the user in advance (for example, 100) is added to the node buffer 25 (NO in step 106). When the number of nodes exceeding the number specified by the user (for example, 100 here) is added (YES in step 106), the expansion procedure is terminated. As shown in FIG. 5, the state of the node buffer 26 when the expansion procedure is completed is a state in which 100 or more nodes such as the nodes 26-1 to 26-8 are held (due to the expansion procedure). Because there may be more than 100).
[0034]
Next, the node buffer 25 is examined from the beginning, and a rule is generated by an output procedure with a node 26 (a node that covers some example) whose f is not 0 as an output, and is sent to the output unit 3. (Step 107). Note that the previous node with f = 0 is simply discarded. As shown in FIG. 6, the state of the node buffer 26 when the output procedure is completed is a state in which the node 26-1 is output (compared to the case of FIG. 5).
[0035]
The output procedure is a procedure that generates a rule from a node. First, a predicate in the node's predicate set is placed on the right side, and the average value of the numerical part of the example covered by the node is entered in the argument part representing the numerical information. A predicate representing a concept is placed on the left side. At this time, if the user specifies that the numerical information is an integer, the average value is rounded off and replaced with an integer.
[0036]
Subsequently, the example covered by the node output in the output procedure is taken out from the example set holding unit 22 (step 108). If the example set held in the example set holding unit 22 becomes empty (YES in step 109), the procedure ends.
[0037]
On the other hand, if the example set held in the example set holding unit 22 is not empty (NO in step 109), the node buffer 25 is checked, and a node whose f is 0 does not have any example even if it is further expanded. Since there is no possibility of covering, all are removed (step 110), the process returns to step 105, and the same processing is repeated.
[0038]
Note that the search procedure always ends at any time because at least one example is taken from the example set each time it loops, and a node whose predicate set is empty covers all examples. I can say that.
[0039]
By the way, the rules obtained by this inductive reasoning system have a priority order. In other words, since the score that is the evaluation function is higher in the rule that is output first, it is treated as a rule with higher priority. In the conventional inductive inference system such as Progol, the set of rules to be output has no priority order between the rules, and is treated as having the same level. When predicting, the derivation is attempted by applying the rules in descending order of priority.
[0040]
Also, when using the rules obtained by this inductive inference system, if the derivation is successful with one rule, the rule with lower priority than that is not used. That is, “only one answer as a numerical value appears” is executed. Incidentally, in the prior art, there are cases where derivation is possible with some rules for one example, that is, “two or more numerical answers are given”.
[0041]
Next, a specific example of the operation of this inductive inference system is shown.
[0042]
Here, the above-mentioned literature (B. Dolsak and S. Muggleton. The application of Inductive Logic Programming to finite element mesh design. In S. Muggleton, editor, Inductive Logic Programming, pages 453-472. Academic Press, London, 1992. ) And the same example. This is not a “toy dataset” created for so-called learning research, but a dataset used in the real world. Here, mesh (X, N) is used as the learning predicate in order to acquire rules for generating a desired mesh from the structure using data of a good mesh example. Here, X is an edge ID, and N is the number of divisions of the edge (the number of elements existing along the edge). Here, the target concept mesh includes numerical information (N). N is an integer.
[0043]
Here, the score s of the node 26 is determined by s = F / 75−10σ × σ−0.05c.
[0044]
First, examples, mode declarations, and background knowledge are input to the inductive reasoning unit 2. Here, the following 75 examples are input.
[0045]
mesh (a2, 1).
mesh (a3, 8).
mesh (a4, 1).
mesh (a5, 1).
mesh (a6, 2).
mesh (a7, 1).
mesh (a8, 1).
mesh (a9, 3).
mesh (a10, 1).
mesh (a11, 3).
mesh (a12, 1).
mesh (a13, 1).
mesh (a14, 1).
mesh (a15, 4).
mesh (a16, 1).
mesh (a17, 2).
mesh (a18, 1).
mesh (a19, 4).
mesh (a20, 1).
mesh (a21, 1).
mesh (a22, 2).
mesh (a23, 2).
mesh (a24, 1).
mesh (a25, 2).
mesh (a26, 1).
mesh (a27, 1).
mesh (a28, 2).
mesh (a29, 1).
mesh (a30, 1).
mesh (a31, 3).
mesh (a32, 2).
mesh (a33, 2).
mesh (a35, 1).
mesh (a36, 12).
mesh (a37, 12).
mesh (a38, 12).
mesh (a39, 5).
mesh (a40, 2).
mesh (a41, 1).
mesh (a42, 5).
mesh (b1, 9).
mesh (b2, 1).
mesh (b3, 2).
mesh (b4, 7).
mesh (b5, 1).
mesh (b6, 1).
mesh (b7, 1).
mesh (b8, 9).
mesh (b9, 1).
mesh (b10, 2).
mesh (b11, 7).
mesh (b12, 1).
mesh (b13, 1).
mesh (b14, 1).
mesh (c1, 1).
mesh (c2, 2).
mesh (c3, 1).
mesh (c4, 1).
mesh (c5, 3).
mesh (c6, 2).
mesh (c7, 2).
mesh (c8, 3).
mesh (c9, 1).
mesh (c10, 2).
mesh (c11, 1).
mesh (c12, 2).
mesh (c13, 1).
mesh (c14, 2).
mesh (c15, 8).
mesh (c16, 8).
mesh (c17, 8).
mesh (c18, 8).
mesh (c19, 8).
mesh (c20, 8).
mesh (c21, 8).
[0046]
The mode declaration is entered as follows: Here, it is shown in the same grammatical form as Progol.
[0047]
:-modeh (1, mesh (+ edge, + nums))?
:-modeh (1, mesh (+ edge, # nums))?
:-modeb (1, important_long (+ edge))?
:-modeb (1, important (+ edge))?
:-modeb (1, important_short (+ edge))?
:-modeb (1, circuit (+ edge))?
:-modeb (1, half_circuit (+ edge))?
:-modeb (1, short_for_hole (+ edge))?
:-modeb (1, long_for_hole (+ edge))?
:-modeb (1, circuit_hole (+ edge))?
:-modeb (1, half_circuit_hole (+ edge))?
:-modeb (1, not_important (+ edge))?
:-modeb (1, free (+ edge))?
:-modeb (1, one_side_fixed (+ edge))?
:-modeb (1, two_side_fixed (+ edge))?
:-modeb (1, fixed (+ edge))?
:-modeb (1, not_loaded (+ edge))?
:-modeb (1, one_side_loaded (+ edge))?
:-modeb (1, cont_loaded (+ edge))?
:-modeb (*, neighbour_xy (+ edge, -edge))?
:-modeb (*, neighbour_yz (+ edge, -edge))?
:-modeb (*, neighbour_zx (+ edge, -edge))?
:-modeb (2, opposite (+ edge, -edge))?
:-modeb (2, same (+ edge, -edge))?
[0048]
Here, modeh specifies a predicate that defines the target concept. modeb specifies a predicate that creates the right side of the rule used to generate the rule. + edge and -edge specify that they are input variables and output variables, respectively.
[0049]
The following is input as background knowledge. These are the same as those described in the literature. However, only the predicate name is changed for the two-argument predicate.
[0050]
important_long (a1).
important_long (a34).
important_long (b1).
important_long (b8).
important (a3).
important_short (a9).
important_short (a11).
important_short (a13).
important_short (a15).
important_short (a19).
important_short (a22).
important_short (a23).
important (a39).
important (b4).
important (b11).
important (c2).
important (c5).
important (c6).
circuit (c18).
circuit (c19).
circuit (c20).
half_circuit (a36).
half_circuit (a37).
important (c8).
important (c10).
important (c12).
important (c14).
important_short (a6).
not_important (a12).
not_important (a14).
not_important (a20).
not_important (a21).
not_important (a24).
not_important (a27).
not_important (a29).
important_short (a25).
important_short (a26).
important_short (a28).
important_short (a31).
important_short (a33).
important_short (a35).
important_short (a40).
important_short (b3).
important_short (b10).
important_short (c4).
important_short (c7).
important_short (c13).
circuit (c15).
circuit (c16).
circuit (c17).
short_for_hole (a16).
short_for_hole (a18).
long_for_hole (a17).
circuit_hole (c21).
half_circuit_hole (a38).
half_circuit_hole (a42).
not_important (a2).
not_important (a4).
not_important (a5).
not_important (a7).
not_important (a8).
not_important (a10).
not_important (a30).
not_important (a32).
not_important (a41).
not_important (b2).
not_important (b5).
not_important (b6).
not_important (b7).
not_important (b9).
not_important (b12).
not_important (b13).
not_important (b14).
not_important (c1).
not_important (c3).
not_important (c9).
not_important (c11).
free (a39).
free (a40).
free (b2).
free (b3).
free (b7).
free (b9).
free (b10).
free (b14).
free (c6).
free (c7).
free (c11).
free (c12).
free (c13).
free (c17).
free (c18).
one_side_fixed (a34).
fixed (a13).
fixed (a14).
fixed (a15).
fixed (a16).
fixed (a17).
fixed (a18).
fixed (a19).
fixed (a20).
fixed (a21).
fixed (a22).
one_side_fixed (a35).
one_side_fixed (a41).
one_side_fixed (b1).
one_side_fixed (b4).
one_side_fixed (b8).
one_side_fixed (b11).
one_side_fixed (c2).
one_side_fixed (c3).
one_side_fixed (c5).
one_side_fixed (c8).
one_side_fixed (c10).
one_side_fixed (c14).
two_side_fixed (a36).
two_side_fixed (a37).
two_side_fixed (a38).
two_side_fixed (a42).
fixed (a23).
fixed (a24).
fixed (a25).
fixed (a26).
fixed (a27).
fixed (a28).
fixed (a29).
fixed (a30).
fixed (a31).
fixed (a32).
two_side_fixed (b5).
two_side_fixed (b6).
two_side_fixed (b12).
two_side_fixed (b13).
fixed (a1).
fixed (a2).
fixed (a3).
fixed (a4).
fixed (a5).
fixed (a6).
fixed (a7).
fixed (a8).
fixed (a9).
fixed (a10).
fixed (a11).
fixed (a12).
fixed (a33).
fixed (c1).
fixed (c4).
fixed (c9).
fixed (c15).
fixed (c16).
fixed (c19).
fixed (c20).
fixed (c21).
not_loaded (a1).
not_loaded (a2).
not_loaded (a3).
not_loaded (a4).
not_loaded (a5).
not_loaded (a6).
not_loaded (a7).
not_loaded (a23).
not_loaded (a24).
not_loaded (a25).
not_loaded (a26).
not_loaded (a27).
not_loaded (a28).
not_loaded (a29).
not_loaded (a33).
not_loaded (a36).
not_loaded (a42).
not_loaded (b1).
not_loaded (b2).
not_loaded (b5).
not_loaded (b6).
not_loaded (b7).
not_loaded (b8).
not_loaded (b9).
not_loaded (b12).
not_loaded (b13).
not_loaded (b14).
not_loaded (c1).
not_loaded (c2).
not_loaded (c3).
not_loaded (c4).
not_loaded (c5).
not_loaded (c6).
not_loaded (c7).
not_loaded (c8).
not_loaded (c9).
not_loaded (c15).
not_loaded (c20).
not_loaded (c21).
one_side_loaded (a34).
one_side_loaded (a35).
one_side_loaded (a40).
one_side_loaded (a41).
one_side_loaded (b3).
one_side_loaded (b4).
one_side_loaded (b10).
one_side_loaded (b11).
cont_loaded (a8).
cont_loaded (a9).
cont_loaded (a10).
cont_loaded (a11).
cont_loaded (a12).
cont_loaded (a13).
cont_loaded (a14).
cont_loaded (a15).
cont_loaded (a16).
cont_loaded (a17).
cont_loaded (a18).
cont_loaded (a19).
cont_loaded (a20).
cont_loaded (a21).
cont_loaded (a22).
cont_loaded (a30).
cont_loaded (a31).
cont_loaded (a32).
cont_loaded (a37).
cont_loaded (a38).
cont_loaded (a39).
cont_loaded (c10).
cont_loaded (c11).
cont_loaded (c12).
cont_loaded (c13).
cont_loaded (c14).
cont_loaded (c16).
cont_loaded (c17).
cont_loaded (c18).
cont_loaded (c19).
neighbour_xy (a34, a35).
neighbour_xy (a35, a26).
neighbour_xy (a26, a36).
neighbour_xy (a36, a4).
neighbour_xy (a4, a34).
neighbor_xy (b1, b13).
neighbour_xy (b13, b8).
neighbour_xy (b8, b7).
neighbour_xy (b7, b1).
neighbour_xy (b4, b6).
neighbour_xy (b6, b11).
neighbour_xy (b10, b14).
neighbour_xy (b14, b3).
neighbour_xy (c15, c9).
neighbor_xy (c16, c9).
neighbour_xy (c17, c11).
neighbour_xy (c12, c17).
neighbour_yz (c20, c2).
neighbour_yz (c21, c4).
neighbour_zx (a1, a2).
neighbour_zx (a2, a3).
neighbour_zx (a3, a4).
neighbour_zx (a4, a5).
neighbour_zx (a5, a6).
neighbour_zx (a6, a7).
neighbour_zx (a7, a8).
neighbour_zx (a8, a9).
neighbour_zx (a9, a10).
neighbour_zx (a10, a11).
neighbour_zx (a11, a12).
neighbour_zx (a12, a13).
neighbour_zx (a13, a14).
neighbour_zx (a14, a15).
neighbour_zx (b5, b1).
neighbour_zx (b8, b9).
neighbour_zx (b9, b10).
neighbour_zx (b10, b11).
neighbour_zx (b11, b12).
neighbour_zx (b12, b8).
neighbour_zx (c1, c2).
neighbour_zx (c2, c3).
neighbour_zx (c3, c4).
neighbour_zx (c4, c5).
neighbour_zx (c5, c6).
neighbour_zx (c6, c7).
neighbour_zx (c7, c8).
neighbour_zx (c8, c9).
neighbour_zx (c9, c10).
neighbour_zx (c10, c11).
neighbour_zx (c11, c12).
neighbour_xy (c18, c12).
neighbour_xy (c13, c18).
neighbour_xy (c19, c1).
neighbour_xy (c20, c1).
neighbour_xy (c21, c3).
neighbour_yz (a39, a41).
neighbour_yz (a40, a39).
neighbour_yz (a35, a40).
neighbour_yz (a25, a35).
neighbour_yz (a42, a25).
neighbour_yz (a24, a42).
neighbour_yz (b5, b6).
neighbour_yz (b6, b12).
neighbour_yz (b12, b13).
neighbour_yz (b13, b5).
neighbour_yz (b2, b7).
neighbour_yz (b7, b9).
neighbour_yz (b9, b14).
neighbour_yz (b14, b2).
neighbour_yz (c15, c8).
neighbour_yz (c16, c10).
neighbour_yz (c19, c14).
opposite (b11, b8).
opposite (c6, c12).
opposite (c2, c14).
opposite (c10, c14).
opposite (c15, c16).
opposite (c16, c17).
opposite (c17, c18).
opposite (c18, c19).
opposite (c19, c20).
opposite (c20, c21).
neighbour_zx (a15, a16).
neighbour_zx (a16, a17).
neighbour_zx (a17, a18).
neighbour_zx (a18, a19).
neighbour_zx (a19, a20).
neighbour_zx (a20, a21).
neighbour_zx (a21, a22).
neighbour_zx (a22, a23).
neighbour_zx (a23, a24).
neighbour_zx (a24, a1).
neighbour_zx (a25, a26).
neighbour_zx (a26, a27).
neighbour_zx (a27, a28).
neighbour_zx (a28, a29).
neighbour_zx (a29, a30).
neighbour_zx (a30, a31).
neighbour_zx (a31, a32).
neighbour_zx (a32, a33).
neighbour_zx (a33, a25).
neighbour_zx (b1, b2).
neighbour_zx (b2, b3).
neighbour_zx (b3, b4).
neighbour_zx (b4, b5).
same (a33, a23).
same (a36, a37).
same (a38, a37).
same (a39, a42).
same (b1, b8).
same (c6, c12).
same (c2, c14).
same (c10, c14).
same (c15, c16).
same (c16, c17).
neighbour_zx (c12, c13).
neighbour_zx (c13, c14).
neighbour_zx (c14, c1).
opposite (a11, a3).
opposite (a9, a3).
opposite (a31, a25).
opposite (a13, a1).
opposite (a15, a1).
opposite (a17, a1).
opposite (a19, a1).
opposite (a22, a1).
opposite (a23, a1).
opposite (a32, a22).
opposite (a33, a23).
opposite (a34, a37).
opposite (a36, a37).
opposite (a38, a37).
opposite (a39, a42).
opposite (b1, b8).
opposite (b3, b1).
opposite (b4, b1).
opposite (b10, b8).
same (c17, c18).
same (c18, c19).
same (c19, c20).
same (c20, c21).
[0051]
Next, the search procedure is entered.
First, as preparation, first, the example received from the input unit 1 is put into the original example set holding unit 21 (step 201). This example set is copied, put in the example set holding unit (step 102), and the node buffer 25 is emptied (step 103).
[0052]
Next, a node having the predicate set as an empty set is generated and placed at the head of the node buffer 25 (step 104). At this time, the node buffer 25 is in a state as shown in FIG. Since the predicate set of node 26-0 is an empty set, all examples are covered. Since 75 examples are included here, f is 75.
[0053]
Subsequently, the expansion procedure of step 103 is entered, but the first node 26-0 of the node buffer 25 is unexpanded and is expanded by the expansion procedure, and the obtained node 26-1 is added to the node buffer. In the expansion procedure, since the element is an empty set, only one predicate specified in the mode declaration is added.
[0054]
Since the number of nodes does not reach the parameter (100) designated by the user in one expansion, the expansion is further repeated here. In this expansion procedure, for example, by adding one predicate from the node {important (X)}, a node of c = 2 such as the node {important (X), one_side_loaded (X)} is also obtained. If the number of nodes exceeds the parameter (100) designated by the user (YES in step 106), the expansion procedure is terminated. The state of the node buffer 25 at this time is shown in FIG.
[0055]
Next, the output procedure of step 107 is entered. In this case, the node buffer 25 is examined from the beginning. However, since f of the first node 26-1 in FIG. 5 is not 0, the output procedure is called using this as an output.
[0056]
The output procedure generates a rule from the node 26-1.
First, the predicate not_important (X) of {not_important (X)} in the predicate set of the node 26-1 is placed on the right side. Next, the average value of the numerical values in the example covered by the node 26-1 is obtained. Here, the example covered by the node 26-1 is 21 (mesh (a2,1), mesh (a4,1), ...), and the numerical part is 1,1,1, ... The average of these is 1.048.
[0057]
At this time, since the numerical information is specified to be an integer, the average value is rounded off and replaced with the integer 1. In the end, the predicate placed on the left side is mesh (X, 1), and the output procedure generates the rule mesh (X, 1) ← not_important (X).
[0058]
Since the node 26-1 is removed (step 107), the node buffer 25 is in the state shown in FIG.
[0059]
Next, 21 examples covered by the node 26-1 are taken out from the example set holding unit 21 (step 108). Since the example set is not empty (NO in step 109), the process proceeds to step 110.
[0060]
Here, the node buffer 25 is examined, and the node where f is 0 is removed (step 110). Thereafter, the process returns to step 105.
[0061]
Next, step 105 is entered again.
Similarly, the node buffer 25 is examined in order from the top, nodes that have not been expanded are expanded by the expansion procedure, and the obtained nodes are added to the node buffer 25 (step 105). This process is repeated (NO in step 106), and when more than 100 nodes are added, this step is terminated (YES in step 106).
[0062]
Next, the output procedure is entered. In this example, the node buffer 25 is checked from the beginning. Since f of the first node 26-1 in FIG. 6 is not 0, the output procedure is called using this as an output.
[0063]
The output procedure generates mesh (X, 8) ← circuit (X). By the same method as before (step 107). Also, the node 26-2 is removed.
[0064]
Subsequently, the six examples covered by the node 26-2 are taken out from the example set holding unit 21 (step 108). Since the example set is not empty (NO in step 109), the process proceeds to the next, and in the same manner, the loop is repeated until the example set becomes empty, and the rules are output. If the example set becomes empty (YES in step 109), the procedure ends.
[0065]
The output priority rules are as follows. The higher the priority, the higher the priority.
[0066]
mesh (X, 1) ← not_important (X).
mesh (X, 8) ← circuit (X).
mesh (X, 9) ← important_long (X).
mesh (X, 12) ← half_circuit (X).
:
[0067]
Here, when this rule is used, derivation is attempted by applying the rules in descending order of priority. For example, when the number of divisions of the edge a2 is to be obtained, the derivation of the goal ← mesh (a2, N). Is tried in order from the above rule. If the derivation is successful with this rule and the substitution N = 1 is obtained, the number of divisions of the edge a2 is obtained as 1. As described above, derivation based on the subsequent rules is not performed.
[0068]
In this embodiment, the variable not corresponding to the numerical information in the target predicate is indicated by X. However, this is for convenience and any variable symbol may be used. Further, when there are two or more variables that do not correspond to the numerical information in the target predicate, the present system can operate in the same manner. In this case, the target predicate is expressed as target (X, Y, N), for example.
[0069]
【The invention's effect】
As described above, according to the present invention, numerical information in a predicate that is a learning target that has not been conventionally used is treated as a numerical value, and the standard deviation of the numerical value portion of the example in the original example set is used Since it was configured to do so, it was possible to output a rule that well explained the covered example.
[0070]
In fact, the result of the following comparative experiment shows that this has an effect that a better rule (that is, a higher prediction accuracy for an unknown example) can be obtained as compared with the prior art.
[0071]
In the comparative experiment, the example described in the embodiment was used in the system of the present invention. Progol was used as an ILP system that does not use numerical information, and the same examples, mode declarations, and background knowledge were given for comparison. However, in addition to examples (positive examples), Progol was given the same number of negative examples. The negative example was generated by randomly generating an example different from the positive example (for example, mesh (a29,8), mesh (a19,7)). Progol also has the ability to generate rules from positive examples only, but this was not used. That is, the rules obtained by Progol do not have a priority order, so it is possible to derive with several rules for one example, that is, “some answers as numbers”, one of which is correct. This is because the unknown example has been successfully predicted, which is advantageous compared to this system. This effect is offset by including the same number of negative examples.
[0072]
In the experiment, both formulas were cross-validated by leave / 1 (take out one example, learn the rest as a training example, and test for all the examples). As a result, in the system of the present invention, the prediction accuracy was 80.0% and Progol was 73.3%, indicating the superiority of this system. The default parameters were used for Progol.
[0073]
In general, when an unknown example is predicted in learning, depending on the data set, the upper limit is usually about 90% in prediction accuracy in a real-world data set. Considering this point (the difference to the ideal accuracy has been reduced by about half from 16.7 points to 10 points), this prediction accuracy difference of 6.7 points can be said to be a significant performance improvement.
[0074]
Moreover, although the prediction accuracy of 80.0% is obtained in the above-described embodiment, if the algorithm and the evaluation function are improved, the performance is improved to the prediction accuracy of 84.0% although it is a result of examination on the desk. It has been found that it is also possible to achieve this, and when the present invention is implemented, there is an effect that a significant improvement in prediction accuracy can be obtained.
[Brief description of the drawings]
FIG. 1 is a block diagram showing a schematic configuration of an inductive inference system.
FIG. 2 is a diagram showing a node 26;
FIG. 3 is a flowchart showing a flow of a search procedure of the inductive reasoning unit 2;
FIG. 4 is a diagram (1) showing a state of the node buffer 25;
FIG. 5 is a diagram (2) showing a state of the node buffer 25;
FIG. 6 is a diagram (3) showing a state of the node buffer 25;
[Explanation of symbols]
1 Input section
2 Inductive Reasoning Department
3 Output section
21 Original example set holding part
22 Example set holder
23 Mode declaration holding part
24 Background Knowledge Holding Unit
25 Node buffer
26, 26-0 to 26-8 nodes

Claims (1)

An inductive inference system based on first-order predicate logic that inputs an example that is a sample of the target concept for a target concept including one piece of numerical information and outputs a rule that explains the target concept,
Storage means for storing the example;
Inference means for generating a node based on an example stored in the storage means, and calculating an evaluation value of the node by a predetermined evaluation function using a standard deviation of a numerical part of an example covered by the generated node; ,
An output means for outputting a rule including an average value of numerical values of an example covered by the node in order of nodes having a high evaluation value calculated by the inference means, and deleting an example corresponding to the outputted rule from the storage means; Comprising
An inductive inference system characterized in that the order of output by the output means is a priority order of rules.

Images