Method and apparatus for creating an executable process from a text description

Abstract

Methods, apparatus and products for creating executable processes from textual descriptions written in a natural language according to the present invention are described. A set of propositions is extracted from a text document written in a natural language. Based on the extracted set of propositions, a set of formulas is extracted from the text document. A state transition diagram is then created that includes a set of proposition value determination paths constrained by the set of formulas. The state transition diagram is converted into a software application.

Description

Technical Field

[0001] The field of the invention is data processing, or more specifically, methods, apparatus and products for creating executable procedures from textual descriptions written in a natural language. Background Art

[0002] The development of the EDVAC computer system in 1948 is often cited as the beginning of the computer age. Since that time, computer systems have evolved into extremely complex devices. Today's computers are much more complex than early systems such as the EDVAC. Computer systems typically include a combination of hardware and software components, application programs, operating systems, processors, buses, memory, input / output devices, etc. As advances in semiconductor processing and computer architecture have driven computers to higher and higher performance, more complex computer software has evolved to take advantage of the higher performance of the hardware, resulting in today's computer systems being much more powerful than they were just a few years ago.

[0003] Computers are increasingly used to automate tasks. However, certain tasks rely on documents written in natural language and therefore require human intervention. For example, when chatting with an assistant during an online help session, the assistant may be able to refer to a help manual or troubleshooting specifications. As another example, when calling an insurance agent regarding insurance coverage, the agent may have a policy document to reference in order to answer questions about coverage. In order to automate these tasks using computer-implemented artificial intelligence (AI), it may be difficult and time-consuming to convert natural language documents into computer code that can be understood by the AI. Summary of the invention

[0004] An embodiment according to the present invention relates to a method for creating an executable process from a text description, comprising extracting a proposition set from a text document written in a natural language, extracting a formula set from the text document based on the proposition set, creating a state transition diagram including a path determined by a set of proposition values ​​constrained by the formula set, and converting the state transition diagram into a software application.

[0005] Another embodiment according to the present invention relates to an apparatus for creating an executable process from a text description written in a natural language, the apparatus comprising a computer processor, a computer memory operably coupled to the computer processor, the computer memory having computer program instructions disposed therein, the computer program instructions, when executed by the computer processor, causing the apparatus to perform the following steps: extracting a proposition set from a text document written in a natural language, extracting a formula set from the text document based on the proposition set, creating a state transition diagram comprising a path determined by a set of proposition values ​​constrained by the formula set, and converting the state transition diagram into a software application.

[0006] According to another embodiment of the present invention, there is provided a computer program product for creating an executable process from a text description written in a natural language, wherein the computer program product is arranged on a computer-readable medium, and the computer program product includes computer program instructions, which, when executed, cause a computer to perform the following steps: extracting a set of propositions from a text document written in a natural language, extracting a set of formulas from the text document based on the set of propositions, creating a state transition diagram including a path determined by a set of proposition values ​​constrained by the set of formulas, and converting the state transition diagram into a software application.

[0007] In different embodiments according to the present invention, extracting a proposition set from a text document may include: masking keywords listed in a predefined dictionary in each sentence of the text document; masking character sequence patterns represented by predefined expression rules in each sentence of the text document; and mapping the masked part of each sentence to a proposition class through a machine learning process.

[0008] In various embodiments according to the present invention, extracting a set of formulas from a text document according to a set of propositions may include: extracting relations among the set of propositions; and generating a set of logic formulas that represent the relations as conditional statements. In some embodiments, extracting a set of formulas from a text document according to a set of propositions may also include extracting a relation between a logic formula that appears in a first sentence of the text document and another logic formula that appears in a second sentence of the text document.

[0009] In different embodiments according to the present invention, creating a state transition diagram including a set of proposition value-determined paths constrained by a set of formulas may include: for each proposition in the set of propositions, constructing a process flow tree representing all possible states of the proposition values; applying the set of formulas as constraints to all paths in the process flow tree; and optimizing the process flow tree.

[0010] In various embodiments according to the invention, converting a state transition diagram into a software application includes generating computer executable logic that determines values ​​of propositional variables represented in the state transition diagram.

[0011] The foregoing and other objects, features, and advantages of the present invention will become apparent from the following more particular description of exemplary embodiments of the present invention, as illustrated in the accompanying drawings, wherein like reference numerals generally represent like parts of exemplary embodiments of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] Embodiments of the present invention will now be described, by way of example only, with reference to the accompanying drawings, in which:

[0013] Figure 1is a diagram of an example network environment for creating executable processes from text descriptions written in a natural language in accordance with the present invention;

[0014] Figure 2 is a block diagram of an example computer for creating an executable process from a text description written in a natural language in accordance with the present invention;

[0015] Figure 3 is a block diagram of an example system for creating an executable process from a text description written in a natural language in accordance with the present invention;

[0016] Figure 4 is a flow chart of an example method for creating an executable process from a text description written in a natural language according to the present invention;

[0017] Figure 5 is a flow chart of an example method for creating an executable process from a text description written in a natural language according to the present invention;

[0018] Figure 6 is a flow chart of an example method for creating an executable process from a text description written in a natural language according to the present invention;

[0019] Figure 7 is a flow chart of an example method for creating an executable process from a text description written in a natural language according to the present invention; and

[0020] Figure 8 is a flow chart of an example method for creating an executable process from a text description written in a natural language according to the present invention. DETAILED DESCRIPTION

[0021] from Figure 1 Initially, exemplary methods, apparatus, and products for creating executable procedures from text descriptions written in a natural language according to the present invention are described with reference to the accompanying drawings. Figure 1 A network diagram of a system configured for creating executable procedures from text descriptions written in a natural language according to an embodiment of the present invention is presented. Figure 1 The system includes a server (106) configured for natural language processing, the server (106) receiving a document (101) written in a natural language from an administrator (102) and creating an executable process from the received document. The server (106) also receives a dictionary (109) and a set of pattern rules (110) useful in identifying natural language patterns from the administrator (102), the dictionary containing keywords with significant meanings in the document (101).

[0022] The server (106) extracts propositions and formulas from each sentence in the document (101). Extracting propositions includes masking important keywords identified by words listed in a dictionary of keywords, and character sequence patterns represented by rules such as regular expression rules. Then, machine learning is used to extract propositions to identify the patterns of expression and mark the propositions with proposition classes. Extracting formulas includes extracting relationships between the extracted propositions through machine learning and outputting logical formulas as conditional statements between the propositions.

[0023] Next, the server (106) creates proposition value determination paths under the constraints of the extracted formula. A tree flow chart (represented as a state transition diagram) is constructed to represent all possible states for each proposition value. Depending on the true or false value of the proposition, the paths in the tree flow chart are forked. The extracted logic formula is applied to all paths, and the paths that do not meet the conditions are invalidated. The remaining paths are optimized by removing duplicate paths that lead to the same end node, regardless of the value of the proposition variable.

[0024] The server (106) then converts the state transition diagram into an executable process, such as a software application. The present application provides a method for determining the values ​​of proposition variables one by one according to the state transition flow chart. For example, these values ​​are determined by asking the user a query related to the proposition. The user will get a different sequence of questions depending on the answers provided.

[0025] After the executable process is created by the server (106), an application program interface (API) on the server (106) or another server (108) in communication with the server (106) can provide end users (103) with access to the executable process on the server (106) through the network (100). For example, a user interface (UI) on a client computer (105) can access the executable process through the API. In one exemplary use, the document (101) can be a help manual or maintenance manual, and the executable process can be artificial intelligence (AI) software that can simulate a conversation (or chat) with the user (103) in natural language through a messaging application, a website, a mobile app, or over the phone, referred to herein as a "chatbot" application. In another exemplary use, the document (101) can be an insurance policy document, and the executable process can be an automated claims assessment application that helps the user (103) verify the coverage of an insurance claim.

[0026] The network (100) may include one or more local area networks (LANs), wide area networks (WANs), personal area networks, mesh networks, cellular networks, the Internet, intranets, or other networks, and combinations thereof. The network (100) may include one or more wired connections, wireless connections, or combinations thereof. Figure 1The arrangement of servers and other devices of the exemplary system shown in the figure is for explanation and not limitation. Data processing systems useful according to different embodiments of the present invention may include additional servers, routers, other devices and peer-to-peer architectures (in Figure 1 (not shown), as will occur to those skilled in the art. The network in such a data processing system may support many data communication protocols, including, for example, TCP (Transmission Control Protocol), IP (Internet Protocol), HTTP (Hypertext Transfer Protocol), WAP (Wireless Access Protocol), HDTP (Handheld Device Transfer Protocol), and other data communication protocols that will occur to those skilled in the art. Various embodiments of the present invention may be used in addition to Figure 1 The invention can be implemented on various hardware platforms other than the hardware platform shown.

[0027] The creation of an executable process according to the present invention from a text description written in a natural language is typically implemented using a computer (i.e., using an automatic computing machine). Figure 1 In the system, for example, the server (106), the server (108) and the client computer (105) are all implemented as computers at least to some extent. Therefore, for further explanation, Figure 2 A block diagram of automated computing machinery according to an embodiment of the present invention is presented, the automated computing machinery including an exemplary computer (152) configured to create an executable process from a text description written in a natural language. Figure 2 The computer (152) includes at least one computer processor (156) or 'CPU' and random access memory (168) ('RAM') connected to the processor (156) and other components of the computer (152) via a high-speed memory bus (166) and a bus adapter (158).

[0028] Stored in the RAM (168) is a natural language processor (126), which is a module of computer program instructions for creating an executable process from a text description written in a natural language according to an embodiment of the present invention. The RAM (168) also stores a propositional natural language processing model (130), which is a module of computer program instructions for extracting propositions from natural language using machine learning. The RAM (168) also stores a formula natural language processing model (131), which is a module of computer program instructions for extracting formulas or logical relationships between propositions from natural language using machine learning. The RAM (168) also stores a state transition diagram generator (132), which is a module of computer program instructions for generating a state transition diagram representing a path determined by a proposition, such as constrained by a formula.

[0029] Also stored in RAM (168) is an operating system (154). Operating systems useful in computers configured to create executable procedures from text descriptions written in a natural language according to embodiments of the present invention include UNIX TM 、Linux TM , Microsoft XP TM 、AIX TM 、IBM's i5 / OS TM and other operating systems as will occur to those skilled in the art. Figure 2 In the example of the operating system (154), NLP (126), propositional NLP model (130), formula NLP model (131), and STG generator (132) are shown in RAM (168), but many components of such software are also typically stored in non-volatile memory, such as, for example, on a hard drive storage device (170). The output of NLP (126) (i.e., propositions (171), formulas (172), and STG (173)) may also be stored in non-volatile memory, such as, for example, on a hard drive (170).

[0030] Figure 2 The computer (152) includes a hard drive adapter coupled to a processor (156) and other components of the computer (152) via an expansion bus (160) and a bus adapter (158). The hard drive adapter connects non-volatile data storage to the computer (152) in the form of a hard drive (170). Hard drive adapters useful in a computer configured to create an executable process from a text description written in a natural language according to embodiments of the present invention include integrated drive electronics ('IDE') adapters, small computer system interface ('SCSI') adapters, and other adapters that will occur to those skilled in the art. Non-volatile computer storage may also be implemented as an optical hard drive, an electrically erasable programmable read-only memory (so-called 'EEPROM' or 'flash' memory), a RAM drive, etc., as will occur to those skilled in the art.

[0031] Figure 2 The example computer (152) includes one or more input / output ('I / O') adapters (178). The I / O adapters implement user-oriented input / output through, for example, software drivers and computer hardware, for controlling output to a display device such as a computer display screen, and user input from a user input device (181) such as a keyboard and mouse. Figure 2The example computer (152) includes a video adapter (209), which is an example of an I / O adapter specifically designed for graphics output to a display device (180), such as a display screen or computer monitor. The video adapter (209) is connected to the processor (156) via a high-speed video bus (164), a bus adapter (158), and a front-side bus (162), which is also a high-speed bus.

[0032] Figure 2 The exemplary computer (152) includes a communications adapter (167) for data communications with other computers (197) and for data communications with a data communications network (100). Such data communications may be performed serially via an RS-232 connection, via an external bus (e.g., a universal serial bus ('USB')), via a data communications network (e.g., an IP data communications network), and in other ways as will occur to those skilled in the art. The communications adapter implements the hardware level of data communications by which one computer sends data communications to another computer, either directly or via a data communications network. Examples of communications adapters useful in a computer configured to create an executable process from a text description written in a natural language according to embodiments of the present invention include a modem for wired dial-up communications, an Ethernet (IEEE 802.3) adapter for wired data communications, and an 802.11 adapter for wireless data communications.

[0033] To explain further, Figure 3 A system diagram of an exemplary system for creating executable procedures from text descriptions written in a natural language according to an embodiment of the present invention is presented. Figure 3 The exemplary system shown in can be configured for use in a "chatbot" application or other application in which a user's "yes / no" answers provide the basis for transitioning from one state to the next in an executable process.

[0034] exist Figure 3In a system, a computer system (352) includes a natural language processor (301), a memory (370), and a text document (315), which may be a manual, specification, or other natural language document from which an executable process is to be created, as previously discussed. The natural language processor (301) includes a keyword tagging module (325) that accepts the text document (315) as input. As previously discussed, the keyword tagging module (325) identifies keywords from a keyword dictionary and replaces the identified keywords with abstract tags. The natural language processor (301) also includes a propositional machine learning model (330) that accepts keyword representations from the keyword tagging module (325) as input and extracts propositions (305) from the natural language expression of the document (325) based on proposition class definitions. The propositions (305) are stored in the memory (370). The natural language processor (301) also includes a formula machine learning model (335) that accepts a propositional class representation from the propositional machine learning model (330) and extracts a formula (307) representing a conditional statement between propositional variables based on the formula class definition. The formula (307) is stored in the memory (370). The natural language processor (301) also includes an STG generator (340) that accepts a formula class representation from the formula machine learning model (335) and generates a state transition diagram (309), which can be in the form of an SCXML file, for example.

[0035] Figure 3 The system also includes a server (390), which can be implemented on the same machine as the computer (352), or on a separate machine that communicates via a computer network. The server (390) includes an SCXML execution engine (350), which takes the SCXML file (309) as its input and parses the file to perform processing based on the input given at each state. The server (390) also includes an API server (355), such as a representational state transfer (REST) ​​API server, which generates questions and receives user answers, and then relays the answers to the SCXML execution engine (350) to determine the next state in the executable process. The API server (355) can communicate with the UI logic (360) on the client device (397) to obtain the answers provided by the user. For example, the UI logic (360) can be embedded in a browser (365) or other user interface application.

[0036] To explain further, Figure 4 A flow chart illustrating an exemplary method for creating an executable process from a text description written in a natural language according to an embodiment of the present invention is presented. Figure 4 The method includes extracting (402) a set of propositions from a text document (415). As used herein, a proposition is a Boolean variable having a value of "true" or "false". A proposition includes entities represented by keywords. For example, "the age of the insured is less than 18 years old" is a proposition that has a true or false value depending on the person to whom the proposition is applied. The text document (415) is a natural language document from which an executable process is to be created. For example, the text document (415) can be a document such as an insurance policy for an automated insurance claims processing application. In another example, the text document (415) is a maintenance or user manual for an automated help application such as a "chatbot".

[0037] Extracting (402) a set of propositions from a text document may be performed by receiving a text document from a user (415) and using natural language processing (NLP) and machine learning techniques to detect entities such as keywords and phrases. Using NLP and machine learning techniques to detect entities such as keywords and phrases may be performed, for example, by Figure 3 The proposition machine learning model (330) is used to perform. A set of keywords can be provided in a user-provided dictionary (425) to identify keywords. The dictionary (425) includes keywords with significant meanings within the text document (415). Phrases can be detected based on a set of expression rules (435) that can be used to identify natural language patterns. The expression rules (435) can also be provided by the user. For each sentence in the text document (415), propositions are extracted by replacing the identified keywords and phrases with abstract labels. Proposition classes can be used to express propositions using abstract labels. By omitting the actual representation (name) of the entity, the proposition class describes the general properties of the entity. For example, the proposition class associated with the above example is T0_AGE_LESS_THAN_T1, where T0 and T1 are abstract labels of the entity, and where T0 is "person" and T1 is "18 years old". When actual entity keywords are provided, the proposition class becomes a proposition. Each proposition class can be defined and provided by the user.

[0038] Figure 4The method also includes extracting (404) a set of formulas from a text document according to a set of propositions. As used herein, a formula represents a relationship between the values ​​of a plurality of proposition variables. With a formula, each proposition variable does not have its value freely, but is constrained by the values ​​of other proposition variables. Each logical formula in the extracted set of formulas may include proposition variables, logical operators, and conditional statements. According to the set of propositions, extracting (404) a set of formulas from a text document may be performed by using NLP and machine learning techniques to determine the logical relationship between logical entities in sentences of a text document. Using NLP and machine learning techniques to determine the logical relationship between logical entities in sentences of a text document may be performed by a formula machine learning model (335). For example, a conditional statement is written as A->B, where A and B are proposition variables, and the formula A->B constrains the possible combinations of proposition variable values ​​to "if A is true, then B should be true". A formula class may be used to express a formula by replacing a proposition with an abstract label. A formula class represents a logical relationship between propositions without specifying a proposition. Thus, an abstract label represents a proposition variable. Each formula class may be defined and provided by a user.

[0039] Figure 4 The method also includes creating (406) a state transition diagram including a set of propositional values ​​that determine the path constrained by a set of formulas. A state is an ordered combination of propositional values. The state transition diagram represents all possible transitions from one state to other states by determining variable values. The nodes of the state transition diagram represent states, and the edges represent the values ​​of the variables corresponding to the state transitions between the two connected nodes. Under the constraints of the formulas, the possible transitions are limited. The constrained transition diagram is called a state transition diagram of the process. In other words, the state transition diagram is a process flow branch that determines the propositional values. An example of a standard output format for representing a state transition diagram is the State Chart Extensible Markup Language (SCXML), which represents transitions between states through events. For example, in the use case of a chatbot application, a state represents the state of a conversation; in the use case of automatic insurance claim assessment, a state represents the state of verification progress.

[0040] Creating (406) a state transition graph including a set of propositional value determination paths constrained by a set of formulas can be performed by constructing a tree flow graph in which each first propositional variable is a start node, a "true" edge and a "false" edge are both connected to another related propositional variable, and each "true" edge and each "false" edge of the related propositional variable is connected to another other propositional variable, and so on, until a final node is reached for each path that completes the process. Creating (406) a state transition graph including a set of propositional value determination paths constrained by a set of formulas includes verifying the result determination for all states in each path.

[0041] Continuing with the above example, consider the following set of formulas that have been extracted:

[0042] W0->W1

[0043] W0=T0_AGE_LESS_THAN_T1

[0044] W1=HAVE_T2

[0045] T0=people

[0046] T1=18 years old

[0047] T2 = Clinical examination

[0048] Now consider a third proposition variable W2 that depends on W0, so that the formula W2->0 is obtained. If there are three proposition variables (W0, W1, W2), then the system has 2 3 =8 states, as follows: (0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1).

[0049] Given the formula W2->W0, the following results are derived, although the results of two paths (2nd and 4th) are "abnormally ended" because W2 is true when W0 is false:

[0050] 1. Start -> (0) -> (0, 0) -> (0, 0, 0) -> normal end

[0051] 2. Start -> (0) -> (0, 0) -> (0, 0, 1) -> abnormal end

[0052] 3. Start -> (0) -> (0, 1) -> (0, 1, 0) -> normal end

[0053] 4. Start -> (0) -> (0, 1) -> (0, 1, 1) -> abnormal end

[0054] 5. Start -> (1) -> (1, 0) -> (1, 0, 0) -> normal end

[0055] 6. Start -> (1) -> (1, 0) -> (1, 0, 1) -> normal end

[0056] 7. Start -> (1) -> (1, 1) -> (1, 1, 0) -> Normal end

[0057] 8. Start -> (1) -> (1, 1) -> (1, 1, 1) -> Normal end

[0058] The two paths with abnormal endings can be invalidated, leaving 6 valid paths. In the example of a troubleshooting diagnosis process or an insurance claim verification process, the value of each variable is determined one by one, and if a path does not meet the conditions of the formula, the path is considered an abnormal case, such as an unresolved case (e.g., an unresolved problem diagnosis) or a rejected case (e.g., a rejected insurance claim).

[0059] Figure 4 The method also includes converting (408) the state transition diagram into a software application. Converting (408) the state transition diagram into a software application can be performed by generating a software application that determines the values ​​of proposition variables one by one based on the state transition diagram. Determining the values ​​of proposition variables one by one based on the state transition diagram can be performed by mapping the proposition class to a yes / no question to be provided in a user interface (UI) to determine the "true" or "false" value of the proposition. Converting (408) the state transition diagram into a software application can include parsing the SCXML file by an SCXML execution engine (350), which can be accessed by the UI (360) through a UI resource request to an API on an API server (355) that interfaces with the SCXML execution engine (350).

[0060] For example, in the use case of a chatbot application, generating a software application that determines the value of a proposition variable may include: generating a chatbot application that asks a user a yes / no question to determine the value of the proposition; in the use case of automatic insurance claim assessment, generating an input form for automatic verification of insurance claims. Those skilled in the art will recognize that software applications can be generated according to the needs of the user and the text documents from which the application is created, and are not limited to the examples provided in the present invention.

[0061] To explain further, Figure 5 A flowchart is given illustrating an exemplary method for creating an executable process from a text description written in a natural language according to an embodiment of the present invention, the method comprising extracting (402) a set of propositions from a text document, extracting (404) a set of formulas from the text document based on the set of propositions, creating (406) a state transition diagram including a path determined by a set of proposition values ​​constrained by the set of formulas, and transforming (408) the state transition diagram into a software application.

[0062] However, Figure 5 Methods and Figure 4The method differs in that extracting (402) a set of propositions from a text document comprises masking (502) keywords listed in a predefined dictionary in each sentence of the text document. Masking (502) keywords listed in a predefined dictionary in each sentence of the text document can be performed by a keyword tagging module (325) replacing the keywords found in the dictionary (425) with abstract tags. Initially, the user prepares a dictionary to mark keywords that have special importance in the document. The term "special importance" means that these keywords are key entities constituting the proposition. The keywords may have a normal form to absorb variant spellings.

[0063] exist Figure 5 In the method, extracting (402) a set of propositions from a text document further comprises masking (504) a character sequence pattern represented by a predefined expression rule in each sentence of the text document. Masking (504) a character sequence pattern represented by a predefined expression rule in each sentence of the text document can be performed by NLP (301) using pattern rules (435) to identify regular expressions in sentences of the text document (415). In order to avoid registering all numbers in a dictionary, a regular expression is used to mark the age expression regardless of the actual numerical value of the age.

[0064] For example, in the case where the input to the NLP (126) is a sentence of a document, by masking (502) keywords listed in a predefined dictionary in each sentence of the text document and by masking (504) a character sequence pattern represented by a predefined expression rule in each sentence of the text document, the NLP (301) creates a masked sentence and maps the masked portion of the data with a surface form and a normal form. For example, in the case where the input is "Persons whose age is less than eighteen years should have clinical exam", the output is:

[0065] "T0 whose age is less than T1 should have T2", where

[0066] T0=Persons

[0067] T1 = eighteen years (18 years old)

[0068] T2 = clinical exam

[0069] Here, the notation T#=surface form (normal form) is used.

[0070] exist Figure 5In the method, extracting (402) a set of propositions from a text document also includes mapping (506) the masked portion of each sentence to a proposition class via a machine learning process. The proposition is represented in an area containing the keywords marked in the example sentence. Through the machine learning process, mapping (506) the masked portion of each sentence to the proposition class can be performed by a proposition machine learning model (330) using a machine learning algorithm to identify the expression pattern of the proposition and mark the proposition with the proposition class. In the case where the keywords have been masked, the identified regular expression is also masked in the sentence. Mapping data of the masked portion and the surface form and the proposition label are also output.

[0071] Proposition classes are usually defined by the user and are logically generic. For example, a proposition class categorizes the variations in the expression of age within a single class. Proposition classes should have true or false values ​​and allow logical operations that invert true or false. For example, if T0's age is less than T1, then [T0_AGE_LESS_THAN_T1] is true. The value of [! T0_AGE_LESS_THAN_T1] is true, meaning that T0's age is equal to or greater than T1. Here, the "!" symbol is used as a logical inversion (NOT) operation. These labels are called proposition variables. For example, where the output of the previous step is input as:

[0072] “T0 whose age is less than T1 should have T2”, where T0 = Persons, T1 = eighteen years, T2 = clinical exam

[0073] The output is:

[0074] “W0 should W1”, where

[0075] W0="T0 whose age is less than T1", (T0_AGE_LESS_THAN_T1)

[0076] W1 = "have T2" ​​(HAVE_T2)

[0077] T0=Persons

[0078] T1 = eighteen years (18 years old)

[0079] T2 = clinical exam

[0080] To explain further, Figure 6A flowchart is given illustrating an exemplary method for creating an executable process from a text description written in a natural language according to an embodiment of the present invention, the method comprising extracting (402) a set of propositions from a text document, extracting (404) a set of formulas from the text document based on the set of propositions, creating (406) a state transition diagram including a path determined by a set of proposition values ​​constrained by the set of formulas, and transforming (408) the state transition diagram into a software application.

[0081] However, Figure 6 Methods and Figure 4 The method differs in that extracting (404) a set of formulas from a text document based on a set of propositions includes extracting (602) relationships among the set of propositions via a machine learning process. The formulas represent conditional statements between the propositions. Extracting (602) relationships among the set of propositions through the machine learning process can be performed by a formula machine learning model (335) using machine learning to identify the extracted propositions and relationships between entities in the propositions.

[0082] exist Figure 6 In the method, extracting (404) a set of formulas from a text document based on a set of propositions also includes generating (604) a set of logical formulas that represent relationships as conditional statements. Generating (604) a set of logical formulas that represent relationships as conditional statements outputs a logical formula that can be implemented by an executable process. The logical formula includes propositional variables and logical operators AND ("&"), OR ("|"), NOT ("!") and a conditional statement symbol ("->"). The conditional statement is written as "A->B", where A and B are propositional variables, and the formula A->B constrains the possible combinations of propositional variable values ​​to "if A is true, then B should be true".

[0083] For example, consider the proposition variables W0 and W1 in the masked sentence “W0 should W1”, where the mapping data includes:

[0084] W0="T0 whose age is less than T1" (T0_AGE_LESS_THAN_T1)

[0085] W1 = "have T2" ​​(HAVE_T2)

[0086] T0=Persons

[0087] T1 = eighteen years (18 years old)

[0088] T2 = clinical exam

[0089] The output of generating (604) a set of logical formulas representing the relationship as conditional statements is the logical formula:

[0090] "W0->W1", where the mapping data includes:

[0091] W0="T0 whose age is less than T1" (T0_AGE_LESS_THAN_T1)

[0092] W1 = "have T2" ​​(HAVE_T2)

[0093] T0=Persons

[0094] T1 = eighteen years (18 years old)

[0095] T2 = clinical exam

[0096] By processing a plurality of sentences in the text document (415) one by one, a set of formulas is obtained.

[0097] In some embodiments, Figure 6 The method also includes extracting (606) the relationship between a logical formula appearing in a first sentence of a text document and another logical formula appearing in a second sentence of the text document. In some cases, it may be necessary to identify the relationship between propositional variables in different formulas in a set of formulas appearing in different sentences of a text document (415). For example, it may be necessary to process pronouns or relative pronouns, or it may be necessary to process incomplete sentences that can be completed by referring to a supplementary sentence in another sentence. The two are the same in the following sense: a sentence does not create a complete formula, but a complete formula can be composed of a combination of multiple sentences. Extracting (606) the relationship between a logical formula appearing in the first sentence of a text document and another logical formula appearing in the second sentence of the text document can be performed by marking a supplementary representation that references another sentence. For example, a PREVIOUS tag can be used to identify a reference to the same propositional variable in a previous sentence, and when the tag is detected, it can be assumed that the incomplete formula can be completed by a backward reference.

[0098] For example, consider the following two sentences, which appear separately:

[0099] 1: "W0 must have undergone W1."

[0100] 2: “The W1 must have taken place in W3.”

[0101] In this case, two formulas were extracted:

[0102] 1: W0->W1

[0103] 2: PREVIOUS_THE_W1->W2

[0104] However, it is not enough to create a formula from sentence 1 alone, because sentence 2 also needs to be considered. Thus, the following two formulas are generated by extracting (606) the relationship between a logical formula appearing in the first sentence of the text document and another logical formula appearing in the second sentence of the text document:

[0105] W0->W1

[0106] W0&W1->W2

[0107] As another example, consider the two sentences:

[0108] 1: “W1 when W0”

[0109] 2: "This restriction is not applied to W2"

[0110] The following formula was extracted:

[0111] 1: W1->W0

[0112] 2: W2->PREVIOUS_VOID_FORMULA

[0113] Given the relationship identified between Sentence 1 and Sentence 2, the following formula is generated by extracting (606) the relationship between a logical formula appearing in the first sentence of the text document and another logical formula appearing in the second sentence of the text document:

[0114] !W2&W1->W0

[0115] To explain further, Figure 7 A flowchart is given illustrating an exemplary method for creating an executable process from a text description written in a natural language according to an embodiment of the present invention, the method comprising extracting (402) a set of propositions from a text document, extracting (404) a set of formulas from the text document based on the set of propositions, creating (406) a state transition diagram including a path determined by a set of proposition values ​​constrained by the set of formulas, and transforming (408) the state transition diagram into a software application.

[0116] However, Figure 7 Methods and Figure 4The method is different in that creating (406) a state transition diagram including a set of propositional value-determined paths constrained by a set of formulas includes: for each proposition in the set of propositions, constructing (702) a process flow tree representing all possible states of the propositional values. From the set of propositional variables, the tree flow is constructed by creating a start node and selecting a first variable and creating two nodes representing the true and false values ​​of the variable. These nodes are connected to the start node. The two paths to the two new nodes are dynamically selected by user input or by form input that determines the value of the variable as true or false. As the N+1th step, for each node created by the Nth step, two new nodes are associated according to the true or false value of the Nth variable. Thus, the N+1 step is constructed by appending the two new nodes to the 2 nodes generated in the Nth step. N nodes to generate 2 (N+1) This process is repeated until N reaches the number of proposition variables. Next, all edge nodes (generated 2 M edge nodes, where M is the number of variables) connected to the final node representing the normal completion of the process.

[0117] Through these steps, we created M The tree graph is expanded by the order of magnitude, and all nodes on the expanded edges are connected to the terminal nodes. Using the above example, the following graph is obtained:

[0118] 1. Start -> (0) -> (0, 0) -> (0, 0, 0) -> normal end

[0119] 2. Start -> (0) -> (0, 0) -> (0, 0, 1) -> normal end

[0120] 3. Start -> (0) -> (0, 1) -> (0, 1, 0) -> normal end

[0121] 4. Start -> (0) -> (0, 1) -> (0, 1, 1) -> normal end

[0122] 5. Start -> (1) -> (1, 0) -> (1, 0, 0) -> normal end

[0123] 6. Start -> (1) -> (1, 0) -> (1, 0, 1) -> normal end

[0124] 7. Start -> (1) -> (1, 1) -> (1, 1, 0) -> Normal end

[0125] 8. Start -> (1) -> (1, 1) -> (1, 1, 1) -> Normal end

[0126] exist Figure 7In the method, creating (406) a state transition diagram including a set of propositional values ​​that determine the path constrained by a set of formulas also includes: applying (704) the set of formulas as constraints to all paths in the process flow tree. Applying (704) the set of formulas as constraints to all paths in the process flow tree can be performed by eliminating invalid paths that do not meet the conditions of the formulas. Each formula declares a constraint on the variable value. In the variable value state transition path constructed above, the path that does not meet the condition should be excluded. By representing all paths from the start node to the end node as the value of each variable and excluding the path containing invalid conversion, applying (704) the set of formulas as constraints to all paths in the process flow tree can be performed. Using the example above with the formula "W2->W0", the second and fourth paths with (0, x, 1) (where the value of W1 is irrelevant to the result and is therefore represented by "x") should be excluded. When the path is excluded, an abnormal end node is created, and the transition flow is connected to the abnormal end node. Now, the flowchart has two end nodes: normal end and abnormal end. Abnormal end nodes represent unresolved situations (e.g., unresolved problem diagnosis in a chatbot application) or rejected situations (e.g., rejected insurance claims in an automated claims verification application). Thus, the process flow tree is updated as:

[0127] 1. Start -> (0) -> (0, 0) -> (0, 0, 0) -> normal end

[0128] 2. Start -> (0) -> (0, 0) -> (0, 0, 1) -> abnormal end

[0129] 3. Start -> (0) -> (0, 1) -> (0, 1, 0) -> normal end

[0130] 4. Start -> (0) -> (0, 1) -> (0, 1, 1) -> abnormal end

[0131] 5. Start -> (1) -> (1, 0) -> (1, 0, 0) -> normal end

[0132] 6. Start -> (1) -> (1, 0) -> (1, 0, 1) -> normal end

[0133] 7. Start -> (1) -> (1, 1) -> (1, 1, 0) -> Normal end

[0134] 8. Start -> (1) -> (1, 1) -> (1, 1, 1) -> Normal end

[0135] exist Figure 7In the method, creating (406) a state transition diagram including a set of proposition value determination paths constrained by a set of formulas also includes optimizing (706) a process flow tree. Optimizing (706) the process flow tree can be performed by determining the combination of variable values ​​that leads to a normal end or an abnormal end, and if the value of the variable on the path does not affect the final result, then truncating the path to omit unnecessary determination of the variable value. For example, in all the above paths:

[0136] Of all the above paths, only the following three paths are needed.

[0137] 1'. Start->(0)->(0, x, 0)->Normal end

[0138] 2'. Start->(0)->(0, x, 1)-> abnormal end

[0139] 8'. Start -> (1) -> Normal end

[0140] That is, when W0 is false and W2 is false, the constraints of the formula are satisfied regardless of the value of W1. Thus, paths 1 and 3 can be reduced to one path (path 1'). When W0 is false and W2 is true, the constraints of the formula are not satisfied regardless of the value of W1. Thus, paths 2 and 4 can be reduced to one path (path 2'). When W0 is true, the constraints of the formula are satisfied regardless of the values ​​of W1 and W2. Thus, paths 5-8 can be reduced to one path (path 8'). The process flow tree is output as a state transition diagram.

[0141] To explain further, Figure 8 A flowchart is given illustrating an exemplary method for creating an executable process from a text description written in a natural language according to an embodiment of the present invention, the method comprising extracting (402) a set of propositions from a text document, extracting (404) a set of formulas from the text document based on the set of propositions, creating (406) a state transition diagram including a path determined by a set of proposition values ​​constrained by the set of formulas, and transforming (408) the state transition diagram into a software application.

[0142] However, Figure 8 Methods and Figure 4The method of is different in that converting (408) the state transition diagram into a software application includes generating (802) computer executable logic that determines the values ​​of proposition variables represented in the state transition diagram. Generating (802) computer executable logic that determines the values ​​of proposition variables represented can be performed by converting the state transition diagram into a computer executable format (such as, for example, State Machine Notation for Control Abstraction, State Chart XML (SCXML)). The executable process begins at a start node. In order to transition to the next node, the value of the proposition represented by the edge connecting the current node to another node must be determined. For example, in the use case of a chatbot, this can be performed by the chatbot asking questions related to the proposition. Each question can be generated by using a predefined question template with questions corresponding to each proposition class. Examples of question templates corresponding to proposition classes are shown in Table 1.

[0143] Table 1

[0144]

[0145] Propositional classes (such as T0_AGE_LESS_THAN_T1) become propositions after replacing T# with actual values. The propositional machine learning model and formula machine learning model discussed above are trained to label parts of sentences by these propositional class labels. By replacing the abstract labels T# with actual values ​​from the mapped data, they become propositions. For example, the example extracted proposition discussed above is:

[0146] W0="T0 whose age is less than T1" (T0_AGE_LESS_THAN_T1), where:

[0147] T0=Persons

[0148] T1 = eighteen years (18 years old)

[0149] The actual proposition is "person_AGE_LESS_THAN_18 years old". Thus, an exemplary question template for this proposition template may be "Is age of T0 less than T1?" The actual question may appear in the generated software application, where the user may be asked the question "Is age of person less than 18 years?" Thus, the created software application uses the executable state transition diagram to traverse a path constrained by the formula and determined by the values ​​of the proposition variables, which are obtained as a yes / no answer to the question asked to the user in the user interface.

[0150] In another use case of insurance claim validation, a claim form input or a database is read to determine the value of a proposition. In this case, the actual value of the abstract tag T# can be used to create a SQL query for a read request against the database or input form, for example, expressed in JavaScript Object Notation (JSON) format.

[0151] In view of the above explanation, the reader will recognize that the benefits of creating executable processes from text descriptions written in natural language according to embodiments of the present invention include:

[0152] - By utilizing machine learning and NLP techniques, the present invention understands written natural language by recognizing contextual structures with logical reasoning just like humans do;

[0153] - Text documents written in natural language can be converted into executable processes by natural language processors with little human supervision;

[0154] - can directly convert text documents written in natural language into executable logic without requiring a human to first convert the natural language description into a programming language; and

[0155] - Because text documents written in natural language already exist that govern business practices, operating manuals, etc., executable procedures that implement these procedures can be created directly from these documents.

[0156] Exemplary embodiments of the present invention are described in the context of a fully functional computer system for creating executable processes from text descriptions written in a natural language. However, those skilled in the art will recognize that the present invention may also be implemented in a computer program product disposed on a computer-readable storage medium for use with any suitable data processing system. Such a computer-readable storage medium may be any storage medium for machine-readable information, including magnetic media, optical media, or other suitable media. Examples of such media include magnetic disks in hard drives or floppy disks, compact disks for optical drives, tapes, and other media that will occur to those skilled in the art. Those skilled in the art will immediately recognize that any computer system with suitable programming means will be able to perform the steps of the method of the present invention as embodied in a computer program product. Those skilled in the art will also recognize that, although some exemplary embodiments described in this specification are oriented to software installed and executed on computer hardware, alternative embodiments implemented as firmware or hardware are also within the scope of the present invention.

[0157] The present invention may be a system, method and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions thereon for causing a processor to execute various aspects of the present invention.

[0158] Computer readable storage medium can be a tangible device that can retain and store instructions for use by instruction execution devices. Computer readable storage medium can be, for example but not limited to, electronic storage device, magnetic storage device, optical storage device, electromagnetic storage device, semiconductor storage device, or any suitable combination of the above. A non-exhaustive list of more specific examples of computer readable storage medium includes the following: portable computer disk, hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanical encoding device such as punch card or a protruding structure in a groove with instructions recorded thereon, and any suitable combination of the above. Computer readable storage medium as used herein should not be interpreted as a temporary signal itself, such as radio waves or other free propagating electromagnetic waves, electromagnetic waves propagated by waveguides or other transmission media (e.g., light pulses passing through fiber optic cables) or electrical signals emitted by wires.

[0159] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network), or downloaded to an external computer or external storage device. The network can include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions to be stored in a computer-readable storage medium in the corresponding computing / processing device.

[0160] The computer-readable program instructions for performing the operation of the present invention can be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​(such as Smalltalk, C++, etc.) and conventional procedural programming languages ​​(such as "C" programming languages ​​or similar programming languages). The computer-readable program instructions can be executed completely on the user's computer, partially on the user's computer, executed as an independent software package, partially on the user's computer, partially on the remote computer, or completely on the remote computer or server. In the latter case, the remote computer can be connected to the user's computer through any type of network (including local area network (LAN) or wide area network (WAN)), or can be connected to an external computer (for example, using an Internet service provider through the Internet). In certain embodiments, the electronic circuit including, for example, a programmable logic circuit, a field programmable gate array (FPGA) or a programmable logic array (PLA) can be personalized to perform computer-readable program instructions by utilizing the state information of the computer-readable program instructions to perform the electronic circuit so as to perform various aspects of the present invention.

[0161] The present invention will be described below with reference to the flowchart and / or block diagram of the method, device (system) and computer program product according to the embodiment of the present invention. It should be understood that each box of the flowchart and / or block diagram and the combination of each box in the flowchart and / or block diagram can be implemented by computer readable program instructions.

[0162] These computer-readable program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device create a device for implementing the functions / actions specified in one or more boxes of the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium, which causes the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable storage medium in which the instructions are stored includes a manufactured product containing instructions for implementing aspects of the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0163] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device, so that a series of operational steps are performed on the computer, other programmable apparatus, or other device to produce computer-implemented processing, so that the instructions executed on the computer, other programmable apparatus, or other device implement the functions / actions specified in or in multiple boxes in the flowchart and / or block diagram.

[0164] The flow charts and block diagrams in the accompanying drawings show the architecture, functions and operations of the possible implementations of the system, method and computer program product according to different embodiments of the present invention. To this end, each box in the flow chart or block diagram may represent a module, segment or part of an instruction, which includes one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the box may not occur in the order marked in the figure. For example, depending on the functions involved, the two blocks shown in succession can actually be executed substantially simultaneously, or these blocks can sometimes be executed in reverse order. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart can be implemented by a dedicated hardware-based system that performs a specified function or action or performs a combination of dedicated hardware and computer instructions.

[0165] It can be understood from the foregoing description that modifications and changes can be made in various embodiments of the present invention without departing from the true spirit of the present invention. The description in this specification is for illustrative purposes only and should not be interpreted as limiting. The scope of the present invention is limited only by the language of the appended claims.

Claims

1. A method for creating an executable procedure from a text description, wherein: The text description is written in a natural language, and the method comprises: Extracting a set of propositions from a text document written in a natural language; Extracting a set of formulas from the text document according to the set of propositions; creating a state transition graph comprising a set of proposition-valued determination paths constrained by the set of formulas, wherein the state transition graph represents transitions between states; and Converting the state transition diagram into a software application includes generating the software application.

2. The method according to claim 1, wherein: Extracting a proposition set from the text document comprises: masking keywords listed in a predefined dictionary in each sentence of the text document; masking a character sequence pattern represented by a predefined expression rule in each sentence of the text document; and The masked parts of each sentence are mapped to propositional classes through a machine learning process.

3. The method according to claim 1, wherein: Extracting a set of formulas from the text document according to the set of propositions includes: extracting relationships among the set of propositions through a machine learning process; and A set of logical formulas expressing the relationship as conditional statements is generated. 4 . The method according to claim 3 , further comprising extracting a relationship between a logic formula appearing in a first sentence of the text document and another logic formula appearing in a second sentence of the text document.

5. The method according to claim 1, wherein: Creating a state transition graph including a set of proposition-valued determination paths constrained by the set of formulas includes: For each proposition in the set of propositions, construct a process flow tree representing states of the proposition value; applying the set of formulas as constraints to all paths in the process flow tree; and The process flow tree is optimized.

6. The method according to claim 1, wherein: Converting the state transition diagram into a software application includes generating computer executable logic that determines values ​​of propositional variables represented in the state transition diagram, and wherein the state transition diagram is in a statechart extensible markup language format.

7. The method according to claim 1 further includes receiving a predefined dictionary of valid keywords, a proposition class definition, and a formula class definition.

8. An apparatus for creating an executable process from a text description, wherein: The text description is written in a natural language, the apparatus comprises a computer processor, a computer memory operatively coupled to the computer processor, the computer memory having computer program instructions disposed therein, the computer program instructions, when executed by the computer processor, causing the apparatus to perform the following steps: Extracting a set of propositions from a text document written in a natural language; Extracting a set of formulas from the text document according to the set of propositions; creating a state transition graph comprising a set of proposition-valued determination paths constrained by the set of formulas, wherein the state transition graph represents transitions between states; as well as Converting the state transition diagram into a software application includes generating the software application.

9. The device according to claim 8, wherein: Extracting a proposition set from the text document comprises: masking keywords listed in a predefined dictionary in each sentence of the text document; masking a character sequence pattern represented by a predefined expression rule in each sentence of the text document; and The masked parts of each sentence are mapped to propositional classes through a machine learning process.

10. The device according to claim 8, wherein: Extracting a set of formulas from the text document according to the set of propositions includes: extracting relationships among the set of propositions through a machine learning process; and A set of logical formulas expressing the relationship as conditional statements is generated.

11. The apparatus according to claim 10, further comprising extracting a relationship between a logic formula appearing in a first sentence of the text document and another logic formula appearing in a second sentence of the text document.

12. The device according to claim 8, wherein: Creating a state transition graph including a set of proposition-valued determination paths constrained by the set of formulas includes: For each proposition in the set of propositions, construct a process flow tree representing states of the proposition value; applying the set of formulas as constraints to all paths in the process flow tree; and The process flow tree is optimized.

13. The device according to claim 8, wherein: Converting the state transition diagram into a software application includes generating computer executable logic that determines values ​​of propositional variables represented in the state transition diagram, and wherein the state transition diagram is in a statechart extensible markup language format.

14. The apparatus according to claim 8 further comprises the step of receiving a predefined dictionary of valid keywords, a proposition class definition and a formula class definition.

15. A computer program product for creating an executable procedure from a text description, wherein: The text description is written in a natural language, the computer program product is arranged on a computer readable medium, and the computer program product includes computer program instructions, which, when executed, cause a computer to perform the following steps: Extracting a set of propositions from a text document written in a natural language; Extracting a set of formulas from the text document according to the set of propositions; creating a state transition graph comprising a set of proposition-valued determination paths constrained by the set of formulas, wherein the state transition graph represents transitions between states; as well as Converting the state transition diagram into a software application includes generating the software application.

16. The computer program product of claim 15, wherein: Extracting a proposition set from the text document comprises: masking keywords listed in a predefined dictionary in each sentence of the text document; masking a character sequence pattern represented by a predefined expression rule in each sentence of the text document; and The masked parts of each sentence are mapped to propositional classes through a machine learning process.

17. The computer program product of claim 15, wherein: Extracting a set of formulas from the text document according to the set of propositions includes: extracting relationships among the set of propositions through a machine learning process; and A set of logical formulas expressing the relationship as conditional statements is generated.

18. The computer program product of claim 17, further comprising extracting a relationship between a logic formula appearing in a first sentence of the text document and another logic formula appearing in a second sentence of the text document.

19. The computer program product of claim 15, wherein: Creating a state transition graph including a set of proposition-valued determination paths constrained by the set of formulas includes: For each proposition in the set of propositions, construct a process flow tree representing states of the proposition value; applying the set of formulas as constraints to all paths in the process flow tree; and The process flow tree is optimized.

20. The computer program product of claim 15, wherein: Converting the state transition diagram into a software application includes generating computer executable logic that determines values ​​of propositional variables represented in the state transition diagram, and wherein the state transition diagram is in a statechart extensible markup language format.

Images