Computer system and training data generation method

Abstract

To generate training data used for training a model that performs a logical inference.SOLUTION: A computer system that generates training data used for training a model configured to perform logical inference holds argument data representing an argument that leads to a conclusion proposition from a plurality of premise propositions. The proposition is expressed as a logical expression. The computer system searches for the argument data whose conclusion is the premise proposition of the argument data or the argument data whose premise is the conclusion proposition of the argument data, and performs combination to generate proof data representing a proof that leads to a conclusion proposition by repeating the argument a plurality of times, converts the proof data into a text expressed as a language expression, and generates the training data using the text.SELECTED DRAWING: Figure 1

Description

[Technical field]

[0001] This relates to a technology for generating training data used to train a model that simulates human logical reasoning. [Background technology]

[0002] The realization of an AI with human-like logical reasoning capabilities has been one of the major goals of the study of artificial intelligence since the dawn of the field. If an AI with logical reasoning capabilities could be realized, it would be able to help solve complex decision-making problems that occur in the real world while ensuring transparency and explainability.

[0003] For example, consider the decision-making problem of "Should we invest in a business in Africa?" To solve this problem, we need to go through the argument steps shown in Figure 17 one by one.

[0004] Generally, if only the conclusion of an AI is presented, it is difficult for people to accept the conclusion with a sense of conviction. Therefore, by presenting the thought process as shown in Figure 17 along with the conclusion, transparency and explainability can be ensured. Ensuring transparency and explainability can increase the traceability of errors made by AI, leading to more accurate decision-making.

[0005] An inference that draws a conclusion from a premise proposition (statement) is recognized as a valid inference. This type of logical inference is called an argument, and is formulated in the form shown in Figure 18. An inference that draws a conclusion by repeating multiple arguments is called a proof.

[0006] Here, the following facts are known in logic. (1) Logical inference is the process of generating a proof of a logical formula by repeating symbol transformation (argumentation) according to certain rules. (2) The correctness of a logical inference does not depend on the content of the proposition, but only on its form. (3) A logical formula (conclusion) derived through logical inference is always a logical truth, and all logical truths can be derived through deductive inference.

[0007] In order to realize an AI with logical inference capabilities, it is necessary to create training data that simulates logical inference and use the training data to perform learning. Since logical inference involves generating proofs by repeating arguments, in order to generate training data that simulates logical inference, it is necessary to generate text that expresses the proofs.

[0008] Non-Patent Document 1 and Non-Patent Document 2 are known as studies on generating such learning data. In Non-Patent Document 1, proofs are generated by randomly generating various logical expressions and applying a logical inference solver to them. In Non-Patent Document 2, a proof process is generated by randomly converting the premise and conclusion of a manually prepared argument into an appropriate natural language. [Prior art documents] [Non-patent literature]

[0009] [Non-Patent Document 1] Tafjord, Oyvind, Bhavana Dalvi Mishra, and Peter Clark, "ProofWriter: Generating implications, proofs, and abductive statements over natural language.", [online], December 24, 2020, [Retrieved November 21, 2022], Internet〈URL:https: / / arxiv.org / abs / 2012.13048v1〉 [Non-Patent Document 2] Fitria, Yanti, Fiddinya Nurul Hasanah, and Nurhizrah Gistituati, "Critical Thinking Skills of Prospective Elementary School Teachers in Integrated Science-Mathematics Lectures." Journal of Education and Learning (EduLearn) 12.4 (2018): 597-603. Summary of the Invention [Problem to be solved by the invention]

[0010] In Non-Patent Document 1, it is not possible to specify arguments contained in the corpus, and only simple proofs with a small number of proof steps can be generated. In Non-Patent Document 2, only single proofs are handled, and stacked proofs are not handled.

[0011] The present invention aims to generate training data to be used for training a model that performs logical inference based on proofs that lead to conclusions through multiple repetitions of unbiased arguments. [Means for solving the problem]

[0012] A representative example of the invention disclosed in the present application is as follows: That is, a computer system for generating learning data used in learning a model performing logical inference includes at least one computer, holds argument data representing an argument that derives a conclusion proposition from a plurality of premise propositions, the propositions being expressed as logical formulas, and the at least one computer searches for and combines the argument data in which the proposition that is the premise of the argument data is the conclusion, or the argument data in which the proposition that is the conclusion of the argument data is the premise, thereby generating proof data representing a proof that derives the conclusion proposition by repeating the argument multiple times, converts the proof data into text expressed as a linguistic expression, and generates the learning data using the text. Effect of the Invention

[0013] According to the present invention, it is possible to generate training data to be used for training a model that performs logical inference based on a proof that repeats unbiased arguments multiple times. Problems, configurations, and effects other than those described above will become apparent from the following description of the embodiments. [Brief description of the drawings]

[0014] [Figure 1] FIG. 2 is a diagram illustrating an example of a configuration of a computer according to a first embodiment. [Figure 2A] FIG. 2 is a diagram showing an example of argument data stored in the argument data database of the first embodiment. [Figure 2B] FIG. 2 is a diagram showing an example of argument data stored in the argument data database of the first embodiment. [Diagram 3] FIG. 4 is a diagram illustrating an example of a translation template database according to the first embodiment. [Figure 4] 11 is a flowchart illustrating an example of a learning data generation process executed by the computer according to the first embodiment. [Diagram 5] 11 is a flowchart illustrating an example of a proof tree generation process executed by a proof tree generation unit according to the first embodiment. [Figure 6] FIG. 11 is a diagram showing a specific example of a proof tree generation process in the first embodiment. [Figure 7A] FIG. 11 is a diagram showing a specific example of a proof tree generation process in the first embodiment. [Figure 7B] FIG. 11 is a diagram showing a specific example of a proof tree generation process in the first embodiment. [Figure 8] 11 is a flowchart illustrating an example of a translation process executed by a translation unit according to the first embodiment. [Figure 9] FIG. 4 is a diagram showing a specific example of the translation process in the first embodiment. [Figure 10] 11 is a flowchart illustrating an example of a text output process executed by a text output unit according to the first embodiment. [Figure 11] FIG. 11 is a diagram showing a specific example of a text output process according to the first embodiment. [Figure 12]13 is a flowchart illustrating an example of a proof tree generation process executed by a proof tree generation unit according to the second embodiment. [Figure 13] FIG. 11 is a diagram showing an example of a screen presented by a computer according to a second embodiment. [Figure 14] FIG. 11 is a diagram showing an example of a screen presented by a computer according to a second embodiment. [Figure 15] FIG. 11 is a diagram showing an example of a screen presented by a computer according to a second embodiment. [Figure 16] FIG. 11 is a diagram illustrating an example of conversion information held by a computer according to a second embodiment. [Figure 17] FIG. 1 is a diagram illustrating an example of reasoning in a decision-making problem. [Figure 18] FIG. 1 is a diagram showing an example of an argument in logic. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0015] Hereinafter, an embodiment of the present invention will be described with reference to the drawings. However, the present invention is not to be interpreted as being limited to the description of the embodiment shown below. It will be easily understood by those skilled in the art that the specific configuration can be changed without departing from the concept or purpose of the present invention.

[0016] In the configurations of the invention described below, the same or similar configurations or functions are given the same reference numerals, and duplicated explanations are omitted.

[0017] In this specification, the terms "first," "second," "third," and the like are used to identify components and do not necessarily limit the number or order. EXAMPLES

[0018] FIG. 1 is a diagram illustrating an example of the configuration of a computer 100 according to the first embodiment.

[0019] The computer 100 generates text representing a proof in which an unbiased argument is repeated multiple times, and generates training data using the text. Note that the text is assumed to be composed of multiple sentences. The computer 100 also uses the training data to train a model, and executes a task using the model. A model trained using natural language is called a language model. The present invention is not limited to the content of the task to be executed and the type of model.

[0020] The computer 100 includes a processor 101, a main memory device 102, a secondary memory device 103, a network interface 104, an input device 105, and an output device 106.

[0021] The processor 101 executes a program stored in the main memory device 102. The processor 101 executes processing according to the program, thereby operating as a functional unit (module) that realizes a specific function. In the following explanation, when a process is explained with a functional unit as the subject, it indicates that the processor 101 is executing a program that realizes the functional unit.

[0022] The main storage device 102 is a memory or the like, and stores programs executed by the processor 101 and data used by the programs. The main storage device 102 is also used as a work area. The secondary storage device 103 is a hard disk drive (HDD), a solid state drive (SSD), or the like, and permanently stores data.

[0023] The programs and data may be stored in the secondary storage device 103. The processor 101 reads the programs and data from the secondary storage device 103 and loads them into the main storage device 102.

[0024] The network interface 104 performs communication via a network. The input device 105 is a keyboard, a mouse, a touch panel, etc., and inputs data, commands, etc. to the computer 100. The output device 106 is a display, etc., and outputs data such as processing results.

[0025] The main memory device 102 stores programs that realize the training data generation unit 110, the training unit 111, and the task execution unit 112. The main memory device 102 also stores an argumentation data database 120, a translation template database 121, a dictionary 122, a training data database 123, and model information 124.

[0026] The argument data database 120 is a database that manages data that represents arguments (argument data). An argument represents an operation that derives a conclusion proposition from a premise proposition. A proposition is expressed as a logical formula that is written using only proposition variables, or proposition variables and logical symbols. An argument is written using inference rules that derive a conclusion proposition from a premise proposition.

[0027] Translation template database 121 is a database for managing translation templates for converting a logical formula into a linguistic expression. In the following description, converting a logical formula into a linguistic expression is referred to as "translating a logical formula."

[0028] The dictionary 122 is information for converting propositional variables included in a logical formula into character strings such as nouns.

[0029] The learning data database 123 is a database for managing learning data. The model information 124 is information on a model that performs logical inference and is generated by a learning process using the learning data. The model is, for example, a neural network.

[0030] The learning unit 111 executes a learning process using the learning data. The present invention is not limited to the method of the learning process. The task execution unit 112 executes an arbitrary task using a model stored in the model information 124.

[0031] The training data generation unit 110 generates training data using argument data. The training data generation unit 110 has a proof tree generation unit 130, a translation unit 131, and a text output unit 132. The proof tree generation unit 130 uses logical data to repeat an argument multiple times and generate tree-structured data (proof tree) representing a proof that leads to a conclusion. The translation unit 131 translates logical expressions in the proof using the translation template database 121. The text output unit 132 generates training data using the translated proof tree.

[0032] Regarding the functional units of the computer 100, multiple functional units may be integrated into one functional unit, or one functional unit may be divided into multiple functional units for each function.

[0033] The computer 100 does not necessarily have to include the learning unit 111 and the task executing unit 112.

[0034] The same functions may be realized by using a computer system made up of a plurality of computers 100. In this case, each functional unit may be distributed among the plurality of computers 100.

[0035] 2A and 2B are diagrams showing an example of argument data stored in the argument data database 120 of the first embodiment.

[0036] The argument data database 120 stores argument data 200-1 and 200-2 that represent arguments as shown in Figures 2A and 2B. The argument data 200-1 and 200-2 represent arguments that assume proposition A and proposition (if A then B). Here, A and B represent proposition variables. The proposition above the bar represents the premise proposition, and the proposition below the bar represents the conclusion proposition. The bars are referred to as premise bars.

[0037] It is assumed that the propositional variables of the logical data are assigned syntactic properties such as parts of speech and conjugated forms.

[0038] FIG. 3 is a diagram illustrating an example of the translation template database 121 according to the first embodiment.

[0039] The translation template database 121 stores, for example, a table 300. The table 300 stores entries each of which is made up of a template ID 301, a logical expression 302, and a translation sentence 303.

[0040] Template ID 301 is a field that stores an ID for identifying a translation type (template). Logical formula 302 is a field that stores a logical formula including logical symbols. Translation sentence 303 is a field that stores a sentence that expresses the logical formula including logical symbols in a language.

[0041] Note that multiple sentences may be defined for the same logical expression, in which case the sentences may be selected randomly or based on any arbitrary selection rule.

[0042] FIG. 4 is a flowchart illustrating an example of the learning data generation process executed by the computer 100 according to the first embodiment.

[0043] The computer 100 acquires multiple pieces of argument data from the argument data database 120 (step S101). All of the argument data stored in the argument data database 120 may be acquired, or a predetermined number of pieces of argument data may be acquired. When acquiring a predetermined number of pieces of argument data, they may be selected randomly, or the user may specify the argument data to be acquired.

[0044] The proof tree generation unit 130 of the computer 100 executes a proof tree generation process (step S102). The details of the proof tree generation process will be described with reference to FIG.

[0045] The translation unit 131 of the computer 100 executes the translation process (step S103). The details of the translation process will be described with reference to FIG.

[0046] The text output unit 132 of the computer 100 executes a text output process (step S104). The details of the text output process will be described with reference to FIG.

[0047] Fig. 5 is a flowchart for explaining an example of the proof tree generation process executed by the proof tree generation unit 130 according to the first embodiment. Fig. 6, Fig. 7A, and Fig. 7B are diagrams showing specific examples of the proof tree generation process according to the first embodiment.

[0048] The proof tree generating unit 130 generates a proof tree for each of the multiple pieces of argumentation data, and registers the generated proof tree in a proof tree list (step S201).

[0049] Specifically, the proof tree generating unit 130 generates tree-structured data (proof trees) with premise propositions as leaf nodes and conclusion propositions as root nodes. The proof tree generating unit 130 also assigns an unprocessed flag to each proof tree and registers it in the proof tree list.

[0050] For example, as shown in FIG. 6, a proof tree 600-1 is generated from the argument data 200-1, and a proof tree 600-2 is generated from the argument data 200-2.

[0051] The proof tree generating unit 130 refers to the proof tree list and selects one proof tree from among the proof trees to which an unprocessed flag has been added (step S202). Here, the selected proof tree is referred to as a target proof tree.

[0052] Proof tree generation unit 130 refers to the proof tree list and searches for proof trees that can be connected to the target proof tree (step S203).

[0053] Possible search methods are (search method 1) a method of searching a proof tree whose root node is a leaf node of the target proof tree, and (search method 2) a method of searching a proof tree whose root node is a leaf node of the target proof tree. When using search method 2, a search is performed for each leaf node of the target proof tree.

[0054] As a result of the search, proof tree generation unit 130 determines whether or not there is a proof tree that can be connected to the target proof tree (step S204).

[0055] If there is no proof tree that can be connected to the target proof tree, proof tree generation unit 130 marks the target proof tree with a processed flag, and the process proceeds to step S206.

[0056] If there is a proof tree that can be connected to the target proof tree, proof tree generation unit 130 generates a new proof tree by connecting the found proof tree to the target proof tree, marks the proof tree with an unprocessed flag, and registers it in the proof tree list (step S205). After that, proof tree generation unit 130 proceeds to step S206. At this time, proof tree generation unit 130 marks the target proof tree with a processed flag.

[0057] 7A, when search method 1 is performed with proof tree 700-1 as the target proof tree, proof tree 700-2 is searched for. In this case, proposition B of proof tree 700-1 and proposition B of proof tree 700-2 are joined to generate proof tree 700-3.

[0058] 7B, when search method 2 is performed with proof tree 700-2 as the target proof tree, proof tree 700-1 is searched. In this case, proposition B of proof tree 700-2 and proposition B of proof tree 700-1 are joined to generate proof tree 700-3.

[0059] When search method 1 is used, new proof trees are generated for each proof tree that is searched. When search method 2 is used, new proof trees are generated for each combination of proof trees that can be connected to each leaf node.

[0060] The proof tree generation unit 130 determines whether or not the processing has been completed for all proof trees in the proof tree list (step S206).

[0061] Specifically, the proof tree generation unit 130 judges whether or not a processed flag has been added to all the proof trees in the proof tree list. If a processed flag has been added to all the proof trees in the proof tree list, the proof tree generation unit 130 judges that processing has been completed for all the proof trees in the proof tree list.

[0062] If the processing has not been completed for all the proof trees in the proof tree list, proof tree generation unit 130 returns to step S202.

[0063] When the processing has been completed for all the proof trees in the proof tree list, the proof tree generation unit 130 deletes the proof tree with one argument step from the proof tree list (step S207) and ends the proof tree generation processing. In other words, the proof tree corresponding to the logical data is deleted.

[0064] Through the above process, a proof tree is generated that corresponds to a proof that leads to a conclusion by performing arguments multiple times.

[0065] Note that the proof tree generation process described in Fig. 5 is merely an example and is not limited to this. Any process may be used as long as it searches for and combines arguments whose conclusion is the proposition that is the premise of the argument, or arguments whose conclusion is the proposition that is the premise of the argument.

[0066] Fig. 8 is a flowchart illustrating an example of the translation process executed by the translation unit 131 according to the first embodiment. Fig. 9 is a diagram illustrating a specific example of the translation process according to the first embodiment.

[0067] The translation unit 131 selects one proof tree from the proof tree list (step S301). Here, the selected proof tree is referred to as a target proof tree.

[0068] Translation unit 131 converts the logical formula included in the target proof tree into a sentence by referring to translation template database 121 (step S302). Specifically, the following process is executed.

[0069] (S302-1) Translation unit 131 selects one logical formula included in the target proof tree.

[0070] (S302-2) The translation unit 131 determines whether the selected logical formula is a logical formula consisting of propositional variables only.

[0071] (S302-3) If the selected logical formula is a logical formula consisting only of propositional variables, translation unit 131 outputs the propositional variables as they are as a sentence, and the process proceeds to S302-5.

[0072] (S302-4) If the selected logical formula is not a logical formula consisting of only proposition variables, the translation unit 131 searches for an entry in which the selected logical formula is stored in the logical formula 302. The translation unit 131 converts the selected logical formula into a sentence based on the translation sentence 303 of the searched entry.

[0073] (S302-5) Translation unit 131 determines whether or not processing has been completed for all logical formulas in the target proof tree. If processing has not been completed for all logical formulas in the target proof tree, translation unit 131 returns to S302-1. If processing has been completed for all logical formulas in the target proof tree, translation unit 131 ends the processing of step S302.

[0074] For example, if proof tree 700-3 is selected as the target proof tree, the output shown in FIG. 9 is obtained.

[0075] The translation unit 131 converts the propositional variables included in the sentence into character strings using the dictionary 122 (step S303).

[0076] For example, in the case of a sentence "If x is A, then it is B," the translation unit 131 converts "x," "A," and "B" into character strings to generate the sentence "If an apple is red, it is delicious." Note that multiple sentences with different meanings may be generated from one sentence.

[0077] Translation unit 131 adds text to the target proof tree (step S304).

[0078] Specifically, translation unit 131 assigns a sentence to each node of proof tree 700-3, as shown in FIG.

[0079] The translation unit 131 determines whether or not the processing has been completed for all the proof trees (step S305).

[0080] If the processing has not been completed for all the proof trees, translation unit 131 returns to step S301. If the processing has been completed for all the proof trees, translation unit 131 ends the translation processing.

[0081] Fig. 10 is a flowchart illustrating an example of the text output process executed by the text output unit 132 according to the first embodiment. Fig. 11 is a diagram illustrating a specific example of the text output process according to the first embodiment.

[0082] The text output unit 132 selects one proof tree from the proof tree list (step S401). Here, the selected proof tree is referred to as a target proof tree.

[0083] Text output unit 132 generates learning data based on the text of the target proof tree (step S402).

[0084] Specifically, the text output unit 132 generates training data by outputting sentences that are assigned to nodes of the target proof tree based on preset rules. The sentence output rules can be changed depending on the task executed by the task execution unit 112.

[0085] For example, when the task execution unit 112 takes a premise proposition as input and executes a task to derive a conclusion, the sentence of the node corresponding to the premise proposition is output as the sentence to be input to the model, and the sentence of the node corresponding to the conclusion proposition is output as the sentence to be output by the model.

[0086] The text output unit 132 may access an external database to check the correctness of the content of the sentence. If the content of the sentence is incorrect, the text output unit 132 controls not to output the sentence as a sentence to be included in the learning data.

[0087] In addition, the node ID, etc. may be output together with the sentence.

[0088] The training data generation unit 110 of the first embodiment repeats multiple arguments, generates a proof tree representing a proof leading to a conclusion, converts the proof tree into text, and generates training data from the text. Since a search for connectable proof trees is performed exhaustively, a proof in which an unbiased argument is repeated multiple times can be generated. Also, a proof based on a complex combination of arguments can be generated. By generating training data using text representing these proofs, training data simulating logical inference can be generated. A model with logical inference ability can be generated by a learning process using the generated training data. EXAMPLES

[0089] In the second embodiment, the proof tree generation process is different from that in the first embodiment. The second embodiment will be described below, focusing on the differences from the first embodiment.

[0090] The hardware configuration and the software configuration of the computer 100 in the second embodiment are the same as those in the first embodiment. The flow of the learning data generation process in the second embodiment is the same as that in the first embodiment. Moreover, the translation process and the text output process in the second embodiment are the same as those in the first embodiment.

[0091] Fig. 12 is a flowchart for explaining an example of a proof tree generation process executed by the proof tree generation unit 130 of the embodiment 2. Fig. 13, Fig. 14, and Fig. 15 are diagrams showing examples of screens presented by the computer 100 of the embodiment 2. Fig. 16 is a diagram showing an example of conversion information 1600 held by the computer 100 of the embodiment 2.

[0092] The computer 100 of the second embodiment receives an input for determining a condition for a proof tree to be generated (proof tree generation condition) when executing the learning data generation process.

[0093] Screen 1300 is a screen for inputting proof tree generation conditions, and includes input fields 1301, 1302, 1303, and an execute button 1304. The user determines the proof tree generation conditions based on the resources of computer 100 or the proof tree to be handled in the task, and inputs the information into screen 1300.

[0094] An input field 1301 is a field for inputting an upper limit value for the depth of a proof tree. An input field 1302 is a field for inputting an upper limit value for the leaf nodes to be included in the proof tree. An input field 1303 is a field for inputting a condition for a logical expression. An execute button 1304 is an operation button for instructing execution of a learning data generation process.

[0095] There are cases where it is difficult for the user to determine the proof tree generation conditions. In such cases, the screens 1400 and 1500 shown in Figs. 14 and 15 are presented.

[0096] Screen 1400 is a screen for setting proof tree generation conditions from conditions related to the resource amount of computer 100. Screen 1400 includes an input area 1401 and a display area 1402. Input area 1401 is an area for inputting conditions related to the resource amount, and display area 1402 is an area for displaying the proof tree generation conditions.

[0097] The input area 1401 includes input fields 1411 and 1412, and a conversion button 1413. The input field 1411 is a field for inputting the number of GPUs. The input field 1412 is a field for inputting the memory capacity. The conversion button 1413 is an operation button for instructing conversion from an information condition regarding the amount of resources to a proof tree generation condition.

[0098] The computer 100 holds conversion information 1600 as shown in FIG. 16. The conversion information 1600 stores an entry including a resource condition 1601 and a proof tree generation condition 1602. When the conversion button 1413 is operated, the computer 100 refers to the conversion information 1600 and searches for an entry whose resource condition 1601 matches the resource condition input in the input area 1401. The computer 100 displays the proof tree generation condition in the display area 1402 based on the proof tree generation condition 1602 of the searched entry. The user modifies the proof tree generation condition displayed in the display area 1402 as necessary. The user also operates the execute button 1421 in the display area 1402 to instruct execution of the learning data generation process.

[0099] Screen 1500 is a screen for setting proof tree generation conditions from logical inference data handled in a task. Screen 1500 includes an input area 1501 and a display area 1502. Input area 1501 is an area for inputting logical inference data handled in a task, and display area 1502 is an area for displaying the proof tree generation conditions.

[0100] The input area 1501 includes an input field 1511 and a conversion button 1512. The input field 1511 is a field for inputting logical inference data to be handled in a task. The conversion button 1512 is an operation button for instructing conversion from the logical inference data to be handled in a task to proof tree generation conditions.

[0101] When the conversion button 1512 is operated, the computer 100 converts the logical inference data into a proof tree and determines the proof tree generation conditions by analyzing the converted proof tree. Methods for converting the logical inference data into a proof tree include well-known syntax analysis / argument mining techniques. Alternatively, a method using a rule-based converter may be used. Items of the proof tree generation conditions that cannot be determined based on the logical inference data are determined randomly.

[0102] Computer 100 displays the proof tree generation conditions in display area 1502. If necessary, the user modifies the proof tree generation conditions displayed in display area 1502. In addition, the user operates execute button 1521 in display area 1502 to instruct execution of the learning data generation process.

[0103] The proof tree generation process of the second embodiment will be described.

[0104] The processes from step S201 to step S203 are the same as those in the first embodiment. In step S203, a connectable proof tree is searched for based on the proof tree generation conditions. The processes in steps S204 and S205 are the same as those in the first embodiment.

[0105] After the process of step S205, proof tree generation unit 130 judges whether or not to end the search based on the proof tree generation condition (step S251). For example, if the depth of the newly generated proof tree matches the upper limit, it is judged that the search is to end.

[0106] If the search is not to be ended, proof tree generation unit 130 returns to step S203, whereas if the search is to be ended, proof tree generation unit 130 proceeds to step S206.

[0107] According to the second embodiment, a proof tree desired by the user can be generated, which is expected to reduce the load, shorten the calculation time, and improve the accuracy of the model.

[0108] The present invention is not limited to the above-mentioned embodiment, but includes various modified examples. For example, the above-mentioned embodiment describes the configuration in detail to easily explain the present invention, and the present invention is not necessarily limited to the configuration including all the described configurations. Also, it is possible to add, delete, or replace a part of the configuration of each embodiment with another configuration.

[0109] In addition, each of the above configurations, functions, processing units, processing means, etc. may be realized in part or in whole by hardware, for example, by designing them as integrated circuits. The present invention can also be realized by software program code that realizes the functions of the embodiments. In this case, a storage medium on which the program code is recorded is provided to a computer, and a processor included in the computer reads the program code stored in the storage medium. In this case, the program code itself read from the storage medium realizes the functions of the above-mentioned embodiments, and the program code itself and the storage medium storing it constitute the present invention. Examples of storage media for supplying such program code include flexible disks, CD-ROMs, DVD-ROMs, hard disks, SSDs (Solid State Drives), optical disks, magneto-optical disks, CD-Rs, magnetic tapes, non-volatile memory cards, ROMs, etc.

[0110] Furthermore, the program code for realizing the functions described in this embodiment can be implemented in a wide range of program or script languages, such as assembler, C / C++, perl, Shell, PHP, Python, Java (registered trademark), etc.

[0111] Furthermore, the program code of the software that realizes the functions of the embodiments may be distributed over a network and stored in a storage means such as a computer's hard disk or memory, or in a storage medium such as a CD-RW or CD-R, and the processor of the computer may read out and execute the program code stored in the storage means or storage medium.

[0112] In the above-mentioned embodiment, the control lines and information lines are shown as those considered necessary for the explanation, and not all the control lines and information lines are shown in the product. All the components may be connected to each other. [Explanation of symbols]

[0113] 100 calculator 101 Processor 102 Main storage 103 Secondary storage device 104 Network Interface 105 Input Device 106 Output Device 110 Learning data generation unit 111 Learning Department 112 Task Execution Unit 120 Argument Data Database 121 Translation template database 122 Dictionaries 123 Learning Data Database 124 Model Information 130 Proof Tree Generation Unit 131 Translation Department 132 Text Output Section 1300, 1400, 1500 screen 1600 Conversion Information

Claims

1. A computer system for generating learning data for use in learning a model that performs logical inference, comprising: At least one computer, The data represents an argument that derives a conclusion from multiple premise propositions; The proposition is expressed as a logical formula, The at least one computer searching for and combining the argument data in which the proposition of the premise of the argument data is the conclusion, or the argument data in which the proposition of the conclusion of the argument data is the premise, thereby generating proof data representing a proof that leads to the proposition that is the conclusion by repeating the argument multiple times; converting the proof data into text expressed as a linguistic expression; A computer system that generates the learning data using the text.

2. 2. The computer system of claim 1, The at least one computer Using the argument data, a proof tree is generated, which is tree-structured data with the propositions of premises as leaf nodes and the proposition of conclusion as a root node; using the proof tree, searching for the argument data whose conclusion is the proposition of the premise of the argument data, or the argument data whose conclusion is the proposition of the conclusion of the argument data, a computer system for generating the proof data by combining a plurality of the proof trees based on a result of the search.

3. 3. The computer system of claim 2, The logical formula is described using variables that represent propositions, or using the variables and logical symbols; the computer system manages templates in which logical expressions including the logical symbols are associated with sentences; The at least one computer outputting the variables of the formula including only the variables of the proof data as a sentence; converting the logical formula including the logical symbols of the proof data into a sentence using the template; converting the variables included in the sentence obtained by converting the logical expression into character strings; a computer system that generates the text composed of sentences obtained by transforming a plurality of the logical formulas included in the proof data;

4. 3. The computer system of claim 2, The at least one computer accepting a generation condition for the proof data from a user; A computer system that generates the proof data based on a generation condition for the proof data.

5. 5. The computer system of claim 4, The at least one computer accepting information regarding the amount of resources of the computer system from a user; determining a condition for generating the proof data based on a resource amount of the computer system; A computer system which presents the determined conditions for generating the proof data.

6. 5. The computer system of claim 4, The at least one computer Accepting information from a user regarding data handled by a model trained using the training data; Analyzing data handled by a model trained using the training data; determining conditions for generating the proof data based on the results of the analysis; A computer system which presents the determined conditions for generating the proof data.

7. 3. The computer system of claim 2, A computer system characterized by executing at least one of a learning process for generating a model for executing an arbitrary task using the learning data, and a task execution process using the model.

8. A method for generating learning data used in learning a model that performs logical inference, the method being executed by a computer system, comprising: The computer system comprises: At least one computer, The data represents an argument that derives a conclusion from multiple premise propositions; The proposition is expressed as a logical formula, The method for generating training data includes: a first step in which the at least one computer searches for and combines the argument data in which the proposition which is a premise of the argument data becomes the conclusion, or the argument data in which the proposition which is a conclusion of the argument data becomes the premise, thereby generating proof data representing a proof which leads to a proposition which is a conclusion by repeating the argument a number of times; a second step of converting the proof data into text expressed as a linguistic expression by the at least one computer; a third step in which the at least one computer generates the training data using the text.

9. The method for generating training data according to claim 8, further comprising the steps of: The first step includes: a step of generating, by the at least one computer, a proof tree, which is tree-structured data in which the propositions of premises are leaf nodes and the proposition of a conclusion is a root node, using the argument data; a step of searching, by the at least one computer, for the argument data whose conclusion is the proposition which is a premise of the argument data, or the argument data whose conclusion is the proposition which is a premise of the argument data, using the proof tree; and generating the proof data by combining a plurality of the proof trees based on a result of the search, said at least one computer.

10. The method for generating training data according to claim 9, The logical formula is described using variables that represent propositions, or using the variables and logical symbols; the computer system manages templates in which logical expressions including the logical symbols are associated with sentences; The second step includes: outputting, by the at least one computer, the variables of the formula including only the variables of the proof data as a sentence; converting, by the at least one computer, the logical formula including the logical symbols of the proof data into a sentence using the template; said at least one computer converting said variables included in a sentence obtained by converting said logical formula into a character string; and generating, by the at least one computer, the text composed of sentences obtained by transforming a plurality of the logical formulas included in the proof data.

11. The method for generating training data according to claim 9, further comprising the steps of: a step of receiving, by the at least one computer, a generation condition for the proof data from a user; and generating the proof data by the at least one computer based on a generation condition of the proof data.

12. The method for generating training data according to claim 11, a step of receiving information regarding a resource amount of the computer system from a user by the at least one computer; determining, by the at least one computer, a condition for generating the proof data based on a resource amount of the computer system; and a step in which the at least one computer presents the determined conditions for generating the proof data.

13. The method for generating training data according to claim 11, The at least one computer receives information from a user regarding data to be handled by a model trained using the training data; A step of analyzing data handled by a model trained using the training data by the at least one computer; determining, by the at least one computer, a condition for generating the proof data based on a result of the analysis; and a step in which the at least one computer presents the determined conditions for generating the proof data.

14. The method for generating training data according to claim 9, further comprising the steps of: A method for generating learning data, comprising a step in which the at least one computer executes at least one of a learning process for generating a model that executes an arbitrary task using the text, and a task execution process using the model.

Images