Estimating program, estimating program, and information processing device

Abstract

According to the present invention, a cause of an event indicated by input text is estimated.　An information processing device (10) generates knowledge graphs (14a, 14b), in which a plurality of entities indicating different events are connected in a causal relationship, on the basis of texts (13a, 13b). The information processing device (10) generates a knowledge graph (15) by integrating some of the plurality of entities between the knowledge graphs (14a, 14b). The information processing device (10) uses the knowledge graph (15) to estimate a cause event corresponding to a result event indicated by input text (16).

Description

Estimation Method, Estimation Program, and Information Processing Apparatus

[0001] The present invention relates to an estimation method, an estimation program, and an information processing apparatus.

[0002] There are times when a computer wants to estimate the cause corresponding to a newly occurred event using a knowledge database that records past cases. For example, a computer may want to estimate the cause corresponding to a newly occurred failure using a knowledge database that records past failure cases of an information processing system. By the computer assisting in failure cause analysis, it is expected that the recovery of the information processing system from failures will be accelerated.

[0003] In addition, there is a technique of generating a connection graph showing the relationships of a plurality of components included in an information processing system in response to the detection of an abnormality, calculating the score of each component using the connection graph, and identifying the root cause of the abnormality using the score. There is also a technique of processing text by using a neural network and a knowledge graph in combination. There is also a technique of analyzing a knowledge graph using a neural network. There is also a technique of generating a knowledge graph and analyzing the root cause of an event using the knowledge graph.

[0004] U.S. Patent Application Publication No. 2020 / 0293917, International Publication No. 2021 / 120543, International Publication No. 2022 / 219435, U.S. Patent Application Publication No. 2023 / 0050889

[0005] However, it is difficult for a computer to effectively utilize the knowledge obtained from the entire plurality of past cases by simply referring to the texts describing the past cases individually. Therefore, there is room for improvement in the support for cause analysis by a computer. Thus, in one aspect, the present invention aims to estimate the cause of an event indicated by an input text.

[0006] In one aspect, the present invention provides an estimation method in which a computer performs the following steps: generate multiple first knowledge graphs, which are knowledge graphs that connect multiple entities representing different events through causal relationships based on multiple first texts; generate a second knowledge graph by integrating some of the entities among the multiple first knowledge graphs; and use the second knowledge graph to estimate the causal events corresponding to the resulting events indicated by the input second texts.

[0007] In one respect, it is possible to estimate the cause of the events indicated by the input text.

[0008] This is a diagram illustrating the information processing device of the first embodiment. This is a diagram showing an example of the hardware of the information processing device of the second embodiment. This is a diagram showing the first example of a case document. This is a diagram showing the first example of a causal knowledge graph. This is a diagram showing the first example of a cause investigation screen. This is a diagram showing an example of applying a logical AND to a causal knowledge graph. This is a diagram showing the second example of a case document. This is a diagram showing the second example of a causal knowledge graph. This is a diagram showing the second example of a cause investigation screen. This is a diagram showing an example of the structure of a large-scale language model. This is a diagram showing the third example of a case document. This is a diagram showing an example of input / output data for a large-scale language model. This is a diagram showing an example of input / output data for a large-scale language model (continued 1). This is a diagram showing an example of input / output data for a large-scale language model (continued 2). This is a block diagram showing an example of the functions of the information processing device. This is a flowchart showing an example of the procedure for cause estimation.

[0009] Hereinafter, this embodiment will be described with reference to the drawings. (a) First Embodiment Figure 1 is a diagram illustrating the information processing device of the first embodiment. The information processing device 10 of the first embodiment generates a knowledge graph showing the causal relationships between events and estimates the cause corresponding to a certain event. The information processing device 10 may be, for example, a client device or a server device. The information processing device 10 may also be called, for example, a computer or an estimation device.

[0010] The information processing device 10 includes a storage unit 11 and a processing unit 12. The storage unit 11 may be a volatile memory such as RAM (Random Access Memory). Alternatively, the storage unit 11 may be a non-volatile storage such as an HDD (Hard Disk Drive) or SSD (Solid State Drive).

[0011] The processing unit 12 is a processor, such as a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), or a DSP (Digital Signal Processor). However, the processing unit 12 may also include electronic circuits such as an ASIC (Application Specific Integrated Circuit) or an FPGA (Field Programmable Gate Array). The processor executes a program stored in memory, such as RAM. The processor is sometimes called a processor circuit. A collection of processors is sometimes called a multiprocessor or simply a "processor." Different processing steps among multiple processing steps may be executed by different processors.

[0012] The memory unit 11 stores multiple texts, such as texts 13a and 13b. Texts 13a and 13b are each case texts that describe past cases in natural language and include descriptions of multiple events that have a causal relationship. For example, texts 13a and 13b are each failure case texts that describe past failure cases that occurred in the information processing system in natural language and include descriptions of multiple events related to the cause and effect of the failure. The information processing system may be a network system that provides communication services.

[0013] Multiple events may include events that represent the final result, events that are the root cause of the final result, and intermediate events that occurred in the process leading from the root cause to the final result. The chain of causal relationships from the root cause to the final result is not necessarily linear, but may have branches. Also, there may not be just one root cause or final result. Due to the nature of natural language, these events are not written according to a strict format.

[0014] The processing unit 12 generates multiple knowledge graphs, such as knowledge graphs 14a and 14b, based on multiple texts stored in the storage unit 11. The processing unit 12 may also generate one knowledge graph from text that describes one case. For example, knowledge graph 14a is generated from text 13a, and knowledge graph 14b is generated from text 13b.

[0015] Knowledge graphs 14a and 14b, respectively, connect multiple entities representing different events through causal relationships. Knowledge graphs can be represented using nodes representing entities and directed edges representing causal relationships between entities. Knowledge graphs can also be represented as a list of causal relationships where one event causes another. Furthermore, knowledge graphs can be described using descriptive languages ​​such as JSON (JavaScript Object Notation) or RDF (Resource Description Framework).

[0016] Knowledge graphs 14a and 14b may contain entities that represent substantially the same events. For example, knowledge graph 14a shows a causal relationship in which event A1 causes event B, and event B causes event C1. Knowledge graph 14b also shows a causal relationship in which event A2 causes event B, and event B causes event C2.

[0017] In generating knowledge graphs 14a and 14b, the processing unit 12 extracts events from texts 13a and 13b using natural language processing. At this time, the processing unit 12 may use a machine learning model trained by machine learning, or it may use a natural language processing model such as a so-called large language model (LLM). For example, the processing unit 12 inputs text 13a into the natural language processing model, causing the natural language processing model to extract events A1, B, and C1. The processing unit 12 also inputs text 13b into the natural language processing model, causing the natural language processing model to extract events A2, B, and C2.

[0018] The processing unit 12 integrates the above-mentioned multiple knowledge graphs to generate a knowledge graph 15. The knowledge graph 15 comprehensively represents the causal relationships extracted from multiple cases and functions as a knowledge database that accumulates insights obtained from all of the multiple cases. At this time, the processing unit 12 integrates some entities between the multiple knowledge graphs. The entities to be integrated are, for example, entities that represent substantially the same event. The processing unit 12 may use a machine learning model, such as a natural language processing model, for this integration.

[0019] For example, the processing unit 12 integrates event B in knowledge graph 14a and event B in knowledge graph 14b. As a result, knowledge graphs 14a and 14b are linked to generate knowledge graph 15. Knowledge graph 15 shows a causal relationship in which event A1 causes event B, and event A2 causes event B. Knowledge graph 15 also shows a causal relationship in which event B causes event C1, and event B causes event C2.

[0020] Knowledge Graph 15 may show a chain of causal relationships that do not directly appear in the text describing individual events. For example, Knowledge Graph 15 suggests that event A1 may cause event C2 via event B. Also, Knowledge Graph 15 suggests that event A2 may cause event C1 via event B.

[0021] The processing unit 12 receives text 16. Text 16 indicates the resulting event. Text 16 may also indicate a malfunction caused by a newly occurring failure in the information processing system. Text 16 may include a question asking for the cause of the event corresponding to the resulting event.

[0022] Upon receiving text 16, the processing unit 12 uses the knowledge graph 15 to estimate the causal event corresponding to the resulting event indicated by text 16. For example, the processing unit 12 extracts the resulting event from text 16 and searches for an entity representing that resulting event in the knowledge graph 15. On the knowledge graph 15, the processing unit 12 searches for an entity representing the root cause by tracing the causal relationship backward from the entity representing the resulting event. The processing unit 12 may use machine learning models such as natural language processing models to extract the resulting event from text 16 and to search for causal events on the knowledge graph 15.

[0023] The processing unit 12 outputs information indicating the causative event. The processing unit 12 may store the information indicating the causative event in non-volatile storage, display it on a display device, or transmit it to another information processing device. For example, text 16 indicates event C1 as the resulting event. In that case, the processing unit 12 searches the knowledge graph 15 for an entity indicating event C1, traces from event C1 to event B, and from event B to events A1 and A2. As a result, the processing unit 12 suggests that the root cause of event C1 may be event A1 or event A2.

[0024] As described above, the information processing device 10 of the first embodiment generates multiple first knowledge graphs, which are knowledge graphs that connect multiple entities representing different events in a causal relationship, based on a plurality of first texts. The information processing device 10 generates a knowledge graph 15 by integrating some of the entities among the plurality of first knowledge graphs. The information processing device 10 uses the knowledge graph 15 to estimate the causal event corresponding to the result event indicated by the input text 16.

[0025] As a result, the information processing device 10 can support root cause analysis, such as fault cause analysis, and can expedite the response to the resulting events. Furthermore, since the information processing device 10 converts text written in natural language about past cases into a knowledge graph, it can easily integrate insights from multiple cases. Therefore, the information processing device 10 can utilize multiple texts across different sources, improving the accuracy of root cause analysis compared to referring to texts individually.

[0026] (b) Figure 2 of the second embodiment shows an example of the hardware of the information processing device of the second embodiment. The information processing device 100 of the second embodiment generates a causal knowledge graph showing the causal relationships between events from a case document in which the case is described in natural language. The information processing device 100 also uses the causal knowledge graph to estimate the root cause corresponding to a new event. However, the generation of the causal knowledge graph and the estimation of the root cause may be performed by different information processing devices. The information processing device 100 corresponds to the information processing device 10 of the first embodiment.

[0027] The information processing device 100 includes a CPU 101, RAM 102, HDD 103, GPU 104, input interface 105, media reader 106, and communication interface 107. The CPU 101 corresponds to the processing unit 12 of the first embodiment. The RAM 102 or HDD 103 corresponds to the storage unit 11 of the first embodiment.

[0028] The CPU 101 is a processor that executes program instructions. The CPU 101 loads the program and data from the HDD 103 into the RAM 102 and executes the program. The information processing device 100 may have multiple processors.

[0029] RAM 102 is a volatile semiconductor memory that temporarily stores programs executed by the CPU 101 and data used for calculations by the CPU 101. The information processing device 100 may have a type of volatile memory other than RAM.

[0030] The HDD 103 is a non-volatile storage device that stores software programs such as operating systems, middleware, and application software, as well as data. The information processing device 100 may also have other types of non-volatile storage, such as an SSD or flash memory.

[0031] The GPU 104 works in conjunction with the CPU 101 to perform image processing and outputs the image to the display device 111 connected to the information processing device 100. The display device 111 is, for example, a CRT (Cathode Ray Tube) display, a liquid crystal display, an organic EL (Electro Luminescence) display, or a projector.

[0032] Furthermore, the GPU 104 may be used as a GPGPU (General Purpose Computing on Graphics Processing Unit). The GPU 104 can execute programs in response to instructions from the CPU 101. The information processing device 100 may have a volatile semiconductor memory other than RAM 102 as GPU memory.

[0033] The input interface 105 receives input signals from an input device 112 connected to the information processing device 100. The input device 112 is, for example, a mouse, a touch panel, or a keyboard. Multiple input devices may be connected to the information processing device 100.

[0034] The media reader 106 is a reading device that reads programs and data recorded on the recording medium 113. The recording medium 113 is, for example, a magnetic disk, an optical disk, or semiconductor memory. Magnetic disks include flexible disks (FDs) and HDDs. Optical disks include CDs (Compact Discs) and DVDs (Digital Versatile Discs). The media reader 106 copies the programs and data read from the recording medium 113 to other recording media such as RAM 102 or HDD 103. The read programs may be executed by the CPU 101.

[0035] The recording medium 113 may be a portable recording medium. The recording medium 113 may be used for distributing programs and data. The recording medium 113 and HDD 103 may also be referred to as computer-readable recording media.

[0036] The communication interface 107 communicates with other information processing devices via the network 114. The communication interface 107 may be a wired communication interface connected to a wired communication device such as a switch or router, or it may be a wireless communication interface connected to a wireless communication device such as a base station or access point.

[0037] In the second embodiment, the example mainly assumes a failure in a wireless communication network. A wireless communication network may include various types of components, and these components may be from different vendors. For example, multiple antenna base stations (RUs: Radio Units) may be connected to a base station control unit (DU: Distributed Unit), and an RU from one vendor may be connected to a DU from a different vendor. In this case, a failure may occur in the connection between the RU and the DU.

[0038] In wireless communication networks, the increasing complexity of the configuration can lead to a diversification of failure causes. For example, a failure in RU / DU connectivity can have various causes, such as hardware failure, hardware incompatibility, software incompatibility, or incorrect identifier settings. Therefore, the information processing device 100 supports failure cause analysis.

[0039] Figure 3 shows a first example of a case document. The information processing device 100 has a case database 130. The case database 130 stores multiple case documents. Each case document contains one or more case texts describing a failure case in natural language. If a single case document contains case texts for two or more failure cases, those case texts are separated.

[0040] Case study texts are created by engineers when a failure occurs. These texts include descriptions of the malfunctions caused by the failure. They also include descriptions of the root cause of the failure as determined through the recovery process. Case study texts may include descriptions of phenomena observed regarding components of the wireless communication network during the recovery process. Furthermore, case study texts may include descriptions of the root cause analysis and recovery work performed by the engineers.

[0041] Furthermore, the case text may include log strings extracted from log files output by components of the wireless communication network. These log strings are sections of the log file that engineers have determined to be relevant to the fault and useful for understanding the fault. Due to the dependencies between multiple components included in a wireless communication network, various events may occur in a chain reaction. Therefore, the case text may explicitly or implicitly explain the chain of causal relationships between multiple events.

[0042] For example, case database 130 stores case documents 131 and 132. Case document 131 describes a malfunction in which router A becomes overloaded. Case document 131 also describes a phenomenon in which retransmissions frequently occurred between router A and device B. Case document 131 also describes the root cause as cable degradation.

[0043] Case study document 132 describes a malfunction in device B where data transmission is impossible. Case study document 132 also describes a phenomenon where retransmissions occur frequently between router A and device B. Furthermore, case study document 132 describes the root cause as a configuration error in item X. The information processing device 100 generates a causal knowledge graph from the case study database 130 in order to utilize the knowledge obtained from these multiple case study documents in a cross-sectional manner.

[0044] FIG. 4 is a diagram showing a first example of a causal knowledge graph. The causal knowledge graph 141 is generated from the above-described case documents 131 and 132. The causal knowledge graph 141 is a directed graph including nodes indicating events and directed edges indicating relationships between events. The causal knowledge graph 141 includes nodes 141a, 141b, 141c, 141d, and 141e.

[0045] Node 141a indicates an event of cable deterioration. Node 141b indicates an event of a setting error of item X. Node 141c indicates an event of frequent retransmission between router A and device B. Node 141d indicates an event of router A being in an overload state. Node 141e indicates an event of data transmission being impossible at device B. The document names of case document 131 are added to nodes 141a, 141c, and 141d to indicate that they are events described in case document 131. Similarly, the document names of case document 132 are added to nodes 141b, 141c, and 141e.

[0046] The causal knowledge graph 141 shows a causal relationship that the event of node 141a causes the event of node 141c. Also, the causal knowledge graph 141 shows a causal relationship that the event of node 141b causes the event of node 141c. Also, the causal knowledge graph 141 shows a causal relationship that the event of node 141c causes the event of node 141d. Also, the causal knowledge graph 141 shows a causal relationship that the event of node 141c causes the event of node 141e.

[0047] By generating the causal knowledge graph 141 from a plurality of failure cases, the causal knowledge graph 141 may show potential causal relationships that are not known from individual failure cases. For example, in the failure case described in case document 131, cable deterioration causes an overload of router A. Also, in the failure case described in case document 132, a setting error of item X causes data transmission to be impossible at device B.

[0048] However, both cable degradation and the misconfiguration of item X cause the same intermediate event. Therefore, potentially, cable degradation may cause data transmission failure of device B, and the misconfiguration of item X may cause overload of router A. Thus, the causal knowledge graph 141 shows cross-cutting findings obtained from multiple failure cases.

[0049] FIG. 5 is a diagram showing a first example of a cause investigation screen. The information processing apparatus 100 supports an engineer in analyzing the cause of a failure by using the causal knowledge graph 141. The information processing apparatus 100 displays a cause investigation screen 150 on the display device 111. The engineer inputs a message 151 on the cause investigation screen 150. The message 151 is a query text for asking about the cause of the router being in an overloaded state.

[0050] The information processing apparatus 100 identifies a node 141d indicating the event described in the message 151 from the causal knowledge graph 141. The information processing apparatus 100 searches for the most upstream node that cannot be traversed further by tracing the edges in the reverse direction from the node 141d. The most upstream node indicates an event corresponding to the root cause. Here, nodes 141a and 141b are detected from the causal knowledge graph 141.

[0051] The information processing apparatus 100 generates a message 152 and displays it on the cause investigation screen 150. The message 152 is a response text indicating that the cable degradation indicated by the node 141a and the misconfiguration of item X indicated by the node 141b are candidates for the cause of the failure. The message 152 includes the document names added to the nodes 141a and 141b in order to show the basis of the cause estimation. The message 152 presents the document name of the case document 131 for the cable degradation and the document name of the case document 132 for the misconfiguration of item X.

[0052] If case documents 131 and 132 are referred to individually, the information processing device 100 will only present cable degradation, as described in case document 131, as the cause of router overload. In contrast, by using the causal knowledge graph 141, the information processing device 100 can present a potential cause of failure, namely a misconfiguration of item X.

[0053] Next, the procedure for generating a causal knowledge graph will be described. The information processing device 100 generates a causal knowledge graph using a large-scale language model, which is a type of machine learning model. The large-scale language model is a generative natural language processing model that receives prompt text and outputs response text corresponding to the prompt text.

[0054] First, the information processing device 100 extracts multiple case texts from the case database 130, each representing a single failure case. If the case documents are written in a specific format, the information processing device 100 may determine the range of text representing a single failure case according to that format. Alternatively, the information processing device 100 may have a large-scale language model determine the boundaries of the case texts.

[0055] For example, the information processing device 100 generates prompt text that includes the text contained in the case document and an instruction statement indicating that the text should be divided into individual failure cases. The information processing device 100 inputs the prompt text into a large-scale language model and obtains response text from the large-scale language model that indicates the divided case text.

[0056] Next, the information processing device 100 generates a causal knowledge graph for each case text, corresponding to one failure case. At this time, the information processing device 100 extracts the causal event, intermediate events, and final event from the case text, and extracts the causal relationships between these multiple events from the case text. The final event corresponds to the final defect caused by the failure. The causal event corresponds to the root cause of the failure. The intermediate event corresponds to an intermediate event that occurred at an intermediate stage in the chain of causal relationships from the causal event to the final event.

[0057] The information processing device 100 extracts causal events, intermediate events, and final events using a large-scale language model. For example, the information processing device 100 generates prompt text that includes case text and instruction sentences indicating instructions to extract causal events, intermediate events, and final events. The information processing device 100 inputs the prompt text into the large-scale language model and obtains response text indicating causal events, intermediate events, and final events from the large-scale language model. The information processing device 100 may extract causal events, intermediate events, and final events in multiple steps.

[0058] Furthermore, the information processing device 100 uses a large-scale language model to extract causal relationships between causal events, intermediate events, and final events. For example, the information processing device 100 specifies case text, causal events, intermediate events, and final events, and generates prompt text that includes an instruction to extract causal relationships. The information processing device 100 inputs the prompt text into the large-scale language model and obtains response text indicating causal relationships from the large-scale language model. However, the information processing device 100 may perform the extraction of some or all of the causal events, intermediate events, and final events and the extraction of causal relationships as a single procedure.

[0059] Next, the information processing device 100 converts the causal events, intermediate events, and final events and their causal relationships into a data format for a causal knowledge graph. For example, the information processing device 100 outputs the causal knowledge graph as JSON data. The information processing device 100 may also convert the data format using a large-scale language model. For example, the information processing device 100 generates prompt text that includes a list of causal relationships and an instruction statement that instructs conversion to JSON format. The information processing device 100 inputs the prompt text into the large-scale language model and obtains response text containing JSON data from the large-scale language model.

[0060] Next, the information processing device 100 integrates multiple causal knowledge graphs generated from multiple case texts. At this time, the information processing device 100 detects nodes that indicate the same event among the multiple causal knowledge graphs. The information processing device 100 generates an integrated causal knowledge graph by replacing the multiple nodes indicating the same event with a single node.

[0061] Furthermore, large-scale language models may determine logical AND or OR relationships between a single event and multiple events described in a single case text. For example, a large-scale language model may determine a logical AND causal relationship such as "Event A causes Events B and C." Alternatively, a large-scale language model may determine a logical OR causal relationship such as "Event D or Event E causes Event F."

[0062] Including such logical information in the causal knowledge graph can improve the accuracy of estimating the cause of a failure. Therefore, the information processing device 100 may add logical AND or OR information output by the large-scale language model to the causal knowledge graph.

[0063] Figure 6 shows an example of applying a logical AND operation to a causal knowledge graph. The causal knowledge graph 142 includes nodes 142a, 142b, 142c, 142d, 142e, and 142f. The causal knowledge graph 142 also includes edges from node 142a to node 142b, from node 142c to node 142d, from node 142b to node 142e, and from node 142d to nodes 142e and 142f.

[0064] The edges from node 142d to node 142e and from node 142d to node 142f are labeled to indicate that these two causal relationships are joined by a logical AND. Therefore, the causal knowledge graph 142 shows that the intermediate event of frequent retransmissions between router A and device B causes both the final event of router A becoming overloaded and the final event of device B being unable to transmit data.

[0065] The information processing device 100 may narrow down the cause of the failure by referring to logical AND and logical OR labels, or it may prioritize the candidate causes of the failure. For example, suppose the message entered by the engineer states that the router is overloaded, but does not state that the device is unable to transmit data. In this case, the information processing device 100 may determine, according to the causal knowledge graph 142, that the probability of an intermediate event such as frequent retransmissions between the router and the device occurring is low.

[0066] The information processing device 100 may suppress the tracing of causal relationships from node 142e to node 142d, thereby presenting only the cable degradation indicated by node 142a and not presenting the setting error for item X indicated by node 142c. Alternatively, the information processing device 100 may present both the cable degradation and the setting error for item X, and then explicitly indicate that the cable degradation has a higher priority and the setting error for item X has a lower priority.

[0067] Furthermore, the information processing device 100 may extract other events from the case text. Other events are events that deviate from the causal relationship path from the causal event to the final event. Other events are events that were recognized during the fault recovery work but were not directly related to the malfunction. Such events may also be highly important in other fault cases.

[0068] The information processing device 100 may use a large-scale language model to extract other events. For example, the information processing device 100 specifies a case text, a causal event, an intermediate event, and a final event, and generates prompt text that includes an instruction to extract other events. The information processing device 100 inputs the prompt text into the large-scale language model and obtains response text indicating other events from the large-scale language model.

[0069] Furthermore, the information processing device 100 may extract log events from the case text. A log event indicates that a specific log string is included in the log file. A log event supports the occurrence of one of the following events: a causal event, an intermediate event, a final event, or other events. When a log event is extracted, in the causal knowledge graph, an edge indicating an indicative relationship is added from the node representing the log event to the node representing the event suggested by the log event.

[0070] The information processing device 100 may extract log events using a large-scale language model. For example, the information processing device 100 specifies a case text, a causal event, an intermediate event, a final event, and other events, and generates prompt text that includes an instruction to extract log events. The information processing device 100 inputs the prompt text into the large-scale language model and obtains response text indicating the log events from the large-scale language model.

[0071] The information processing device 100 may narrow down the cause of the failure by referring to log events, or it may prioritize candidate causes of the failure. For example, a message entered by an engineer may contain a log string extracted from a log file. When tracing the causal relationship path from the final event, the information processing device 100 may narrow down the path to the path associated with the log event corresponding to the entered log string. The information processing device 100 may also give a higher priority to the cause event reached by the path associated with the log event corresponding to the entered log string than to the cause event reached by other paths.

[0072] Furthermore, as shown in Figure 4, the information processing device 100 may add the document name of the case document from which the event indicated by the node was extracted to the node of the causal knowledge graph. When presenting candidate causal events, the information processing device 100 may output the document name added to the node of the causal event. This improves the explainability of causal estimation. In addition, engineers can refer to the original case document, improving convenience for engineers.

[0073] Furthermore, if a case document is added to the case database 130 after the causal knowledge graph has been generated, the information processing device 100 may update the causal knowledge graph. In this case, the information processing device 100 can generate a separate causal knowledge graph for the additional failure case and integrate the separate causal knowledge graph into the existing overall causal knowledge graph. This allows the information processing device 100 to easily maintain the causal knowledge graph in an up-to-date state.

[0074] Furthermore, in the second embodiment, the information processing device 100 generates a causal knowledge graph relating to failure cases in wireless communication networks, but it can also generate causal knowledge graphs relating to other types of cases. For example, the information processing device 100 may generate a causal knowledge graph relating to personnel interview cases. A causal knowledge graph generated from interview case documents created by interviewers is useful for analyzing causal events that affect evaluation results and can be used to improve the sense of satisfaction of interviewees and to educate interviewers. Next, another example of a causal knowledge graph will be described as a use case for failure cause analysis.

[0075] Figure 7 shows a second example of a case document. The case database 130 stores case documents 133 and 134. Case document 133 contains case text about a failure in which the application terminates immediately after startup. Case document 134 contains case text about a failure in which an error occurs when reading data for analysis.

[0076] Figure 8 shows a second example of a causal knowledge graph. The information processing device 100 generates a causal knowledge graph 143 from case documents 133 and 134. The causal knowledge graph 143 includes nodes 143a, 143b, 143c, 143d, 143e, 143f, 143g, 143h, 143i, and 143j.

[0077] Node 143a indicates the cause event of downloading via the internet. Node 143b indicates the intermediate event of an incompatible version. Node 143c indicates the log event of a startup error. Node 143d indicates the intermediate event of startup failure. Node 143e indicates the final event of forced termination. Node 143f indicates the cause event of automatic update setting being ON. Node 143g indicates the intermediate event of the UI application version being automatically updated. Node 143h indicates the log event of an incompatible version. Node 143i indicates the log event of a read error. Node 143j indicates the final event of a read error.

[0078] The event at node 143a triggers the event at node 143b. The event at node 143b triggers the events at nodes 143d and 143j. The event at node 143c suggests the event at node 143d. The event at node 143d triggers the event at node 143e. The event at node 143f triggers the event at node 143g. The event at node 143g triggers the event at node 143b. The event at node 143h suggests the event at node 143b. The event at node 143i suggests the event at node 143j.

[0079] The events in nodes 143a, 143b, 143c, 143d, and 143e were extracted from case document 133. The events in nodes 143b, 143f, 143g, 143h, 143i, and 143j were extracted from case document 134.

[0080] Figure 9 shows a second example of the cause investigation screen. The information processing device 100 accepts the input of message 153 on the cause investigation screen 150. Message 153 is a query text that inquires about the reason why the data for analysis cannot be read. The information processing device 100 detects node 143j from the causal knowledge graph 143, which indicates the final event described in message 153. The information processing device 100 traces the causal relationship in reverse from node 143j to reach nodes 143a and 143f, which indicate the causal events.

[0081] The information processing device 100 generates message 154 and displays it on the cause investigation screen 150. Message 154 is a response text that lists the cause event indicated by node 143f, which is "automatic update setting ON," and the cause event indicated by node 143a, which is "downloaded via the internet," as candidate causes of the failure.

[0082] The information processing device 100 may generate the response text to the query text using a large-scale language model. For example, the information processing device 100 specifies a causal knowledge graph and generates prompt text that includes the input query text and an instruction sentence that instructs the estimation of the causal event. The information processing device 100 inputs the prompt text into the large-scale language model and obtains response text that indicates the causal event.

[0083] Furthermore, for example, the information processing device 100 generates prompt text that includes the input query text and an instruction that instructs the extraction of the final event from the query text. The information processing device 100 inputs the prompt text into a large-scale language model and obtains response text indicating the extracted final event. Outside the large-scale language model, the information processing device 100 searches for a node indicating the final event from the causal knowledge graph and searches for a node indicating the causal event from the causal knowledge graph by following the edges.

[0084] Next, the structure and input / output data of the large-scale language model will be described. The large-scale language model may be a neural network or it may be implemented using a transformer with an attention mechanism. Transformers are also described in the following non-patent document: Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, and Lukasz Kaiser, "Attention Is All You Need", Proc. of the 31st International Conference on Neural Information Processing Systems (NIPS 2017), pages 6000-6010, December 2017.

[0085] Figure 10 shows an example of the structure of a large-scale language model. The large-scale language model 160 is an encoder-decoder type neural network. The large-scale language model 160 has embedding layers 161, 162, position coding layers 163, 164, encoder 165, decoder 166, linear layer 167, and softmax layer 168.

[0086] The embedding layer 161 converts each of the multiple words contained in the input text into a word vector called an embedding representation or distributed representation. A word vector is a numerical vector with a fixed number of dimensions, such as 512 or 1024 dimensions. Similar word vectors are assigned to words used in similar contexts. The correspondence between words and word vectors is determined by a neural network. The embedding layer 161 may be trained together with the other layers of the large-scale language model 160, or it may be pre-trained.

[0087] The embedding layer 162 converts each of the one or more words that have been determined so far from the words that should be included in the output text into a word vector. In the large-scale language model 160, the words that should be included in the output text are determined one by one from the beginning. The same correspondence between words and word vectors as in the embedding layer 161 is used.

[0088] The position encoding layer 163 adds a position vector corresponding to the word's position to the word vector output by the embedding layer 161. This addition of position vectors is sometimes called position encoding. The position vector is a numerical vector with the same number of dimensions as the word vector. For each of the multiple words in the input text, the position encoding layer 163 calculates the numerical values ​​for each dimension of the position vector using a sine function or cosine function, based on a non-negative integer indicating which word it is from the beginning.

[0089] The position coding layer 164 adds a position vector corresponding to the word's position to the word vector output by the embedding layer 162. The method for calculating the position vector is the same as that of the position coding layer 163. For each of the one or more words in the output text, the position coding layer 164 calculates the numerical values ​​for each dimension included in the position vector using a sine function or cosine function, based on a non-negative integer indicating the word's position from the beginning.

[0090] The encoder 165 transforms multiple vectors corresponding to multiple words. The encoder 165 includes, in order, a self-attention layer 165a, a normalization layer 165b, a feedforward layer 165c, and a normalization layer 165d. The large-scale language model 160 may have multiple encoders 165 stacked in series. In that case, the first encoder receives vectors from the position coding layer 163, and the last encoder outputs vectors to the decoder 166.

[0091] The self-attention layer 165a transforms vectors using an attention mechanism. The self-attention layer 165a has a query matrix, a key matrix, and a value matrix as trained parameter values. The self-attention layer 165a selects one word of interest from among multiple words contained in the input text.

[0092] The self-attention layer 165a transforms the vector of the word of interest using a query matrix to calculate a vector called the query. The self-attention layer 165a also transforms the vectors of multiple words using a key matrix to calculate a vector called the key. The self-attention layer 165a calculates the dot product of the query and the key as the attention score for each word. The attention score indicates the degree of relevance between the word of interest and each other word.

[0093] The self-attention layer 165a transforms the vectors of multiple words using a value matrix to calculate a vector called a value. The self-attention layer 165a uses the attention score as a weight to calculate a weighted sum of values ​​among multiple words, and outputs the calculated weighted sum as the transformed vector for the word of interest. The self-attention layer 165a repeats the above process while changing the word of interest.

[0094] The normalization layer 165b normalizes the vector output by the self-attention layer 165a so that the numerical values ​​for each dimension follow a constant distribution. The feedforward layer 165c is a forward neural network. The feedforward layer 165c transforms vectors of multiple words individually using trained parameter values. The normalization layer 165d normalizes the vector output by the feedforward layer 165c in the same way as the normalization layer 165b.

[0095] Decoder 166 converts the vectors of one or more words that have been determined so far from the words that should be included in the output text. Decoder 166 includes, in order, a self-attention layer 166a, a normalization layer 166b, an attention layer 166c, a normalization layer 166d, a feedforward layer 166e, and a normalization layer 166f. The large-scale language model 160 may have multiple decoders 166 stacked in series. In that case, the first decoder receives a vector from the position coding layer 164, and the last decoder outputs a vector to the linear layer 167.

[0096] The self-attention layer 166a transforms the vector using the same attention mechanism as the self-attention layer 165a. The query, key, and value are calculated from the word vectors of the output text. The normalization layer 166b normalizes the vector output by the self-attention layer 166a in the same way as the normalization layer 165b.

[0097] The attention layer 166c uses an attention mechanism to transform the word vectors of the output text. However, the attention layer 166c calculates the query from the word vectors of the output text and calculates the key and value from the word vectors of the input text. This allows the degree of relevance between the words in the output text and the words in the input text to be determined.

[0098] The attention layer 166c selects one word of interest from one or more words contained in the output text. The attention layer 166c calculates a query by transforming the vector of the word of interest using a query matrix. The attention layer 166c also receives vectors of multiple words contained in the input text from the encoder 165. The attention layer 166c calculates a key by transforming the vector of each word using a key matrix, and calculates a value by transforming the vector of each word using a value matrix.

[0099] The attention layer 166c calculates the dot product of the query and the key as an attention score for each word in the input text. The attention score indicates the degree of relevance between each word in the input text and the word in the output text of interest. The attention layer 166c uses the attention scores as weights to calculate a weighted sum of values ​​among multiple words in the input text. The attention layer 166c outputs the calculated weighted sum as a transformed vector for the word in the output text of interest.

[0100] The normalization layer 166d normalizes the vector output by the attention layer 166c in the same way as the normalization layer 165b. The feedforward layer 166e transforms the word vectors of the output text individually using the trained parameter values. The normalization layer 166f normalizes the vector output by the feedforward layer 166e in the same way as the normalization layer 165b.

[0101] The linear layer 167 uses the numerical values ​​contained in the vector output by the decoder 166 to calculate scores for various words listed in the dictionary. The words listed in the dictionary are words to which word vectors are assigned by the embedding layers 161 and 162. For example, the word vectors of the embedding layers 161 and 162 are referenced in the calculation of the scores.

[0102] The softmax layer 168 converts the scores of various words into probabilities between 0 and 1. The large-scale language model 160 selects one word according to the probability and adds the selected word to the end of the output text. The large-scale language model 160 generates the output text by repeating the process of the decoder 166 described above.

[0103] The large-scale language model 160 uses random numbers when selecting words for the output text to ensure diversity in the output text. The large-scale language model 160 randomly selects one word from several words in order of probability, starting with the words with the highest probability. Therefore, the word with the highest probability is not necessarily selected. The extent to which lower-ranking words are included as selection candidates is adjusted by the hyperparameters of the large-scale language model 160.

[0104] Figure 11 shows a third example of a case document. Case document 135 describes a failure case in which S-plane packets were not accepted by the RU. Case document 135 includes a description of the malfunction, the phenomena observed regarding the components of the wireless communication network, the work performed by the engineer, and the method used to resolve the failure. Case document 135 also includes log strings extracted by the engineer from the log file. In Figure 11, the log strings included in case document 135 are underlined.

[0105] Figure 12 shows an example of input and output data for a large-scale language model. First, the information processing device 100 generates prompt text 171a and inputs it to the large-scale language model 160. The prompt text 171a includes the case text described in the case document 135. The prompt text 171a also includes an instruction to extract the final event from this case text. Furthermore, the prompt text 171a includes a note indicating that multiple events described in the case text may be connected by a chain of causal relationships, and that only the final event should be extracted, and other events should not be extracted.

[0106] The large-scale language model 160 generates response text 171b from prompt text 171a. Response text 171b indicates two final events. The information processing device 100 receives response text 171b, generates prompt text 172a, and inputs it to the large-scale language model 160. Prompt text 172a includes an instruction that instructs the device to extract a causal event based on the previously input case text and the previously extracted final event. The large-scale language model 160 generates response text 172b from prompt text 172a. Response text 172b indicates one causal event.

[0107] Figure 13 is a diagram (continued 1) showing an example of input and output data for a large-scale language model. The information processing device 100 receives the response text 172b, generates prompt text 173a, and inputs it to the large-scale language model 160. The prompt text 173a includes an instruction that instructs the device to extract a list of causal relationships, including intermediate events, based on the previously input case text and the previously extracted causal and final events. The prompt text 173a also instructs the device to explicitly indicate logical AND or OR relationships if such relationships exist between multiple causal relationships.

[0108] Furthermore, prompt text 173a indicates, as a caution, that the case text may contain a chain of causal relationships in which a causal event triggers an intermediate event, which in turn triggers another intermediate event, and which in turn triggers a final event. Prompt text 173a also indicates that the causal event and the final event are indirectly connected. The number of intermediate events between the causal event and the final event, and the branching structure of the path between the causal event and the final event, vary depending on the case text. Based on the above caution, the information processing device 100 ensures that the large-scale language model 160 extracts intermediate events and causal relationships from the event text without omission. Note that in Figure 13, the above caution included in prompt text 173a is underlined.

[0109] The large-scale language model 160 generates response text 173b from prompt text 173a. Response text 173b represents one intermediate event and shows three causal relationships between one causal event, one intermediate event, and two final events. Response text 173b shows that the causal event causes the intermediate event, and that the intermediate event causes the two final events. Furthermore, response text 173b shows that the two causal relationships from the intermediate event to the two final events have a logical AND relationship.

[0110] Figure 14 is a diagram (continued 2) showing an example of input and output data for a large-scale language model. The information processing device 100 receives the response text 173b, generates prompt text 174a, and inputs it to the large-scale language model 160. The prompt text 174a includes an instruction that instructs the device to extract other events and add causal relationships to the list based on the previously input case text and the previously extracted list of causal relationships.

[0111] The large-scale language model 160 generates response text 174b from prompt text 174a. Response text 174b indicates four other events and shows seven causal relationships between one causal event, one intermediate event, two final events, and the four other events. The list shown in response text 174b is generated by adding causal relationships to the list shown in response text 173b.

[0112] Response text 174b, together with the two final events, indicates that the intermediate event triggers the first other event. Furthermore, response text 174b indicates that the intermediate event triggers the second other event, the second other event triggers the third other event, and the third other event triggers the fourth other event.

[0113] The information processing device 100 receives the response text 174b, generates prompt text 175a, and inputs it to the large-scale language model 160. The prompt text 175a includes an instruction that instructs the device to extract log events and add suggestive relationships to the list based on the previously input case text and the previously extracted list of causal relationships.

[0114] The large-scale language model 160 generates response text 175b from prompt text 175a. Response text 175b shows three log events and, in addition to the seven causal relationships shown in response text 174b, shows three suggestive relationships. Response text 175b indicates that the first log event suggests the first other event. Response text 175b also indicates that the second log event suggests the second other event. Response text 175b also indicates that the third log event suggests the third other event. The information processing device 100 converts response text 175b into a causal knowledge graph. Next, the functions and processing procedures of the information processing device 100 will be described.

[0115] Figure 15 is a block diagram showing an example of the functions of an information processing device. The information processing device 100 includes a document storage unit 121, a model storage unit 122, a graph storage unit 123, a model access unit 124, a case extraction unit 125, a graph generation unit 126, a graph integration unit 127, and a graph inference unit 128. The document storage unit 121, the model storage unit 122, and the graph storage unit 123 are implemented using, for example, a RAM 102 or an HDD 103. The model access unit 124, the case extraction unit 125, the graph generation unit 126, the graph integration unit 127, and the graph inference unit 128 are implemented using, for example, a CPU 101, a GPU 104, and a program.

[0116] The document storage unit 121 stores case documents. The document storage unit 121 corresponds to the case database 130. The model storage unit 122 stores large-scale language models. However, it is sufficient that the information processing device 100 can utilize the large-scale language models, and the large-scale language models may be stored in other information processing devices. The graph storage unit 123 stores causal knowledge graphs.

[0117] The model access unit 124 performs natural language processing to generate response text from prompt text using a trained large-scale language model stored in the model storage unit 122. However, the model access unit 124 may also use a large-scale language model stored in another information processing device. In that case, the model access unit 124 sends the prompt text to the other information processing device and receives the response text from the other information processing device.

[0118] The case extraction unit 125 reads case documents from the document storage unit 121 and extracts case text from the case documents that represent each failure case. The case extraction unit 125 may also generate prompt text for extracting case text and pass it to the model access unit 124, thereby obtaining the extracted case text from the model access unit 124.

[0119] The graph generation unit 126 obtains case text from the case extraction unit 125 and generates a causal knowledge graph for each case text. At this time, the graph generation unit 126 generates prompt text for extracting multiple events from the case text and passes it to the model access unit 124, and obtains a list of causal relationships and suggestive relationships between events from the model access unit 124. The graph generation unit 126 converts this list into the format of a causal knowledge graph.

[0120] The graph integration unit 127 obtains multiple causal knowledge graphs corresponding to multiple case texts from the graph generation unit 126. The graph integration unit 127 detects nodes that indicate the same event among the multiple causal knowledge graphs and integrates those nodes to generate an integrated causal knowledge graph. The graph integration unit 127 may also obtain a list of events to be integrated from the model access unit 124 by generating prompt text for determining the identity of events and passing it to the model access unit 124. The graph integration unit 127 stores the integrated causal knowledge graph in the graph storage unit 123.

[0121] The graph inference unit 128 receives a query text inquiring about the cause of the failure. The graph inference unit 128 generates prompt text to extract the final event from the query text and passes it to the model access unit 124, and retrieves the final event from the model access unit 124. The graph inference unit 128 searches for a node indicating the final event from the causal knowledge graph stored in the graph storage unit 123 and searches for a node indicating the causal event by tracing the causal relationship. The graph inference unit 128 generates and outputs an answer text indicating the estimated causal event. The graph inference unit 128 may save the answer text to non-volatile storage, display it on the display device 111, or transmit it to another information processing device.

[0122] Figure 16 is a flowchart illustrating an example of the procedure for causal estimation. In step S10, the case extraction unit 125 extracts multiple case texts from the case document group. In step S11, the graph generation unit 126 selects one case text. The graph generation unit 126 uses a large-scale language model to extract causal events, intermediate events, and final events from the case text. As described above, the graph generation unit 126 may also extract causal events, intermediate events, and final events through multiple queries to the large-scale language model.

[0123] In step S12, the graph generation unit 126 uses a large-scale language model to extract causal relationships between causal events, intermediate events, and final events from the case text. As described above, the graph generation unit 126 may extract causal relationships in conjunction with the extraction of some or all of the causal events, intermediate events, and final events, and steps S11 and S12 may be executed as a single unit. The graph generation unit 126 may also have the large-scale language model determine the logical AND or OR relationship between multiple causal relationships.

[0124] In step S13, the graph generation unit 126 extracts log events from the case text using a large-scale language model. The graph generation unit 126 may also use the large-scale language model to extract other events from the case text that are not directly related to the final event. In step S14, the graph generation unit 126 converts the extraction results from steps S11 to S13 for one case text into a causal knowledge graph format. The graph generation unit 126 may add labels indicating the logical AND or OR between multiple causal relationships determined by the large-scale language model to the edges of the causal knowledge graph. The graph generation unit 126 may also add the document name of the case document containing the case text to each node of the causal knowledge graph.

[0125] In step S15, the graph generation unit 126 determines whether all the case texts extracted in step S10 have been analyzed. If all the case texts have been analyzed, the process proceeds to step S16; if there are any case texts that have not been analyzed, the process returns to step S11. In step S16, the graph integration unit 127 integrates multiple causal knowledge graphs corresponding to multiple case texts to generate an integrated causal knowledge graph.

[0126] In step S17, the graph inference unit 128 receives the query text. In step S18, the graph inference unit 128 extracts the final event from the query text using a large-scale language model. In step S19, the graph inference unit 128 searches for the node of the final event from the causal knowledge graph generated in step S16 and searches for a node of a causal event that can reach the node of the final event by one or more edges.

[0127] In this case, the graph inference unit 128 may narrow down the nodes of the causal events by referring to labels indicating logical AND or logical OR, or it may determine the priority of nodes of multiple causal events. Alternatively, the graph inference unit 128 may narrow down the nodes of the causal events by referring to log events, or it may determine the priority of nodes of multiple causal events.

[0128] In step S20, the graph inference unit 128 generates and outputs answer text indicating the causal event. The graph inference unit 128 may also insert the document name attached to the node of the causal event into the answer text together with the string indicating the causal event.

[0129] As described above, the information processing device 100 of the second embodiment receives a query text inquiring about the cause of a failure, and outputs a response text indicating candidate causes of the failure, referring to past failure cases. This allows the information processing device 100 to support engineers in analyzing the cause of failures and to expedite the failure recovery process.

[0130] Furthermore, the information processing device 100 generates an integrated causal knowledge graph from multiple case texts corresponding to multiple failure cases. The information processing device 100 estimates the causal event corresponding to the final event by traversing edges on the causal knowledge graph. This allows the information processing device 100 to utilize cross-sectional insights obtained from all multiple failure cases, improving the accuracy of causal estimation compared to individually referring to the case texts. In addition, the causal knowledge graph includes nodes for intermediate events, as well as nodes for causal events and final events. Therefore, it becomes easy to integrate insights obtained from multiple failure cases.

[0131] Furthermore, the information processing device 100 adds document names to the nodes of the causal knowledge graph and inserts the document names into the response text as the basis for causal estimation. This improves the explainability of the estimation results and enhances convenience for engineers. In addition, the information processing device 100 adds labels to multiple edges of the same node that indicate the logical AND or OR relationship determined by the large-scale language model. The information processing device 100 refers to the edge labels to narrow down or prioritize the causal relationship paths. This allows the information processing device 100 to improve the accuracy of causal estimation.

[0132] Furthermore, the information processing device 100 extracts log events from the case text and adds suggestive relationships, indicating that the log events suggest other events, to the causal knowledge graph. The information processing device 100 refers to the nodes representing the log events and narrows down or prioritizes the causal relationship paths. This allows the information processing device 100 to improve the accuracy of cause estimation. In addition, the information processing device 100 does not fix the structure of the causal relationship between the causal event and the final event, but generates prompt text to flexibly extract the chain of causal relationships shown in the case text. This improves the accuracy of the causal knowledge graph.

[0133] 10 Information processing device 11 Storage unit 12 Processing unit 13a, 13b, 16 Text 14a, 14b, 15 Knowledge graph

Claims

1. An estimation method in which a computer performs a process that generates multiple first knowledge graphs, which are knowledge graphs that connect multiple entities representing different events in a causal relationship based on multiple first texts; generates a second knowledge graph by integrating some of the entities among the multiple first knowledge graphs; and uses the second knowledge graph to estimate the causal event corresponding to the resulting event indicated by the input second text.

2. The estimation method according to claim 1, wherein the process of generating the plurality of first knowledge graphs includes a process of inputting the plurality of first texts into a natural language processing model, thereby causing the natural language processing model to extract the plurality of entities and the causal relationships.

3. The estimation method according to claim 1, wherein the process for generating the plurality of first knowledge graphs includes extracting from each of the plurality of first texts a first causal relationship in which a first event causes a second event, and a second causal relationship in which the second event causes a third event.

4. The estimation method according to claim 1, wherein the process for generating the plurality of first knowledge graphs includes a process for associating each of the plurality of entities with a first text from among the plurality of first texts that includes the event represented by the entity, and the estimation process includes a process for outputting citation information that cites the first text associated with the entity that represents the event of the cause.

5. The estimation method according to claim 1, wherein the process of generating the plurality of first knowledge graphs includes a process of assigning logical information indicating a logical OR or logical AND to two or more causal relationships of the same entity, and the estimation process includes a process of using the logical information to narrow down the paths traceable from the entity representing the result event in the second knowledge graph.

6. The estimation method according to claim 1, wherein at least one of the plurality of first texts includes a log string output by an information processing system, the process of generating the plurality of first knowledge graphs includes the process of associating the log string with an entity indicating an event corresponding to the log string, and the estimation process includes the process of using the log string to narrow down the path traceable from the entity indicating the resulting event in the second knowledge graph.

7. The estimation method according to claim 1, wherein each of the plurality of first texts is a failure case text describing a failure in an information processing system and the cause of the failure.

8. An estimation program that causes a computer to perform the following processing: generating multiple first knowledge graphs, which are knowledge graphs that connect multiple entities representing different events in a causal relationship based on multiple first texts; generating a second knowledge graph by integrating some of the entities among the multiple first knowledge graphs; and using the second knowledge graph to estimate the causal events corresponding to the resulting events indicated by the input second texts.

9. An information processing device comprising: a storage unit for storing a plurality of first texts; a processing unit for generating a plurality of first knowledge graphs, which are knowledge graphs that connect a plurality of entities representing different events in a causal relationship based on the plurality of first texts; a processing unit for generating a second knowledge graph by integrating some of the entities among the plurality of entities in the plurality of first knowledge graphs; and a processing unit for estimating the causal event corresponding to the result event indicated by the input second text using the second knowledge graph.

Images