Computer system and method for generating training data

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] It relates to a technique for generating learning data used for learning a model that simulates human logical inference.

Background Art

[0002] The realization of artificial intelligence with logical inference ability like humans is one of the major goals since the dawn of artificial intelligence studies. If artificial intelligence with logical inference ability can be realized, it can support the solution of complex decision-making problems occurring in the real world while ensuring transparency and explainability.

[0003] For example, consider the decision-making problem of "whether to invest in African business". To solve this problem, it is necessary to think about the argument steps one by one as shown in FIG. 17.

[0004] Generally, even if only the conclusion of artificial intelligence is presented, it is difficult for people to accept the conclusion with a sense of conviction. Therefore, by presenting the thinking process as shown in FIG. 17 together with the conclusion, transparency and explainability can be ensured. Ensuring transparency and explainability can enhance the traceability of errors caused by artificial intelligence, leading to more accurate decision-making.

[0005] The inference that derives a conclusion from a premise proposition (statement) is recognized as a valid inference. Such a type of logical inference is called an argument and is formulated in the form as shown in FIG. 18. Repeating multiple arguments and deriving a conclusion is called a proof.

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

[0007] To realize artificial intelligence with logical reasoning capabilities, one should create training data that simulates logical reasoning and then perform training using that data. Since logical reasoning involves generating proofs by repeating arguments, generating training data that simulates logical reasoning requires generating text that represents proofs.

[0008] Non-Patent Documents 1 and 2 are known studies on generating such training data. Non-Patent Document 1 generates proofs by randomly generating various logical formulas and applying a logical inference solver to them. Non-Patent Document 2 generates proof processes by randomly converting the premises and conclusions of an argument, prepared manually, into 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. [Overview of the Initiative] [Problems that the invention aims to solve]

[0010] Non-patent document 1 does not allow specifying the arguments to be included in the corpus, and can only generate simple proofs with a small number of proof steps. Non-patent document 2 deals only with single proofs and does not deal with the accumulation of arguments.

[0011] The present invention aims to generate training data for use in training a model that performs logical inference based on proofs that repeatedly perform unbiased arguments and arrive at conclusions. [Means for solving the problem]

[0012] A representative example of the invention disclosed in this application is as follows: A computer system for generating training data used to train a model that performs logical reasoning, comprising at least one computer, holding argumentation data representing arguments that derive a conclusion proposition from a plurality of premise propositions, the propositions being expressed as logical formulas, the at least one computer searching for and combining argumentation data in which the premise proposition of the argumentation data is the conclusion, or argumentation data in which the conclusion proposition of the argumentation data is the premise, thereby generating proof data representing a proof that derives a conclusion proposition by repeating the argument multiple times, converting the proof data into text expressed as a linguistic expression, and generating the training data using the text. [Effects of the Invention]

[0013] According to the present invention, learning data used for learning a model that performs logical inference can be generated based on a proof that repeatedly performs unbiased argumentation a plurality of times. Problems, configurations, and effects other than those described above will be clarified by the description of the following embodiments.

Brief Description of the Drawings

[0014] [Figure 1] It is a diagram showing an example of the configuration of the computer of Example 1. [Figure 2A] It is a diagram showing an example of the argument data stored in the argument database of Example 1. [Figure 2B] It is a diagram showing an example of the argument data stored in the argument database of Example 1. [Figure 3] It is a diagram showing an example of the translation template database of Example 1. [Figure 4] It is a flowchart for explaining an example of the learning data generation process executed by the computer of Example 1. [Figure 5] It is a flowchart for explaining an example of the proof tree generation process executed by the proof tree generation unit of Example 1. [Figure 6] It is a diagram showing a specific example of the proof tree generation process of Example 1. [Figure 7A] It is a diagram showing a specific example of the proof tree generation process of Example 1. [Figure 7B] It is a diagram showing a specific example of the proof tree generation process of Example 1. [Figure 8] It is a flowchart for explaining an example of the translation process executed by the translation unit of Example 1. [Figure 9] It is a diagram showing a specific example of the translation process of Example 1. [Figure 10] It is a flowchart for explaining an example of the text output process executed by the text output unit of Example 1. [Figure 11] It is a diagram showing a specific example of the text output process of Example 1. [Figure 12]It is a flowchart for explaining an example of the proof tree generation process executed by the proof tree generation unit of Example 2. [Figure 13] It is a diagram showing an example of the screen presented by the computer of Example 2. [Figure 14] It is a diagram showing an example of the screen presented by the computer of Example 2. [Figure 15] It is a diagram showing an example of the screen presented by the computer of Example 2. [Figure 16] It is a diagram showing an example of the conversion information held by the computer of Example 2. [Figure 17] It is a diagram showing an example of the inference in the decision-making problem. [Figure 18] It is a diagram showing an example of the argument in logic.

Embodiments for Carrying Out the Invention

Example

[0019] It seems there are some parts in the original text that are not fully presented or have some incorrect formatting in the "利用本明細書等における……" parts. If you can correct or clarify those parts, the translation will be more accurate.​​​​​​​​​​​Computer 100 generates text representing a proof that repeats unbiased arguments multiple times, and uses this text to generate training data. The text consists of multiple sentences. Computer 100 also trains a model using the training data and performs tasks using the model. A model trained using natural language is called a language model. This invention is not limited to the content of the tasks performed or the type of model.

[0020] The computer 100 includes a processor 101, a main memory 102, a secondary memory 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 102. By executing processing according to the program, the processor 101 operates as a functional unit (module) that realizes a specific function. In the following description, when the processing is described with a functional unit as the subject, it indicates that the processor 101 is executing a program that realizes that functional unit.

[0022] The main memory 102 is a memory device that stores programs executed by the processor 101 and data used by those programs. The main memory 102 is also used as a work area. The secondary memory 103 is an HDD (Hard Disk Drive) or SSD (Solid State Drive) that permanently stores data.

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

[0024] The network interface 104 performs communication over the network. The input device 105 is a keyboard, mouse, 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 102 stores programs that implement the learning data generation unit 110, the learning unit 111, and the task execution unit 112. The main memory 102 also stores the argumentation data database 120, the translation template database 121, the dictionary 122, the learning data database 123, and the model information 124.

[0026] The Argument Data Database 120 is a database that manages data representing arguments (argument data). An argument represents the operation of deriving a conclusion proposition from a premise proposition. A proposition is expressed as a logical formula written using only propositional variables, or using propositional 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 logical formulas into linguistic expressions. In the following description, the conversion of logical formulas into linguistic expressions will be referred to as "translation of logical formulas."

[0028] Dictionary 122 contains information for converting propositional variables included in logical formulas into strings such as nouns.

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

[0030] The learning unit 111 performs learning processing using the learning data. The present invention is not limited to the learning processing method. The task execution unit 112 performs any task using the model stored in the model information 124.

[0031] The learning data generation unit 110 generates learning data using argumentation data. The learning data generation unit 110 includes a proof tree generation unit 130, a translation unit 131, and a text output unit 132. The proof tree generation unit 130, Argumentation data Using this method, the argument is repeated multiple times to generate a tree structure data (proof tree) representing the proof that leads to the conclusion. The translation unit 131 uses the translation template database 121 to translate the logical formulas in the proof. The text output unit 132 generates training data using the translated proof tree.

[0032] Furthermore, regarding the functional units of the computer 100, multiple functional units may be combined into a single functional unit, or a single functional unit may be divided into multiple functional units according to its function.

[0033] Note that the computer 100 does not necessarily have to have a learning unit 111 and a task execution unit 112.

[0034] Alternatively, the same functionality may be achieved using a computer system consisting of multiple computers 100. In this case, each functional unit may be distributed among the multiple computers 100.

[0035] Figures 2A and 2B show examples of argumentation data stored in the argumentation data database 120 of Example 1.

[0036] The argumentation data database 120 stores argumentation data 200-1 and 200-2, which represent arguments as shown in Figures 2A and 2B. The argumentation data 200-1 is The bar represents a proposition A and an argument that takes the proposition (If A, then B) as premises. Here, A and B represent propositional variables. The proposition on the upper side of the bar represents the premise proposition, and the proposition on the lower side of the bar represents the conclusion proposition. The bar is called the premise bar.

[0037] In addition, Argumentation data The propositional variables are assumed to be assigned syntactic characteristics such as part of speech and conjugation form.

[0038] Figure 3 shows an example of the translation template database 121 of Example 1.

[0039] The translation template database 121 stores, for example, table 300. Table 300 stores entries consisting of template ID 301, logical expression 302, and translation sentence 303.

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

[0041] Furthermore, multiple sentences may be defined for the same logical expression. In this case, the sentences can be selected randomly or based on any selection rule.

[0042] Figure 4 is a flowchart illustrating an example of the training data generation process performed by the computer 100 in Example 1.

[0043] Computer 100 retrieves multiple argument data from argument data database 120 (step S101). All argument data stored in argument data database 120 may be retrieved, or a predetermined number of argument data may be retrieved. If a predetermined number of argument data is retrieved, they may be selected randomly, or the user may specify which argument data to retrieve.

[0044] The proof tree generation unit 130 of the computer 100 executes the proof tree generation process (step S102). The details of the proof tree generation process will be explained using Figure 5.

[0045] The translation unit 131 of the computer 100 performs the translation process (step S103). The details of the translation process will be explained using Figure 8.

[0046] The text output unit 132 of the computer 100 performs text output processing (step S104). Details of the text output processing will be explained using Figure 10.

[0047] Figure 5 is a flowchart illustrating an example of the proof tree generation process performed by the proof tree generation unit 130 in Example 1. Figures 6, 7A, and 7B show specific examples of the proof tree generation process in Example 1.

[0048] The proof tree generation unit 130 generates a proof tree for each of the multiple argument data and registers it in the proof tree list (step S201).

[0049] Specifically, the proof tree generation unit 130 generates tree structure data (proof trees) in which the premise propositions are leaf nodes and the conclusion proposition is the root node. The proof tree generation 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 Figure 6, proof tree 600-1 is generated from argument data 200-1, and proof tree 600-2 is generated from argument data 200-2.

[0051] The proof tree generation unit 130 refers to the proof tree list and selects one proof tree from among those marked with an unprocessed flag (step S202). Here, the selected proof tree is referred to as the target proof tree.

[0052] The 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] Two possible search methods are: (Search Method 1) searching for proof trees in which the root node of the target proof tree is a leaf node, and (Search Method 2) searching for proof trees in which the leaf nodes of the target proof tree are root nodes. When using Search Method 2, a search is performed on each leaf node of the target proof tree.

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

[0055] If no proof tree exists that can be connected to the target proof tree, the proof tree generation unit 130 assigns a processed flag to the target proof tree and proceeds to step S206.

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

[0057] As shown in Figure 7A, when a search using search method 1 is performed with proof tree 700-1 as the target proof tree, proof tree 700-2 is searched. In this case, proof tree 700-3 is generated by combining proposition B of proof tree 700-1 and proposition B of proof tree 700-2.

[0058] As shown in Figure 7B, when a search using search method 2 is performed with proof tree 700-2 as the target proof tree, proof tree 700-1 is found. In this case, proof tree 700-3 is generated by combining proposition B of proof tree 700-2 and proposition B of proof tree 700-1.

[0059] If search method 1 is used, a new proof tree is generated equal to the number of proof trees that have been searched. If search method 2 is used, a new proof tree is generated equal to the number of combinations of proof trees that can be connected to each leaf node.

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

[0061] Specifically, the proof tree generation unit 130 determines whether the processed flag has been assigned to all proof trees in the proof tree list. If the processed flag has been assigned to all proof trees in the proof tree list, the proof tree generation unit 130 determines that processing is complete for all proof trees in the proof tree list.

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

[0063] When processing is complete for all proof trees in the proof tree list, the proof tree generation unit 130 removes proof trees with a number of argumentation steps of 1 from the proof tree list (step S207) and terminates the proof tree generation process. That is, Argumentation data The corresponding proof tree is deleted.

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

[0065] Note that the proof tree generation process described in Figure 5 is just one example and is not limited to it. Any process that searches for and combines arguments where the proposition that serves as the premise of the argument is the conclusion, or arguments where the proposition that is the conclusion of the argument is a premise, is acceptable.

[0066] Figure 8 is a flowchart illustrating an example of the translation process performed by the translation unit 131 of Example 1. Figure 9 is a diagram showing a specific example of the translation process of Example 1.

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

[0068] The translation unit 131 refers to the translation template database 121 and converts the logical formulas contained in the target proof tree into sentences (step S302). Specifically, the following processes are performed.

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

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

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

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

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

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

[0075] The translation unit 131 uses the dictionary 122 to convert the propositional variables contained in the sentence into strings (step S303).

[0076] For example, if the sentence is "If x is A, then it is B," the translation unit 131 converts "x," "A," and "B" into strings and generates the sentence "If an apple is red, then it is delicious." It is also possible to generate multiple sentences with different meanings from a single sentence.

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

[0078] Specifically, the translation unit 131 adds a sentence to each node of the proof tree 700-3, as shown in Figure 9.

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

[0080] If processing is not complete for all proof trees, the translation unit 131 returns to step S301. If processing is complete for all proof trees, the translation unit 131 terminates the translation process.

[0081] Figure 10 is a flowchart illustrating an example of the text output process performed by the text output unit 132 of Embodiment 1. Figure 11 is a diagram showing a specific example of the text output process of Embodiment 1.

[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 the target proof tree.

[0083] The text output unit 132 generates training 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 attached to the nodes of the target proof tree based on pre-configured rules. The sentence output rules can be changed according to 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 performs 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 also access an external database to verify the correctness of the sentence content. If the sentence content is incorrect, the text output unit 132 controls itself so as not to output that sentence as one to be included in the training data.

[0087] Note that the node ID and other information may be output along with the sentence.

[0088] The learning data generation unit 110 in Example 1 generates a proof tree representing a proof that leads to a conclusion by repeatedly performing multiple arguments, converts the proof tree into text, and generates learning data from the text. Since the search for connectable proof trees is exhaustive, it is possible to generate proofs that repeat unbiased arguments multiple times. Furthermore, it is possible to generate proofs that consist of complex combinations of arguments. By generating learning data using the text that expresses these proofs, it is possible to generate learning data that simulates logical inference. Through a learning process using the generated learning data, it is possible to generate a model that has logical inference capabilities. [Examples]

[0089] In Example 2, the proof tree generation process differs from that in Example 1. The following describes Example 2, focusing on the differences from Example 1.

[0090] The hardware and software configurations of the computer 100 in Example 2 are the same as those in Example 1. The flow of the training data generation process in Example 2 is the same as that in Example 1. Furthermore, the translation process and text output process in Example 2 are the same as those in Example 1.

[0091] Figure 12 is a flowchart illustrating an example of the proof tree generation process performed by the proof tree generation unit 130 in Example 2. Figures 13, 14, and 15 show examples of screens displayed by the computer 100 in Example 2. Figure 16 shows an example of the conversion information 1600 held by the computer 100 in Example 2.

[0092] The computer 100 in Example 2 accepts input to determine the conditions for the proof tree to be generated (proof tree generation conditions) when executing the training data generation process.

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

[0094] Input field 1301 is for entering the upper limit of the proof tree depth. Input field 1302 is for entering the upper limit of the leaf nodes to be included in the proof tree. Input field 1303 is for entering the conditions of the logical expression. The execute button 1304 is an operation button for instructing the execution of the training data generation process.

[0095] In some cases, it may be difficult for the user to determine the proof tree generation conditions. In such cases, screens 1400 and 1500, as shown in Figures 14 and 15, are presented.

[0096] Screen 1400 is a screen for setting proof tree generation conditions based on resource requirements for computer 100. Screen 1400 includes an input area 1401 and a display area 1402. Input area 1401 is for inputting resource requirements, and display area 1402 is for displaying proof tree generation conditions.

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

[0098] Computer 100 holds conversion information 1600 as shown in Figure 16. The conversion information 1600 stores entries that include resource conditions 1601 and proof tree generation conditions 1602. When the conversion button 1413 is operated, computer 100 refers to the conversion information 1600 and searches for an entry in which the resource condition 1601 matches the resource condition entered in the input area 1401. Computer 100 displays the proof tree generation conditions in the display area 1402 based on the proof tree generation conditions 1602 of the found entry. The user modifies the proof tree generation conditions displayed in the display area 1402 as needed. The user also operates the execute button 1421 in the display area 1402 to instruct the execution of the training data generation process.

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

[0100] Input area 1501 includes input field 1511 and conversion button 1512. Input field 1411 is a field for inputting data for logical inference handled by the task. Conversion button 1512 is an operation button for instructing the conversion of data for logical inference handled by the task into 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. Possible methods for converting the logical inference data into a proof tree include known syntactic analysis / argument mining techniques. Alternatively, 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. The user modifies the proof tree generation conditions displayed in display area 1502 as needed. The user also operates the execute button 1521 in display area 1502 to instruct the execution of the training data generation process.

[0103] The proof tree generation process in Example 2 will now be explained.

[0104] The processing from steps S201 to S203 is the same as in Example 1. In step S203, a search for connectable proof trees is performed based on the proof tree generation conditions. The processing from steps S204 and S205 is the same as in Example 1.

[0105] After processing in step S205, the proof tree generation unit 130 determines whether to terminate the search based on the proof tree generation conditions (step S251). For example, if the newly generated proof tree depth matches the upper limit, it is determined to terminate the search.

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

[0107] According to Example 2, a proof tree desired by the user can be generated. This is expected to reduce the load, shorten the computation time, and improve the accuracy of the model.

[0108] It should be noted that the present invention is not limited to the embodiments described above, and various modifications are included. Furthermore, for example, the embodiments described above are detailed explanations of the configuration in order to clearly illustrate the present invention, and are not necessarily limited to those having all the configurations described. In addition, some of the configurations in each embodiment can be added to, deleted from, or replaced with other configurations.

[0109] Furthermore, each of the above-mentioned configurations, functions, processing units, processing means, etc., may be implemented in hardware, in whole or in part, for example, by designing them as integrated circuits. The present invention can also be implemented by software program code that realizes the functions of the embodiment. In this case, a storage medium on which the program code is recorded is provided to a computer, and the processor of that computer reads the program code stored in the storage medium. In this case, the program code read from the storage medium itself realizes the functions of the embodiment described above, and the program code itself and the storage medium on which it is stored constitute the present invention. Examples of storage media used to supply 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, and the like.

[0110] Furthermore, the program code that implements the functions described in this embodiment can be implemented in a wide range of programming or scripting languages, such as assembler, C / C++, Perl, Shell, PHP, Python, and Java (registered trademark).

[0111] Furthermore, the program code for the software that implements the functions of the embodiment may be distributed via 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 computer's processor may read and execute the program code stored in the storage means or storage medium.

[0112] In the above-described embodiment, the control lines and information lines shown are those deemed necessary for explanation and do not necessarily represent all control lines and information lines in the actual product. All components may be interconnected. [Explanation of Symbols]

[0113] 100 calculator 101 Processors 102 Main storage 103 Secondary storage device 104 Network Interfaces 105 Input device 106 Output device 110 Training Data Generation Unit 111 Learning Department 112 Task Execution Unit 120 Argumentation Data Database 121 Translation Template Database 122 dictionaries 123 Training Data Database 124 Model Information 130 Proof Tree Generation Unit 131 Translation Department 132 Text Output Section 1300, 1400, 1500 screens 1600 conversion information

Claims

1. A computing system that generates training data used for training a model that performs logical inference, Equipped with at least one computer, It stores argumentation data that represents an argument that derives a conclusion from multiple premise propositions, The aforementioned proposition can be expressed as a logical formula, The aforementioned at least one computer is By searching for and combining argument data in which the aforementioned proposition, which is a premise of the aforementioned argument data, is the conclusion, or argument data in which the aforementioned proposition, which is the conclusion of the aforementioned argument data, is a premise, proof data is generated that represents a proof that derives a conclusion proposition by repeating the argument multiple times. The aforementioned proof data is converted into text that represents it as a linguistic expression. A computer system characterized by generating the training data using the aforementioned text.

2. A computer system according to claim 1, The aforementioned at least one computer is Using the aforementioned argumentation data, a proof tree is generated, which is a tree structure data where the premise propositions are leaf nodes and the conclusion propositions are root nodes. Using the proof tree, search for the argument data in which the proposition that is a 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 a premise. A computer system characterized by generating proof data by combining a plurality of proof trees based on the results of the search.

3. A computer system according to claim 2, The aforementioned logical formula is written using variables representing propositions, or using the aforementioned variables and logical symbols. The aforementioned computer system manages templates that associate logical formulas and sentences containing the aforementioned logical symbols, The aforementioned at least one computer is The variables in the logical expression containing only the variables in the proof data are output as a sentence. The logical expression containing the logical symbols in the proof data is converted into a sentence using the template. Convert the aforementioned logical expression into a string, and include the aforementioned variable in the converted sentence. A computer system characterized by generating the text consisting of sentences obtained by transforming a plurality of logical formulas contained in the proof data.

4. A computer system according to claim 2, The aforementioned at least one computer is The user provides the conditions for generating the aforementioned proof data. A computer system characterized by generating the proof data based on the conditions for generating the proof data.

5. A computer system according to claim 4, The aforementioned at least one computer is The system receives information from the user regarding the amount of resources available to the computer system. Based on the amount of resources in the aforementioned computer system, the conditions for generating the proof data are determined. A computer system characterized by presenting the conditions for generating the determined proof data.

6. A computer system according to claim 4, The aforementioned at least one computer is The user provides information about the data handled by the model trained using the aforementioned training data. The model trained using the aforementioned training data analyzes the data it handles. Based on the results of the above analysis, the conditions for generating the proof data are determined. A computer system characterized by presenting the conditions for generating the determined proof data.

7. A computer system according to claim 2, A computer system characterized by performing at least one of the following: a learning process that generates a model for performing an arbitrary task using the aforementioned training data, and a task execution process that uses the aforementioned model.

8. A method for generating training data used to train a logical inference model executed by a computer system, The aforementioned computer system, Equipped with at least one computer, It stores argumentation data that represents an argument that derives a conclusion from multiple premise propositions, The aforementioned proposition can be expressed as a logical formula, The method for generating the aforementioned training data is: A first step in which at least one computer searches for and combines argument data in which the proposition that is a premise of the argument data is the conclusion, or argument data in which the proposition that is the conclusion of the argument data is a premise, thereby generating proof data that represents a proof that derives a conclusion proposition by repeating the argument multiple times. The second step involves at least one computer converting the proof data into text that represents it as a linguistic expression, A method for generating training data, characterized in that at least one computer generates the training data using the text.

9. A method for generating learning data according to claim 8, The first step described above is: The steps include: the at least one computer generating a proof tree, which is a tree structure data in which the premise propositions are leaf nodes and the conclusion propositions are root nodes, using the argumentation data; The steps include: the at least one computer using the proof tree to search for 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 a premise; A method for generating training data, characterized in that at least one computer generates proof data by combining a plurality of proof trees based on the results of the search.

10. A method for generating learning data according to claim 9, The aforementioned logical formula is written using variables representing propositions, or using the aforementioned variables and logical symbols. The aforementioned computer system manages templates that associate logical formulas and sentences containing the aforementioned logical symbols, The second step described above is: The steps include: the at least one computer outputting the variables of the logical formula, which includes only the variables of the proof data, as a sentence; The steps include: the at least one computer converting the logical expression containing the logical symbols of the proof data into a sentence using the template; The steps include: the at least one computer converting the variables included in the sentence into which the logical expression has been converted into a string; A method for generating training data, characterized in that at least one computer generates the text consisting of sentences obtained by transforming a plurality of logical formulas contained in the proof data.

11. A method for generating learning data according to claim 9, The steps include: the at least one computer receiving the conditions for generating the proof data from the user; A method for generating training data, characterized in that at least one computer generates the proof data based on the conditions for generating the proof data.

12. A method for generating learning data according to claim 11, The steps include: the at least one computer receiving information from a user regarding the amount of resources available in the computer system; The steps include: the at least one computer determining the conditions for generating the proof data based on the amount of resources in the computer system; A method for generating training data, characterized in that at least one computer presents the determined conditions for generating the proof data.

13. A method for generating learning data according to claim 11, The steps include: the at least one computer receiving information from a user about the data handled by a model trained using the training data; The steps include: at least one computer analyzing data handled by a model trained using the training data; The steps include: the at least one computer determining the conditions for generating the proof data based on the results of the analysis; A method for generating training data, characterized in that at least one computer presents the determined conditions for generating the proof data.

14. A method for generating learning data according to claim 9, A method for generating training data, characterized in that at least one computer performs at least one of the following steps: a training process that generates a model for performing an arbitrary task using the text, and a task execution process that uses the model.

Images