Hidden rule identification and completion optimization method and device and storage medium

Abstract

The embodiment of the invention provides a hidden rule identification and completion optimization method and device and a storage medium, and the method comprises the steps: obtaining a user demand and a rule text; extracting rule data according to the rule text based on a natural language processing algorithm; constructing an initial rule knowledge graph according to the rule data; based on a sub-graph matching algorithm, generating a complete rule graph according to the initial rule knowledge graph; and based on a shortest path algorithm, generating a shortest logic path according to the complete rule map and the user demand. Therefore, the integrity of the rule is improved.

Description

Technical Field

[0001] This document relates to the field of artificial intelligence technology, and in particular to a method, device and storage medium for implicit rule recognition and completion optimization. Background Art

[0002] In knowledge graphs, rule reasoning can enhance the expressive power of knowledge graphs and improve reasoning efficiency and accuracy.

[0003] Existing technologies usually train models through sample data and use the trained models to perform operations such as entity recognition, relationship extraction, and rule extraction on text. However, when faced with complex rule systems, existing methods have the defect that implicit logic is not made explicit, especially in the automatic completion of reasoning chains. In addition, existing systems are unable to automatically identify implicit logical dependencies between rules, resulting in the reasoning process requiring additional time and resources to find and verify implicit missing relationships. This not only increases the computational cost, but also reduces the efficiency of rule reasoning. At the same time, due to the lack of mining implicit dependency relationships, existing methods may have incomplete rule logic when constructing knowledge graphs, requiring manual intervention to supplement these missing implicit logical connections, affecting user experience and work efficiency. Summary of the Invention

[0004] In view of the above solutions, the present application aims to propose a method, device and storage medium for implicit rule identification and completion optimization to solve at least one of the above technical problems.

[0005] In a first aspect, one or more embodiments of this specification provide a method for optimizing implicit rule identification and completion.

[0006] Obtain user requirements and rule texts;

[0007] Extracting rule data based on the rule text based on a natural language processing algorithm;

[0008] Constructing an initial rule knowledge graph based on the rule data;

[0009] Based on the subgraph matching algorithm, a complete rule graph is generated according to the initial rule knowledge graph;

[0010] Based on the shortest path algorithm, the shortest logical path is generated according to the complete rule graph and the user needs.

[0011] Further, based on the constraint propagation algorithm, the conflict type of the path is determined according to the complete rule graph;

[0012] The complete rule graph is optimized according to the conflict type and the preset priority.

[0013] Furthermore, extracting rule data from the rule text based on a natural language processing algorithm includes:

[0014] Extracting key entities, conditions, and constraints based on the rule text based on a natural language processing algorithm;

[0015] Generate rule nodes and relationship edges according to the key entities, the conditions and the constraints;

[0016] Rule data is obtained according to the rule nodes and the relationship edges.

[0017] Furthermore, the generating of a complete rule graph based on the initial rule knowledge graph based on the subgraph matching algorithm includes:

[0018] Determine implicit rules based on the initial rule knowledge graph based on a subgraph matching algorithm;

[0019] A complete rule graph is generated according to the implicit rules and the initial rule knowledge graph.

[0020] Furthermore, the generating of the shortest logical path based on the shortest path algorithm according to the complete rule graph and the user requirements includes:

[0021] Determining the direct relationship data required by the user based on the complete rule graph and the user needs;

[0022] Based on the shortest path algorithm, the shortest logical path required by the user is generated according to the direct relationship data.

[0023] In a second aspect, an embodiment of the present application provides an implicit rule identification and completion optimization device, comprising:

[0024] Acquisition module, used to obtain user requirements and rule texts;

[0025] A processing module, configured to extract rule data according to the rule text based on a natural language processing algorithm;

[0026] A graph construction module, used to construct an initial rule knowledge graph based on the rule data;

[0027] A subgraph completion module, configured to generate a complete rule graph based on the initial rule knowledge graph based on a subgraph matching algorithm;

[0028] The path reasoning module is used to generate the shortest logical path based on the shortest path algorithm according to the complete rule graph and the user needs.

[0029] Furthermore, it also includes a conflict optimization module,

[0030] Based on the constraint propagation algorithm, the conflict type of the path is determined according to the complete rule graph;

[0031] The complete rule graph is optimized according to the conflict type and the preset priority.

[0032] Furthermore, the processing module is configured to:

[0033] Extracting key entities, conditions, and constraints based on the rule text based on a natural language processing algorithm;

[0034] Generate rule nodes and relationship edges according to the key entities, the conditions and the constraints;

[0035] Rule data is obtained according to the rule nodes and the relationship edges.

[0036] Furthermore, the subgraph completion module is configured as follows:

[0037] Determine implicit rules based on the initial rule knowledge graph based on a subgraph matching algorithm;

[0038] A complete rule graph is generated according to the implicit rules and the initial rule knowledge graph.

[0039] In a third aspect, an embodiment of the present application provides a storage medium for storing computer-executable instructions, characterized in that when the computer-executable instructions are executed, they implement the steps of the implicit rule identification and completion optimization method described in any one of the first aspects.

[0040] Compared with the existing technology, this application can at least achieve the following technical effects:

[0041] This application can use the subgraph matching algorithm to complete the implicit dependencies in the rule knowledge graph, improve the completeness of the rules, and automatically discover the indirect influence relationships between the rules required by the user through the shortest path reasoning algorithm, thereby improving the user's applicability of the rules. At the same time, it can avoid photovoltaic power station design errors caused by hidden rules when searching for rules. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate one or more embodiments of this specification or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments recorded in this specification. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0043] Figure 1 A flowchart of a method for implicit rule identification and completion optimization provided in one or more embodiments of this specification;

[0044] Figure 2 A schematic diagram of the structure of an implicit rule recognition and completion optimization device provided in one or more embodiments of this specification. DETAILED DESCRIPTION

[0045] In order to enable those skilled in the art to better understand the technical solutions in one or more embodiments of this specification, the technical solutions in one or more embodiments of this specification will be clearly and completely described below in conjunction with the drawings in one or more embodiments of this specification. Obviously, the described embodiments are only part of the embodiments of this specification, not all of the embodiments. Based on one or more embodiments of this specification, all other embodiments obtained by ordinary technicians in this field without making creative efforts should fall within the scope of protection of this document.

[0046] Existing rule extraction techniques can only extract explicit, direct relationships between rules and are unable to automatically complete the implicit logical dependencies between rules. This makes them inadequate for intelligent management of complex rule systems. For example, in the design of photovoltaic power plants, the dependencies between certain rules are not explicitly stated in the design specifications. This can lead designers to miss important constraints when applying the rules. For example, Rule A: Module tilt should be ≤30°; Rule B: When the slope is greater than 10°, the module tilt must be reduced to accommodate wind loads. Although both rules design module tilt, their logical dependencies are not explicitly established. This can lead designers to fail to correctly adjust the module tilt on steep slopes, impacting the stability of the photovoltaic power plant. Furthermore, some rules have indirect dependencies and conflicts. For example, the tilt of photovoltaic modules is affected by wind speed and terrain. However, traditional rule bases often only store direct constraints and lack reasoning capabilities, resulting in limited rule applicability. Furthermore, due to the layers of dependencies between rules, it is difficult to assess the impact of new rules on the existing system when they are released, leading to delays in rule design.

[0047] In response to the above technical problems, this application proposes a method for implicit rule identification and completion optimization, such as Figure 1 The specific steps are as follows:

[0048] Step S1, obtain user requirements and rule text.

[0049] Specifically, obtain the rule texts such as industry specifications, national standards, or enterprise internal regulations in the field of photovoltaic power station design; then preprocess the text data. First, split the rule text into individual words or phrases; then remove meaningless words such as "of", "is", "and", etc.; then restore the word form and unify different forms of the same word (such as "calculate", "calculated") into the basic form (such as "calculate"). Obtain user requirements according to the design standards of photovoltaic power stations in a certain area by photovoltaic power station designers, engineers, etc.

[0050] Step S2, based on the natural language processing algorithm, extract rule data according to the rule text.

[0051] In the embodiment of the present application, based on the natural language processing algorithm, extract key entities, conditions, and constraints according to the rule text; generate rule nodes (Rule) and relationship edges according to the key entities, the conditions, and the constraints; obtain rule data according to the rule nodes and the relationship edges. Among them, the relationship edges include dependence, constraint, and conflict. The dependence relationship represents the sequential applicability between rules; the constraint relationship represents the restriction of one rule on other rules; the conflict relationship represents different requirements of two rules for the same parameter.

[0052] Specifically, use the natural language processing algorithm (NLP, Natural Language Processing) to extract rule information from rule documents or databases. The rule information includes structured information such as rule names, contents, applicable conditions, and influence scopes. Parse these rule information into rule nodes (Rule Nodes) and condition nodes (ConditionNodes). Then extract the key information in the rules and identify different entities. Finally, use the relation extraction (Relation Extraction) technology to identify the dependence relationship between rules.

[0053] Among them, the key information is identified by the methods of feature engineering and semantic analysis. First, based on TF-IDF (Term Frequency-Inverse Document Frequency), the importance of words in the rule document is calculated, and words with high frequency but low information content (such as "的", "是") are filtered out. Words with high TF-IDF values are key information, such as "wind speed", "tilt angle", "spacing", etc. Second, semantic analysis is carried out based on word vectors (Word Embedding), and word embedding models such as Word2Vec, GloVe or BERT are used to calculate the semantic similarity between words, and words highly relevant to the rule theme are identified as key information. For example, the rule: "When the wind speed exceeds 20m / s, the component support must be strengthened"; key information: wind speed, 20m / s, strengthen, component support. Third, based on dependency parsing, the subject, predicate and object of the sentence are identified to determine the core entities and constraints of the rule. For example, the rule: "Under the condition that the slope is greater than 10°, the component tilt angle should be ≤ 30°"; key information: slope > 10°, component tilt angle ≤ 30°. Then, based on the pattern matching of the rule template, some rule templates (such as "If..., then...") are predefined to match the core information in the rule. For example, the template: "If A, then B"; matching result: A is the condition node and B is the rule node. Finally, based on the semantic attention mechanism (Attention Mechanism) of the context, pre-trained models such as BERT are used to identify the core vocabulary through the context attention weights. For example, words such as wind speed, spacing, and tilt angle have high weights in the rule context and are usually key information.

[0054] For example, use a pre-trained model or a custom NER model to identify the key entities in the rules of a specific domain, such as "component tilt angle", "wind speed", "slope", etc. in the design of a photovoltaic power station. Then use dependency parsing to identify the subject-predicate-object structure in the sentence; rule: "When the wind speed is greater than 20m / s, the component spacing should be less than 2m", parsing result: subject (wind speed), condition (greater than 20m / s), action (should be less than), object (component spacing). Then, based on regular expressions or deep learning models (such as BERT, RoBERTa), identify the rule pattern of "If..., then...".

[0055] This application can efficiently extract structured rule information from rule documents or databases through NLP technologies, especially NER, syntactic analysis and relation extraction.

[0056] Step S3, construct an initial rule knowledge graph according to the rule data.

[0057] Specifically, in a graph database, nodes and edges are used to represent the relationships between rules and conditions, modeling rule relationships. A rule node represents a complete rule or instruction, typically including constraints, execution actions, and scope of application. A condition node represents the conditions under which a rule is established, typically environmental factors or prerequisites. Edges represent the dependencies between rules and conditions, and between rules. A graph database is then used to store the rule knowledge graph, and the Cypher query language is used to store rule relationships. Finally, rule and condition nodes and edges are created, and the graph can represent the direct dependencies between rules, completing the construction of the initial rule knowledge graph.

[0058] For example, the transformation process of the rule knowledge graph includes:

[0059] (1) Entity Recognition and Classification

[0060] Identify entities in text (such as components, wind speed, slope) through NER;

[0061] Through pattern recognition, regular entities (such as the component inclination angle should be ≤30°) and conditions (such as wind speed>20m / s) are identified.

[0062] (2) Relationship identification and classification

[0063] Use dependency parsing to identify the relationship between rules and conditions;

[0064] Rule: "If wind speed > 20m / s, module spacing should be ≤ 1.8m";

[0065] Relationship: Conditional node (wind speed > 20m / s) → Rule node (component spacing should be ≤ 1.8m).

[0066] (3) Node type judgment

[0067] Rule Node:

[0068] Usually contains restrictive words (such as must, should, must not exceed, etc.).

[0069] Contains execution actions (such as adjust, maintain, reduce, etc.).

[0070] Conditional nodes:

[0071] Usually contains conditional words (such as if, when, under the condition of).

[0072] Most of them are environmental variables or state descriptions (such as wind speed, slope, temperature).

[0073] (4) Constructing a rule knowledge graph

[0074] Use a graph database (such as Neo4j or JanusGraph) to store rules and conditions as nodes and relationships as edges. Rule nodes include the following relationships: component inclination ≤ 30° and slope > 10°. The relationship between component inclination and slope is that slope affects component inclination.

[0075] Step S4: Based on the subgraph matching algorithm, a complete rule graph is generated according to the initial rule knowledge graph.

[0076] In an embodiment of the present application, based on a subgraph matching algorithm, implicit rules are determined according to the initial rule knowledge graph; and a complete rule graph is generated according to the implicit rules and the initial rule knowledge graph.

[0077] Specifically, first, select a subgraph matching algorithm suitable for the rule graph, such as the VF2 algorithm, which can efficiently find subgraph matching situations in the graph and identify implicit missing dependencies. Secondly, traverse the initial rule knowledge graph of the rules, find the dependencies between existing rules, and determine whether there are any direct dependency gaps. For example, "slope" should directly affect "component inclination", but this dependency may not be established in the current graph, and it is considered that there is an implicit relationship missing in the rule. Thirdly, use the VF2 subgraph matching algorithm to match potential missing dependencies in the rule graph. For example, the implicit logical missing between rule A (component inclination) and rule B (wind load adjustment) is detected, and it is deduced that the two should be indirectly related. Then, once the missing logical relationship is found, the system will automatically add a new dependency to the initial rule knowledge graph through the algorithm. Finally, based on the new dependency, update the graph to generate a complete rule graph.

[0078] For example, the algorithmic process for identifying hidden missing relationships is:

[0079] (1) Graph Traversal:

[0080] Use depth-first search (DFS) or breadth-first search (BFS) to traverse the entire knowledge graph.

[0081] Get all existing rule nodes and condition nodes and their relationship edges.

[0082] (2) Subgraph pattern definition (Pattern Definition):

[0083] Define the pattern graph for subgraph matching, for example:

[0084] Mode: A→B→C

[0085] Expected: If A affects B, and B affects C, then A should affect C.

[0086] (3) Subgraph Matching:

[0087] Use the VF2 subgraph matching algorithm to identify incomplete patterns in existing graphs.

[0088] For example: Rule A: "Module inclination angle ≤ 30°"; Rule B: "Module inclination angle needs to be adjusted when the slope is > 10°";

[0089] Implicit missing dependency: From "slope > 10°" directly to "component inclination ≤ 30°".

[0090] (4) Output: Identify implicit missing dependencies:

[0091] Output in the form of a relationship chain, for example:

[0092] Implicit missing dependency: Slope > 10° → Component inclination ≤ 30°.

[0093] This application uses a subgraph matching algorithm to automatically identify and complete the implicit missing relationships between rule logics, reducing unnecessary errors caused by the lack of implicit rules; and by completing the logical rules, the traceability of the rules can be improved, making them more applicable in the process of using the rules to design photovoltaic power stations; at the same time, the consistency of the rules is enhanced to ensure that the photovoltaic power station design plan can bear all relevant constraints.

[0094] Step S5: Based on the shortest path algorithm, the shortest logical path is generated according to the complete rule graph and the user needs.

[0095] In an embodiment of the present application, the direct relationship data required by the user are determined based on the complete rule graph and the user needs; based on the shortest path algorithm, the shortest logical path required by the user is generated based on the direct relationship data.

[0096] Specifically, first, a graph computing algorithm, such as Shortest Path Reasoning (SPR), is used to derive indirect relationships between rules using a shortest path algorithm (such as Dijkstra). Second, within the rule knowledge graph, a starting rule and a target rule are selected, and the shortest path algorithm is used to calculate the logical chain between the starting and target rules. For example, it is deduced that the restriction on "module tilt angle" will affect the "wind speed requirement," which in turn affects the design of the "support foundation." Third, the shortest path reasoning algorithm identifies all intermediate rules and conditions between the starting and target rules. Furthermore, through query methods in the graph database, indirect dependencies between the rules are automatically identified and generated. Finally, the derived indirect rule relationships are aligned with the user's business needs in real-world scenarios, automatically generating new rules or adjusting existing rules to produce the shortest logical path required by the user. For example, for photovoltaic power plant design, the following relationship is derived: module tilt angle → wind speed impact → support foundation.

[0097] For example, in the design of photovoltaic power plants, the relationship between different rules may be indirect, that is, the applicability of a rule may depend on the results of another rule.

[0098] Rule A: "The depth of the support foundation must be ≥1.5m"; Rule B: "The foundation depth in high wind load areas should be ≥2m"; Rule C: "If the wind load affects the stability of the support, the foundation depth must be increased." There is no direct relationship between Rule A and Rule C, but Rule C indirectly affects Rule A by affecting the stability of the support through wind load. The solution is to first obtain the direct relationship between all rules, then calculate the shortest path between the rules, and derive the indirect association. That is, the direct relationship between the rules is Rule A (support foundation depth) → Rule B (wind load impact) → Rule C (support stability); through shortest path reasoning, it is automatically deduced to Rule A (support foundation depth) → Rule C (support stability).

[0099] This application adopts the shortest path algorithm to calculate the shortest logical path between rules and deduce the indirect association between rules. It can discover the potential dependencies between rules, improve the intelligence level of rule applicability, avoid human omission of rules, improve the automatic reasoning ability of the rule base, and help photovoltaic power station designers to more comprehensively understand the logical relationship between rules.

[0100] Furthermore, based on the constraint propagation algorithm, the type of path is determined according to the complete rule graph; and the complete rule graph is optimized according to the conflict type and the preset priority.

[0101] Specifically, the constraint propagation algorithm first traverses the entire rule graph to detect conflicts between rules and their types. For example, it detects whether component spacing rules contradict each other under different conditions. Secondly, it searches and identifies conflicting rules in the graph database. Then, based on the conflict type, it adjusts the priority or parameters of the conflicting rules. For example, in high-wind-speed areas, the scope of application of the "component spacing" rule is adjusted. The scope of application of the rule is intelligently adjusted based on environmental factors such as wind speed and temperature. For example, in low-wind-speed areas, the standard rule is maintained, while in high-wind-speed areas, wind-speed-related adjustments are automatically applied. Next, by simulating different environments and conditions, it verifies whether the optimized rules meet the design requirements. The optimized rules dynamically adapt to new business needs, ensuring the long-term effectiveness and consistency of the rule system. Finally, the optimized rules and their adjustments are fed back into the complete rule knowledge graph, and the graph is continuously updated to ensure that the rule management system can adapt to new changes. Conflict types include parameter conflict, condition conflict, and logical conflict. A parameter conflict occurs when different rules have conflicting requirements for the same parameter. For example, Rule A states that "module spacing ≥ 2m," while Rule B states that "module spacing ≤ 1.8m in high wind speed areas." This conflict can be described as the conflicting ranges of values for the same parameter (module spacing). A condition conflict occurs when a condition is triggered and multiple rules conflict with each other. For example, Rule A states that "when wind speed is > 20m / s, the tilt angle ≤ 30°," while Rule B states that "when wind speed is > 20m / s, the tilt angle ≥ 35°." This conflict can be described as the conflicting requirements of Rule A and Rule B under the same condition. A logical conflict occurs when rules are logically mutually exclusive. For example, Rule A states that "module tilt angles > 30° are prohibited," while Rule B states that "module tilt angles > 30° are permitted under certain conditions." This conflict can be described as a logical contradiction that renders the rules unenforceable.

[0102] For example, in the design of photovoltaic power plants, different standards may have different provisions for the same parameters.

[0103] Rule A: "Module spacing should be ≥2m"; Rule B: "Module spacing in high wind speed areas should be ≤1.8m." If the conflict between these two rules is not detected, it is very likely that the designed solution will not comply with the rules, affecting user safety. The solution is to use the constraint propagation algorithm (Constraint Propagation) to automatically identify and optimize rule conflicts so that the rules can be applied under different environmental conditions. That is, the constraint propagation algorithm first detects rule conflicts; then optimizes the rules. If the high wind speed area requires module spacing ≤1.8m, while the standard rule requires module spacing ≥2m, the system will automatically adjust the rule to "standard module spacing → high wind speed area → 1.8m" based on the priority.

[0104] This application uses a constraint propagation algorithm to automatically detect rule conflicts and intelligently adjust rule parameters, thereby reducing the burden of manual inspection, improving work efficiency, avoiding safety hazards caused by non-compliant photovoltaic power station designs due to unreasonable rules, and enhancing the manageability of the rule base.

[0105] This application provides an implicit rule recognition and completion optimization device, such as Figure 2 As shown, including:

[0106] Acquisition module 101, used to acquire user requirements and rule text;

[0107] A first processing module 102 is configured to extract rule data from the rule text based on a natural language processing algorithm;

[0108] A graph construction module 103 is used to construct an initial rule knowledge graph based on the rule data;

[0109] A subgraph completion module 104 is configured to generate a complete rule graph based on the initial rule knowledge graph based on a subgraph matching algorithm;

[0110] The path reasoning module 105 is configured to generate the shortest logical path based on the shortest path algorithm, the complete rule graph and the user requirements.

[0111] Furthermore, it also includes a conflict optimization module,

[0112] Based on the constraint propagation algorithm, the conflict type of the path is determined according to the complete rule graph;

[0113] The complete rule graph is optimized according to the conflict type and the preset priority.

[0114] Furthermore, the processing module is configured to:

[0115] Extracting key entities, conditions, and constraints based on the rule text based on a natural language processing algorithm;

[0116] Generate rule nodes and relationship edges according to the key entities, the conditions and the constraints;

[0117] Rule data is obtained according to the rule nodes and the relationship edges.

[0118] Furthermore, the subgraph completion module is configured as follows:

[0119] Determine implicit rules based on the initial rule knowledge graph based on a subgraph matching algorithm;

[0120] A complete rule graph is generated according to the implicit rules and the initial rule knowledge graph.

[0121] An embodiment of the present application provides a storage medium for storing computer-executable instructions, characterized in that the computer-executable instructions, when executed, implement the steps of the implicit rule identification and completion optimization method described in any one of the above embodiments.

[0122] It should be noted that the embodiment of the storage medium in this specification and the embodiment of the implicit rule identification and completion optimization method in this specification are based on the same inventive concept. Therefore, the specific implementation of this embodiment can refer to the implementation of the corresponding implicit rule identification and completion optimization method mentioned above, and the repeated parts will not be repeated.

[0123] The foregoing description of this specification describes specific embodiments. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in an order different from that described in the embodiments and still achieve the desired results. Furthermore, the processes depicted in the accompanying drawings do not necessarily require the specific order shown or the sequential order to achieve the desired results. In certain embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0124] In the 1930s, technological improvements could be clearly distinguished as either hardware improvements (for example, improvements to circuit structures like diodes, transistors, and switches) or software improvements (improvements to process flows). However, with the advancement of technology, many process flow improvements today can now be considered direct improvements to hardware circuit structures. Designers almost always create the corresponding hardware circuit structure by programming the improved process flow into the hardware circuit. Therefore, it cannot be said that a process flow improvement cannot be implemented using hardware modules. For example, a programmable logic device (PLD), such as a field programmable gate array (FPGA), is an integrated circuit whose logical function is determined by user programming. Designers can "integrate" a digital system on a PLD by programming it themselves, without having to hire a chip manufacturer to design and manufacture a dedicated integrated circuit chip. Moreover, nowadays, instead of manually fabricating integrated circuit chips, this programming is mostly done using "logic compiler" software. This is similar to the software compiler used when developing programs. Before compilation, the original code must also be written in a specific programming language, called a hardware description language (HDL). There is not just one HDL, but many, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc. The most commonly used ones are VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art will also understand that by simply programming the method flow in one of these hardware description languages and then programming it into an integrated circuit, a hardware circuit that implements the logic method flow can be easily obtained.

[0125] The controller can be implemented in any suitable manner. For example, the controller can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicone Labs C8051F320. The memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also know that in addition to implementing the controller in a purely computer-readable program code format, the controller can be implemented in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, such a controller can be considered a hardware component, and the devices included therein for implementing various functions can also be considered as structures within the hardware component. Or even, the devices for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.

[0126] The systems, devices, modules, or units described in the above embodiments may be implemented by computer chips or entities, or by products having certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0127] For the convenience of description, the above devices are described as being divided into various units according to their functions. Of course, when implementing the embodiments of this specification, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0128] Those skilled in the art will appreciate that one or more embodiments of this specification may be provided as a method, system, or computer program product. Thus, one or more embodiments of this specification may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0129] This specification is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of this specification. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, 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 generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0130] These computer program instructions may also be stored in a computer readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0131] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operational steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing the instructions executed on the computer or other programmable device for implementing the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.

[0132] In a typical configuration, a computing device includes one or more processors (CPUs), input / output interfaces, network interfaces, and memory.

[0133] Memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0134] Computer-readable media includes permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. The information can be computer-readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include transitory computer-readable media (transitory media), such as modulated data signals and carrier waves.

[0135] It should also be noted that the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, commodity, or apparatus that includes a series of elements includes not only those elements but also other elements not explicitly listed, or includes elements inherent to such process, method, commodity, or apparatus. In the absence of further limitations, an element defined by the phrase "comprises a ..." does not exclude the presence of other identical elements in the process, method, commodity, or apparatus that includes the element.

[0136] One or more embodiments of this specification may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, and the like that perform specific tasks or implement specific abstract data types. One or more embodiments of this specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communications network. In a distributed computing environment, program modules may be located in local and remote computer storage media, including storage devices.

[0137] The various embodiments in this specification are described in a progressive manner. Similar parts between the various embodiments can be referred to in conjunction with each other. Each embodiment focuses on the differences between the other embodiments. In particular, the system embodiments are generally similar to the method embodiments, so the description is relatively simple. For relevant parts, refer to the description of the method embodiments.

[0138] The foregoing description is merely an example of the present invention and is not intended to limit the present invention. Persons skilled in the art will readily appreciate that various modifications and variations of the present invention are possible. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of the present invention are intended to be included within the scope of the claims herein.

Claims

1. A method for identifying and completing implicit rules, characterized by include: Obtain user requirements and rule texts; Extracting rule data based on the rule text based on a natural language processing algorithm; Constructing an initial rule knowledge graph based on the rule data; Based on the subgraph matching algorithm, a complete rule graph is generated according to the initial rule knowledge graph; Based on the shortest path algorithm, the shortest logical path is generated according to the complete rule graph and the user needs.

2. The method according to claim 1, characterized in that The method further comprises, Based on the constraint propagation algorithm, the conflict type of the path is determined according to the complete rule graph; The complete rule graph is optimized according to the conflict type and the preset priority.

3. The method according to claim 1, characterized in that Extracting rule data from the rule text based on a natural language processing algorithm includes: Extracting key entities, conditions, and constraints based on the rule text based on a natural language processing algorithm; Generate rule nodes and relationship edges according to the key entities, the conditions and the constraints; Rule data is obtained according to the rule nodes and the relationship edges.

4. The method according to claim 1, wherein The method of generating a complete rule graph based on the initial rule knowledge graph based on the subgraph matching algorithm includes: Determine implicit rules based on the initial rule knowledge graph based on a subgraph matching algorithm; A complete rule graph is generated according to the implicit rules and the initial rule knowledge graph.

5. The method according to claim 1, wherein The generating of the shortest logical path based on the shortest path algorithm according to the complete rule graph and the user requirements includes: Determining the direct relationship data required by the user based on the complete rule graph and the user needs; Based on the shortest path algorithm, the shortest logical path required by the user is generated according to the direct relationship data.

6. A device for identifying and completing implicit rules, characterized in that include: Acquisition module, used to obtain user requirements and rule texts; A processing module, configured to extract rule data according to the rule text based on a natural language processing algorithm; A graph construction module, used to construct an initial rule knowledge graph based on the rule data; A subgraph completion module, configured to generate a complete rule graph based on the initial rule knowledge graph based on a subgraph matching algorithm; The path reasoning module is used to generate the shortest logical path based on the shortest path algorithm according to the complete rule graph and the user needs.

7. The device according to claim 6, characterized in that The device also includes a conflict optimization module, Based on the constraint propagation algorithm, the conflict type of the path is determined according to the complete rule graph; The complete rule graph is optimized according to the conflict type and the preset priority.

8. The device according to claim 6, characterized in that The processing module is configured to: Extracting key entities, conditions, and constraints based on the rule text based on a natural language processing algorithm; Generate rule nodes and relationship edges according to the key entities, the conditions and the constraints; Rule data is obtained according to the rule nodes and the relationship edges.

9. The device according to claim 6, characterized in that The subgraph completion module is configured as follows: Determine implicit rules based on the initial rule knowledge graph based on a subgraph matching algorithm; A complete rule graph is generated according to the implicit rules and the initial rule knowledge graph.

10. A storage medium for storing computer-executable instructions, characterized in that: When the computer executable instructions are executed, the steps of the implicit rule identification and completion optimization method according to any one of claims 1 to 6 are implemented.

Images