Business process analysis method and device based on natural language, equipment and medium

Abstract

The invention relates to the technical field of semantic analysis, can be applied to business system platforms of financial science and technology, medical health and the like, and discloses a business process analysis method, device and equipment based on a natural language and a medium. Generating a target logic tree corresponding to the natural language instruction; converting the logic structure in the target logic tree into a structured code, and performing grammar verification on the structured code; correcting the structured codes which do not pass the grammar verification, and performing rendering operation on the target structured codes to obtain a visual flow chart; adjusting the visual flow chart, and updating the structured code based on the adjusted visual flow chart; and when the visual flow chart meets the flow demand of the target user, outputting a target flow chart corresponding to the natural language instruction, and performing business flow analysis on the natural language instruction by using the target flow chart. And the efficiency of business process analysis is improved.

Description

Technical Field

[0001] The present invention relates to the field of semantic parsing technology, and in particular to a business process analysis method, device, equipment and medium based on natural language. Background Art

[0002] With the diversification of business, enterprise processes have become lengthy and complex in branches. Manual maintenance of flowcharts is inefficient. In addition, as policies change or business models iterate, flowcharts need to be frequently modified. Manual adjustments are prone to missing nodes or logical conflicts. In order to improve the efficiency of business process analysis, it is necessary to use natural language processing to automatically parse process nodes, sequences, conditional branches and other elements in the text to generate standardized flowcharts and reduce information loss in the demand and design stages.

[0003] In the field of healthcare, the process specifications of different hospitals vary greatly. For example, the medical record archiving process is significantly different between tertiary hospitals and community clinics. Flowcharts need to be adjusted frequently, and manual modification is costly, resulting in slow and inefficient modification of flowcharts.

[0004] In the field of financial technology business, financial policies and financial products are iterating rapidly. For example, the risk control process of new financial products and the need for natural language description, such as dynamically adjusting the weights of credit scoring models, are difficult to automatically convert into logical branches in the flowchart, resulting in low efficiency in generating flowcharts.

[0005] Traditional flowchart design tools require users to manually drag and drop components or write code, and require users to master specific syntax. The generation process is cumbersome, inefficient, and has a high learning cost. Existing AI-assisted drawing tools are mostly based on image generation models and cannot directly generate structured flowchart code. They also lack deep integration with development tools, resulting in low efficiency in analyzing business processes. Summary of the Invention

[0006] The present invention provides a business process analysis method, device, equipment and medium based on natural language to solve the technical problem of low efficiency in business process analysis.

[0007] In a first aspect, a business process analysis method based on natural language is provided, comprising:

[0008] Obtaining a target user's natural language instruction, identifying entity data and constraints in the natural language instruction, and analyzing semantic relationships between the entity data;

[0009] Generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions and the semantic relationship;

[0010] Converting the logical structure in the target logic tree into structured code of a preset target syntax, and performing syntax checking on the structured code;

[0011] Correcting the structured code that fails the syntax check to obtain a target structured code, and rendering the target structured code to obtain a visual flow chart;

[0012] Adjusting the visual flowchart according to the process requirements of the target user, updating the structured code based on the adjusted visual flowchart, and returning to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user;

[0013] When the visual flowchart meets the process requirements of the target user, the target flowchart corresponding to the natural language instruction is output, and the business process analysis of the natural language instruction is performed using the target flowchart.

[0014] In a second aspect, a business process analysis device based on natural language is provided, comprising:

[0015] A natural language instruction parsing module is used to obtain the natural language instructions of the target user, identify the entity data and constraints in the natural language instructions, and analyze the semantic relationship between the entity data;

[0016] A target logic tree generation module, configured to generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions, and the semantic relationship;

[0017] a structured code conversion module, configured to convert the logical structure in the target logic tree into structured code of a preset target grammar, and perform syntax checking on the structured code;

[0018] A target structured code rendering module is used to correct the structured code that fails the syntax check to obtain the target structured code, and render the target structured code to obtain a visual flow chart;

[0019] a visual flowchart adjustment module, configured to adjust the visual flowchart according to the process requirements of the target user, update the structured code based on the adjusted visual flowchart, and return to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user;

[0020] The business process analysis module is used to output a target flow chart corresponding to the natural language instruction when the visual flow chart meets the process requirements of the target user, and use the target flow chart to perform business process analysis on the natural language instruction.

[0021] In a third aspect, a computer device is provided, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the steps of the above-mentioned natural language-based business process analysis method are implemented.

[0022] In a fourth aspect, a computer-readable storage medium is provided, which stores a computer program. When the computer program is executed by a processor, the steps of the above-mentioned natural language-based business process analysis method are implemented.

[0023] In the solution implemented by the above-mentioned natural language-based business process analysis method, device, equipment and medium, the natural language instructions of the target user can be obtained through the client, the entity data and constraints in the natural language instructions can be identified, and the semantic relationship between the entity data can be analyzed; the target logic tree corresponding to the natural language instruction is generated according to the entity data, constraints and semantic relationships; the logical structure in the target logic tree is converted into a structured code of a preset target syntax, and the structured code is syntax-checked; the structured code that fails the syntax check is corrected to obtain the target structured code, and the target structured code is rendered to obtain a visual flowchart; the visual flowchart is adjusted according to the process requirements of the target user, the structured code is updated based on the adjusted visual flowchart, and the process returns to the step of syntax-checking the structured code. Until the visual flowchart meets the process requirements of the target user; when the visual flowchart meets the process requirements of the target user, the target flowchart corresponding to the natural language instructions is output, and the target flowchart is fed back to the client. In the present invention, entity data, constraints and semantic relationships are automatically extracted through natural language analysis, and a logical tree is directly generated, eliminating the manual combing process. Structured code generation and syntax verification are automatically completed to avoid errors in manually written code. NLP is combined with flowchart generation technology to achieve automated drawing that is what you want. Users can directly drag and drop nodes and modify logical relationships in the visual flowchart, automatically update the structured code and re-check it synchronously, without having to start drawing from scratch. The structured code generated each time can be automatically archived, which is convenient for tracing the history of process changes, thereby solving the technical problem of low efficiency in business process analysis. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments of the present invention. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0025] Figure 1This is a schematic diagram of an application environment of a natural language-based business process analysis method according to an embodiment of the present invention;

[0026] Figure 2 This is a flowchart of a natural language-based business process analysis method according to an embodiment of the present invention;

[0027] Figure 3 yes Figure 2 A schematic flow chart of a specific implementation of step S1;

[0028] Figure 4 yes Figure 2 A schematic flow chart of a specific implementation of step S3;

[0029] Figure 5 This is a schematic diagram of the structure of a business process analysis device based on natural language in one embodiment of the present invention;

[0030] Figure 6 is a structural diagram of a computer device in one embodiment of the present invention;

[0031] Figure 7 FIG. 2 is another structural diagram of a computer device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0032] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of them. All other embodiments obtained by ordinary technicians in this field based on the embodiments of the present invention without making any creative efforts shall fall within the scope of protection of the present invention.

[0033] The business process analysis method based on natural language provided by the embodiment of the present invention can be applied in Figure 1in an application environment, wherein the client communicates with the server through a network. The server can obtain the natural language instructions of the target user through the client, identify the entity data and constraints in the natural language instructions, and analyze the semantic relationship between the entity data; generate a target logic tree corresponding to the natural language instructions according to the entity data, constraints and semantic relationships; convert the logical structure in the target logic tree into a structured code of a preset target grammar, and perform syntax checking on the structured code; correct the structured code that fails the syntax check to obtain the target structured code, render the target structured code, and obtain a visual flowchart; adjust the visual flowchart according to the process requirements of the target user, update the structured code based on the adjusted visual flowchart, and return to the step of syntax checking on the structured code until the visual flowchart meets the process requirements of the target user. Process requirements; when the visual flowchart meets the process requirements of the target user, the target flowchart corresponding to the natural language instruction is output and the target flowchart is fed back to the client. In the present invention, entity data, constraints and semantic relationships are automatically extracted through natural language analysis, and a logical tree is directly generated, eliminating the manual combing process. Structured code generation and syntax verification are automatically completed, avoiding errors in manually written code. Combining NLP with flowchart generation technology, an automated drawing is achieved where you get what you want; users can directly drag and drop nodes and modify logical relationships in the visual flowchart, automatically update the structured code and re-verify it synchronously, without having to start drawing from scratch. Each time the structured code is adjusted, it can be automatically archived, making it easy to trace the process change history, thereby solving the technical problem of low efficiency when performing business process analysis. Among them, the client can be, but is not limited to, various personal computers, laptops, smart phones, tablets and portable wearable devices. The server can be implemented with an independent server or a server cluster consisting of multiple servers. The present invention is described in detail below through specific embodiments.

[0034] See also Figure 2 As shown, Figure 2 A flowchart of a natural language-based business process analysis method provided in an embodiment of the present invention includes the following steps:

[0035] S1. Obtain a natural language instruction from a target user, identify entity data and constraints in the natural language instruction, and analyze semantic relationships between the entity data.

[0036] In an embodiment of the present invention, the natural language instruction refers to a request or description with a clear goal proposed by the user in the form of daily spoken or written language, such as "draw a resource relationship diagram between a Docker container and a physical host."

[0037] In detail, the natural language instructions of the target user can be obtained from a pre-stored storage area through computer statements with data capture functions (such as Java statements, Python statements, etc.), where the storage area includes but is not limited to a database and a blockchain.

[0038] Furthermore, natural language often contains ambiguity. Therefore, it is necessary to clarify the requirement boundaries in natural language instructions to avoid ambiguity. For example, in a container deployment scenario, incorrect entities or missing constraints may lead to resource configuration errors. Therefore, it is necessary to identify the entity data and constraints in natural language instructions.

[0039] In an embodiment of the present invention, the entity data refers to the specific objects, concepts or attributes involved in the natural language instructions, such as Docker containers, physical hosts, Kubernetes clusters, etc., and the constraints refer to the restrictions, rules or parameters on entity operations or relationships in the natural language instructions, such as using the TCP protocol when mapping ports, mounting volumes in read-only mode, etc.

[0040] In the embodiment of the present invention, referring to Figure 3 As shown, the identifying entity data and constraints in the natural language instruction includes:

[0041] S31, performing a text cleaning operation on the natural language instruction, and performing a standardization operation on the cleaned natural language instruction to obtain a standardized natural language instruction;

[0042] S32. Using a pre-trained named entity recognition model, identify entity data in the standardized natural language instruction;

[0043] S33, performing grammatical analysis on the standardized natural language instruction to determine a grammatical structure;

[0044] S34. Determine the constraints in the natural language instruction based on the grammatical structure and preset domain knowledge.

[0045] In detail, the instruction content in the natural language instructions is filtered out of irrelevant symbols, stop words are removed, and repeated content is processed. The text of the cleaned natural language instructions is converted into all lowercase or all uppercase, common abbreviations in the field are converted into complete terms, and different expressions of the same concept are unified, such as host and physical host are unified into physical host, mount volume and volume mount are unified into mount volume, so as to obtain standardized natural language instructions.

[0046] Specifically, the NER model, such as BERT-BiLSTM-CRF, is trained using annotated domain corpus (such as IT operation and maintenance text containing entities such as containers and ports). Standardized instructions are input, and the model outputs an entity list and category, thereby obtaining the entity data in the natural language instructions. That is, the named entity recognition (NER) capability of pre-trained models such as BERT is used to locate professional terms such as Docker containers and physical hosts from the user input text. The model captures contextual semantics through a multi-layer Transformer structure and identifies entity boundaries and categories. For example, containers and hosts belong to device-type entities. Syntactic analysis tools are used to parse the sentence structure, identify components such as the subject, predicate, object, and adverbial, and match the adverbial, defined, and other components in the grammatical structure through predefined constraint templates to extract constraint conditions. For example, the matching logic is to contain the keyword "in... mode" in read-only mode, match the "operation constraint" template, and extract the value as read-only.

[0047] Furthermore, analyzing the semantic relationship between entity data is a key step in converting natural language instructions into structured logic.

[0048] For example, if it is necessary to generate a visualization diagram of the hospital's testing process, the input natural language instruction is "generate a sample testing flowchart for the hospital's laboratory department, including sample reception, blood routine examination, biochemical examination, result review and report issuance, and mark the responsible person and time range of each link". The named entity recognition model is used to identify the entity data in the natural language instruction, and the entity data is sample reception, blood routine examination, biochemical examination, result review, report issuance (link); responsible person (attribute); time range (attribute). The constraint conditions are the order of links, such as sample reception → blood routine examination / biochemical examination in parallel, responsible person, such as inspector A is responsible for blood routine, and time, such as result review is less than 2 hours.

[0049] In addition, in the field of financial technology, it is necessary to generate a payment system architecture diagram. The input natural language instruction is "Draw a technical architecture diagram of a financial payment system, including the user end, payment gateway, risk control system, core transaction engine, and bank interface, mark the communication protocol and data flow of each component, and highlight the linkage logic between the risk control system and the core engine." The named entity recognition model is used to identify the entity data in the natural language instruction. The entity data is the user end, payment gateway, risk control system, core transaction engine, and bank interface (component); communication protocol (attributes, such as HTTPS, TCP / IP); data flow (relationship). The constraints are security protocols, such as HTTPS encryption and real-time risk control verification, such as the risk control system needs to intervene before the transaction.

[0050] In an embodiment of the present invention, semantic relationships include operational relationships, attribute relationships, hierarchical relationships, and dependency relationships. The operational relationship represents the behavioral association between entities, such as user → create → container; the attribute relationship represents the subordinate relationship between the entity and the attribute, such as container → port number → 8080; the hierarchical relationship represents the inclusion or hierarchical structure between entities, such as host → inclusion → container group; the dependency relationship represents the operation or logical dependency between entities, such as Web service → dependency → database.

[0051] In detail, the co-occurrence frequency of pairs of implementations in the statistical instructions is used to preliminarily judge the potential relationship between entities. The domain knowledge base, such as the Docker knowledge graph, is used to eliminate entity ambiguity. The natural language model is used to analyze the semantic relationship between entities, that is, based on the generation capability of PT or a dedicated relationship extraction model, such as BERT+CR, to analyze the semantic association between entities, such as mapping ports to represent network configuration relationships and mounting volumes to represent storage associations. The predicate relationship between entity pairs is captured through the attention mechanism, such as the mapping of containers to host ports.

[0052] Furthermore, abstract logical rules, data relationships and business requirements are transformed into structured and visual logical models, and the abstract logic is concretized using graphical methods.

[0053] S2. Generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions and the semantic relationship.

[0054] In the embodiment of the present invention, the target logic tree clearly displays the semantic structure and execution logic of the instruction by hierarchically decomposing the target subject, entity data and constraint conditions.

[0055] In an embodiment of the present invention, generating a target logic tree corresponding to the natural language instruction based on the entity data, the constraint conditions, and the semantic relationship includes:

[0056] Generate a root node according to the target topic in the natural language instruction, and use the entity data and the constraint conditions as child nodes corresponding to the root node;

[0057] Determine an association relationship between the root node and the child nodes according to the semantic relationship;

[0058] Connecting the child nodes to the root node through the association relationship to form an initial logic tree of the natural language instruction;

[0059] The initial logic tree is layered according to the entity type and entity attributes of the entity data to obtain a target logic tree corresponding to the natural language instruction.

[0060] Specifically, the core goal is extracted from the natural language instructions as the root node of the logic tree. The root node must accurately reflect the core demands of the user's intention, avoid ambiguity or deviation from the topic, and the identified entity data and constraints are used as child nodes of the root node. The entity data is the specific object or parameter in the instruction, and the constraints are restrictions on the entity, such as time range, screening rules, etc. The two together define the task boundaries.

[0061] Specifically, the semantic relationship between entity data and constraints, such as affiliation, temporal relationship, causal relationship, etc., is analyzed to determine the connection method between the root node and the child nodes. The grammatical relationship between keywords can be identified, such as adverbial-central word, attributive-central word, and then the initial logic tree is layered according to the type and attributes of the entity. The first layer is the root node, the second layer is the entity type, and the third layer is the specific entity value and constraint conditions, so as to obtain the target logic tree corresponding to the natural language instruction.

[0062] Furthermore, the hierarchical structure of the logic tree can be directly mapped to the code framework. Through layered decomposition and semantic association, vague user requirements can be transformed into a clear structured framework, providing clear guidance for subsequent code generation, task scheduling and system execution.

[0063] For example, a logical tree structure can be generated based on entity data, constraints and semantic relationships. For example, the logical tree structure of the hospital inspection process is link nodes - sample reception, blood routine test, biochemical test, result review, and report issuance; the relationship nodes are sample reception-blood routine test, sample reception-biochemical test, blood routine test-result review, biochemical test-result review, result review-report issuance; for another example, the logical tree structure of the payment system is component nodes - user end, payment gateway, risk control system, core transaction engine, bank interface; the relationship nodes are user end → payment gateway (request payment), payment gateway → risk control system (risk verification), risk control system → core transaction engine (pass / reject), core transaction engine → bank interface (execute transaction), bank interface → core transaction engine (return result).

[0064] S3. Convert the logical structure in the target logic tree into a structured code with a preset target syntax, and perform syntax checking on the structured code.

[0065] In the embodiment of the present invention, the structured code refers to organizing logical structures, such as entities, relationships, and constraints, into a code form with clear hierarchy and machine parseability through a predefined grammatical structure.

[0066] In the embodiment of the present invention, referring to Figure 4 As shown, converting the logical structure in the target logic tree into a structured code of a preset target syntax includes:

[0067] S41, determining the node type, node attributes and node connection relationship according to the logical structure in the target logical tree;

[0068] S42: Determine a target component corresponding to an entity node in the target logical tree according to the node type, and determine a component attribute of the target component according to the node attribute;

[0069] S43. Convert the constraint conditions in the target logic tree into constraint codes according to the grammatical structure of the target grammar, and convert the node connection relationships into relationship codes;

[0070] S44. Combining the target components, the component attributes, the constraint codes, and the relationship codes into a structured code of the target syntax according to the logical relationship of the target logic tree.

[0071] In detail, the target logic tree is traversed using a depth-first traversal or breadth-first traversal algorithm to ensure that every node and edge in the tree can be accessed, thereby obtaining complete logical structure information. For example, starting from the root node, the child nodes are accessed in a certain order, and the node types (entities, constraints, etc.), node attributes (such as entity name, port number, etc.) and the connection relationship between nodes are recorded. That is, entities, constraints and their associations are disassembled from the logic tree to provide structured data for code generation. The node types include root nodes, entity nodes and constraint nodes. The root node represents the user's core goal, such as designing a container network architecture; entity nodes represent specific objects, such as Docker containers, physical hosts, and attributes, such as port 8080 and volume path / data; constraint nodes represent operation restrictions, such as read-only mode and TCP protocol; node attributes are characteristic parameters of entities, such as container name, host type, cloud host, and specific values ​​of constraints, such as port mapping direction: host→container; connection relationships refer to semantic associations between entities, such as container→mount→host volume, host→mapped port→container.

[0072] Specifically, for the entity nodes in the logical tree, define the corresponding components in PlantUML according to the type of entity node. If it is a Docker container entity, use rectangle "Docker container" as container to define a rectangular component with an alias of container to represent the container; if it is a physical host, use rectangle "physical host" as host to define it; if the entity node has related attributes, such as the color of the container, the model of the host, etc., add the corresponding attribute settings when defining the component. For example, to set the container color to green, you can write rectangle "Docker container" as container#green; when traversing to the constraint node, extract the specific condition content it contains, such as the "map host port 80 to container port 8080" constraint, and convert the constraint into the corresponding code according to the target syntax structure. In PlantUML, the port mapping constraint can be expressed as host:80->container:8080 to clarify the port mapping relationship between entities (host and container), and then check the semantic relationship type marked by the edge connecting the entity nodes in the logical tree, such as managing life cycle, mounting volume, etc., and generate code to represent the relationship according to the target syntax requirements. For Docker The semantic relationship of Daemon managing the container life cycle can be expressed in PlantUML as DockerDaemon-[#lightblue]->container: management life cycle, where -[#lightblue]-> represents a colored (light blue) arrow, which is used to reflect the direction of the relationship, and the following text describes the relationship content.

[0073] In addition, to enhance code readability, comments can be added at appropriate locations in the structured code based on the information in the logic tree. For example, comments can be added above the code lines that define important entities or complex constraints to explain their meaning and function. For example, / / can be added before the code line that defines the port mapping relationship to indicate the port mapping relationship from the host to the container. Then, the entity components can be defined first, and then the relationships and constraints between the entities can be described. The generated code fragments can be integrated together in a certain logical order to form a complete structured code.

[0074] Exemplarily, the payment system logic tree is converted into structured code as component "user end" as user#lightblue, component "payment gateway" as gateway#lightgreen, component "risk control system" as risk#red, component "core transaction engine" as core#orange, component "bank interface" as bank#lightgray, user-->gateway: HTTPS request payment, gateway-->risk: TCP / IP risk verification, risk-->core: verification result (pass / reject), core-->bank: internal API executes transaction, bank-->core: SFTP return result, note right of risk: real-time interception of high-risk transactions.

[0075] Furthermore, use PlantUML's syntax checker or online parser to check whether the generated code conforms to the PlantUML syntax structure and whether there are any syntax errors, such as mismatched brackets, spelling errors of keywords, etc., and make corrections to ensure that the code can correctly render the expected graphics.

[0076] In an embodiment of the present invention, a corresponding syntax checking tool is used to perform syntax checking on the structured code, such as the built-in checking mechanism of PlantUML, an online syntax checker, etc. After the syntax is checked, a detailed error prompt will be returned, clearly indicating the location of the error in the code, the line number, the column number, etc., as well as the error type, such as syntax format error, keyword spelling error, bracket mismatch, etc. For example, it is prompted that on line 5, the keyword rectangle is spelled incorrectly.

[0077] Furthermore, structured code that conforms to the target syntax (such as PlantUML) is generated, supporting automatic completion and error correction, thereby ensuring the accuracy of the subsequent generated flow charts.

[0078] S4. Correct the structured code that fails the syntax check to obtain a target structured code, and render the target structured code to obtain a visual flow chart.

[0079] In the embodiment of the present invention, the target structured code refers to a code that, after syntax checking and correction, fully complies with the target syntax structure and can be correctly processed by a parsing tool.

[0080] In the embodiment of the present invention, the step of correcting the structured code that fails the syntax check to obtain the target structured code includes:

[0081] Identify error locations in structured code that fails syntax checking;

[0082] identifying an error type of the structured code according to the error location;

[0083] determining a correction logic for the structured code according to the error type;

[0084] The structured code is modified according to the modification logic to obtain a target structured code.

[0085] In detail, based on the line number and column number provided in the error message, accurately locate the erroneous code fragment in the structured code. For example, if the error is on line 5, open the code file and find the content on line 5 to view it. Further determine the specific error point based on the error description. If the prompt is that the brackets do not match, carefully check the use of brackets in that line and nearby code to see if there are any problems such as overwriting, underwriting, or mismatched bracket types.

[0086] Specifically, the error types are syntax format errors, logical errors and missing element errors. Syntax format errors include keyword errors and symbol usage errors. If it is a keyword spelling error, such as writing rectangle as recangle in PlantUML, directly correct it to the correct keyword spelling; for example, a colon should be used to represent the separation in the relationship, but a comma is written instead, then replace the wrong symbol with the correct symbol. If there is an indentation error in the code, adjust it according to the indentation format specified by the target grammar; logical errors include relationship direction errors and entity association errors, that is, when describing the relationship between entities, if the direction of the semantic relationship is reversed, for example The container depends on the host but it is written as the host depends on the container. Adjust the direction of the relationship according to the actual semantics. When it is found that the association between entities in the code does not conform to the semantics expressed by the logic tree, such as incorrectly mapping the port that should be associated with the container to other entities, re-organize the logic and correctly adjust the entity association relationship. Missing element errors include missing keywords and missing symbols. For example, if necessary keywords are missing in the code, such as forgetting to write the as keyword when defining a component in PlantUML, fill in the missing keywords. Check whether there are any missing brackets, semicolons and other symbols, and fill them in in time. For example, if you forget to write the closing bracket when defining a relationship, fill it in.

[0087] Furthermore, a repair strategy is generated according to the error type, and the repair strategy includes automatic completion and error correction. Automatic completion refers to filling in missing code elements based on a template library or syntax structure, such as port number format and volume path specification. For example, when the user enters the container mapping port, it is automatically completed as Docker container: 8080->physical host: 80; error correction refers to detecting code format errors through a syntax checker, such as the PlantUML parser, and correcting logical errors in combination with the semantic understanding ability of the NLP model, thereby verifying and correcting the structured code to obtain the target structured code.

[0088] Furthermore, in order to achieve fully automatic generation from text to graphics, the rendering operation is the last link in the automation chain of natural language instructions, logic tree, code, and graphics. Therefore, the rendering operation must be performed on the generated target structured code.

[0089] In an embodiment of the present invention, the visual flowchart refers to a chart that displays the system architecture, business process or logical relationship in a graphical form, and intuitively presents information through nodes (such as components, steps) and connections (such as arrows, line segments).

[0090] In an embodiment of the present invention, rendering the target structured code to obtain a visual flowchart includes:

[0091] Generating rendering commands corresponding to the target structured code;

[0092] Determining a rendering style and layout direction of the target structured code according to preset rendering parameters;

[0093] The rendering command is executed according to the rendering style and the layout direction to obtain a visual flowchart.

[0094] In detail, the structured code is converted into instructions that can be recognized by the rendering tool, that is, the corresponding rendering engine is called according to the target syntax, the format of the generated image is specified, and the structured code file is input to generate the rendering instructions corresponding to the target structured code, and then the visual presentation and structural arrangement of the flowchart are adjusted according to the preset parameters. The overall style is defined through the configuration file, and custom icons are added to the components or the shapes are modified, and the layout line corresponding to the target structured code is determined. The layout direction includes horizontal layout, vertical layout and mixed layout. The horizontal layout is suitable for scenarios where the process is from left to right, such as data flow; the vertical layout is suitable for hierarchical structures, such as organizational charts; and the mixed layout achieves local direction adjustment through sub-graphs.

[0095] Specifically, the structured code is parsed into visual graphics, that is, the structured code is parsed, an internal logic tree is constructed, the position of each component is calculated according to the layout direction and node relationship, the nodes and relationship lines are filled with style attributes such as color, icon, and text, and the graphics library (such as Graphviz's dot engine) is called to generate pixel-level image data, thereby generating a visual flowchart corresponding to the natural language instructions. IDE plug-ins (such as VS Code plug-in) are provided to support one-click generation and preview of flowcharts.

[0096] Furthermore, in order to synchronize the code and visualization results in real time, reverse modification is supported, that is, the target structured code is automatically updated by adjusting the flowchart to obtain the updated code.

[0097] S5. Adjust the visual flowchart according to the process requirements of the target user, update the structured code based on the adjusted visual flowchart, and return to the step of grammatically checking the structured code until the visual flowchart meets the process requirements of the target user.

[0098] In the embodiment of the present invention, the user's specific modification request for the flowchart is clarified, and a distinction is made between technical detail adjustment and business logic change.

[0099] In the embodiment of the present invention, adjusting the visual flowchart according to the process requirements of the target user includes:

[0100] Identify the target user's process requirements;

[0101] Identifying adjustment content of the visual flowchart according to the demand content;

[0102] Determining an adjustment position of the visual flowchart according to the adjustment content;

[0103] The visual flowchart is adjusted according to the adjustment position and the adjustment content.

[0104] In detail, conduct a contextual analysis of the target users' process requirements, identify the scenarios to which the target users' process requirements apply, and classify the process requirements based on the scenarios. For example, if the requirement types include node adjustment, relationship adjustment, style adjustment, and layout adjustment, then node adjustment includes adding nodes and deleting nodes; relationship adjustment includes reversing the mapping direction and adding new relationship lines; style adjustment includes changing the container color and adding node icons; layout adjustment includes changing from horizontal layout to vertical layout and displaying microservice modules in groups; and map user requirements to specific elements of the flowchart. For example, if the requirement is to add a load balancer node, the adjustment content is to add a new node load balancer and define its relationship with the existing nodes, and then locate the specific position that needs to be modified in the flowchart, that is, find the target node according to the logical tree structure, and modify the flowchart according to the adjustment content and position to ensure that it meets user requirements.

[0105] Furthermore, when adjusting the visual flowchart, only the elements directly related to the requirements are adjusted, and the integrity of the uninvolved parts is retained. In this way, the visual flowchart can dynamically adapt to changes in different users, scenarios and requirements, ensuring that it always serves as an efficient communication and analysis tool. Therefore, in order to synchronize the code and visualization results in real time, it is necessary to update the structured code based on the adjusted visual flowchart.

[0106] In an embodiment of the present invention, adjustments to the visual flowchart (such as adding new nodes) need to be reflected in the structured code to ensure that subsequent modifications or automated processes, such as re-rendering and code generation, are based on the latest logic. The code is the structured carrier of the flowchart, and the updated code can track the change history through version control tools to facilitate problem tracing.

[0107] In an embodiment of the present invention, updating the structured code based on the adjusted visual flowchart includes:

[0108] Perform code parsing on the adjusted visual flowchart to obtain the target code;

[0109] Comparing the target code with the structured code to obtain code difference data;

[0110] Determining update details of the structured code according to the code difference data;

[0111] The structured code is updated according to the update details.

[0112] In detail, the adjusted visual flowchart is re-parsed into structured code, and the modified nodes, relationships and styles are extracted. The graphics and code are reversely converted using the PlantUML online editor to output the target code. The target code contains the structured code of all adjusted elements, such as the newly added node definition and the modified relationship expression. The parsed target code is then compared with the original structured code to find out the newly added, deleted or modified parts. The diff command, the compare file function of VS Code or the difference viewer of Git can be used to find out the newly added, deleted or modified parts.

[0113] Specifically, the difference data obtained from the comparison is converted into specific code modification instructions, such as adding nodes, modifying nodes, deleting nodes, and changing relationships. The newly added nodes record the node type, name, and attributes; the modified nodes determine the modified attribute values; the deleted nodes mark the node IDs to be removed; and the relationship changes record the addition and deletion of relationship lines, direction adjustments, or label modifications. Then, the original structured code is modified according to the update details to ensure that it is consistent with the adjusted process. Figure 1 For example, when adding new content, insert new node definitions and relationship expressions in the code, usually add them to the corresponding level in a logical order; when modifying content, directly edit existing code lines, such as replacing node names, modifying color values, and updating relationship labels; delete content to remove node definitions and relationship line codes that are no longer needed, and then use the rendering tool to generate a new flowchart and compare whether it is completely consistent with the adjusted diagram, that is, to confirm that the updated structured code can correctly render the adjusted flowchart to avoid omissions or errors.

[0114] Furthermore, the process modeling, architecture design and other requirements initiated by users through natural language instructions ultimately need to have a visualized process as the final result.

[0115] S6. When the visual flowchart meets the process requirements of the target user, output a target flowchart corresponding to the natural language instruction, and use the target flowchart to perform business process analysis on the natural language instruction.

[0116] In the embodiment of the present invention, the target flow chart refers to a visual chart that ultimately meets the needs of the target user after a series of processes such as demand analysis, logic tree construction, code conversion, and rendering adjustment.

[0117] In detail, when the visual flowchart has met all the process requirements of the target user, no further adjustment is required. The final confirmed visual flowchart will be presented to the user in an appropriate manner, fully reflecting the user's business process, technical architecture or operational logic requirements, and realizing the complete link from intent description to intuitive presentation, providing a solid foundation for subsequent collaboration, execution and decision-making.

[0118] Furthermore, business process analysis is the process of converting business rules described in natural language into a visual and executable process model. Based on the generated flowchart, the business process can be advanced according to the process of the flowchart, thereby improving the efficiency of business process execution.

[0119] It can be seen that in the above solution, entity data, constraints and semantic relationships are automatically extracted through natural language analysis, and a logical tree is directly generated, eliminating the manual combing process. Structured code generation and syntax verification are automatically completed to avoid errors in manually written code. NLP is combined with flowchart generation technology to achieve automated drawing that is what you want. Users can directly drag and drop nodes and modify logical relationships in the visual flowchart, and the structured code will be automatically updated and re-verified without having to start drawing from scratch. The structured code generated each time can be automatically archived to facilitate tracing the history of process changes, thereby solving the technical problem of low efficiency in business process analysis.

[0120] It should be understood that the size of the serial numbers of the steps in the above embodiments does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0121] In one embodiment, a business process analysis device based on natural language is provided, which corresponds one-to-one to the business process analysis method based on natural language in the above embodiment. Figure 5 As shown, the natural language-based business process analysis device includes a natural language instruction parsing module 101, a target logic tree generation module 102, a structured code conversion module 103, a target structured code rendering module 104, a visual flowchart adjustment module 105, and a business process analysis module 106. The functional modules are described in detail as follows:

[0122] The natural language instruction parsing module 101 is used to obtain the natural language instruction of the target user, identify the entity data and constraints in the natural language instruction, and analyze the semantic relationship between the entity data;

[0123] A target logic tree generating module 102 is configured to generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions, and the semantic relationship;

[0124] The structured code conversion module 103 is used to convert the logical structure in the target logic tree into a structured code with a preset target syntax, and perform syntax checking on the structured code;

[0125] The target structured code rendering module 104 is used to correct the structured code that fails the syntax check to obtain the target structured code, and render the target structured code to obtain a visual flow chart;

[0126] A visual flowchart adjustment module 105 is configured to adjust the visual flowchart according to the process requirements of the target user, update the structured code based on the adjusted visual flowchart, and return to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user;

[0127] The business process analysis module 106 is configured to output a target flow chart corresponding to the natural language instruction when the visual flow chart meets the process requirements of the target user, and perform business process analysis on the natural language instruction using the target flow chart.

[0128] In one embodiment, the natural language instruction parsing module 101, when performing identification of entity data and constraints in the natural language instruction, is configured to:

[0129] performing a text cleaning operation on the natural language instructions, and performing a standardization operation on the cleaned natural language instructions to obtain standardized natural language instructions;

[0130] Using a pre-trained named entity recognition model, identifying entity data in the standardized natural language instructions;

[0131] Performing grammatical analysis on the standardized natural language instructions to determine a grammatical structure;

[0132] According to the grammatical structure and preset domain knowledge, the constraints in the natural language instruction are determined.

[0133] In one embodiment, the target logic tree generation module 102, when generating the target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions, and the semantic relationship, is configured to:

[0134] Generate a root node according to the target topic in the natural language instruction, and use the entity data and the constraint conditions as child nodes corresponding to the root node;

[0135] Determine an association relationship between the root node and the child nodes according to the semantic relationship;

[0136] Connecting the child nodes to the root node through the association relationship to form an initial logic tree of the natural language instruction;

[0137] The initial logic tree is layered according to the entity type and entity attributes of the entity data to obtain a target logic tree corresponding to the natural language instruction.

[0138] In one embodiment, the structured code conversion module 103, when converting the logical structure in the target logic tree into structured code of a preset target syntax, is configured to:

[0139] Determine the node type, node attributes and node connection relationship according to the logical structure in the target logical tree;

[0140] Determining a target component corresponding to an entity node in the target logical tree according to the node type, and determining a component attribute of the target component according to the node attribute;

[0141] According to the grammatical structure of the target grammar, the constraint conditions in the target logic tree are converted into constraint codes, and the node connection relationships are converted into relationship codes;

[0142] The target components, the component attributes, the constraint codes and the relationship codes are combined into a structured code of the target syntax according to the logical relationship of the target logic tree.

[0143] In one embodiment, the target structured code rendering module 104, when correcting the structured code that fails syntax checking to obtain the target structured code, is configured to:

[0144] Identify error locations in structured code that fails syntax checking;

[0145] identifying an error type of the structured code according to the error location;

[0146] determining a correction logic for the structured code according to the error type;

[0147] The structured code is modified according to the modification logic to obtain a target structured code.

[0148] In one embodiment, the visual flowchart adjustment module 105, when adjusting the visual flowchart according to the process requirements of the target user, is configured to:

[0149] Identify the target user's process requirements;

[0150] Identifying adjustment content of the visual flowchart according to the demand content;

[0151] Determining an adjustment position of the visual flowchart according to the adjustment content;

[0152] The visual flowchart is adjusted according to the adjustment position and the adjustment content.

[0153] In one embodiment, the visual flowchart adjustment module 105, when updating the structured code based on the adjusted visual flowchart, is further configured to:

[0154] Perform code parsing on the adjusted visual flowchart to obtain the target code;

[0155] Comparing the target code with the structured code to obtain code difference data;

[0156] Determining update details of the structured code according to the code difference data;

[0157] The structured code is updated according to the update details.

[0158] The present invention provides a business process analysis device based on natural language, which automatically extracts entity data, constraints and semantic relationships through natural language analysis, directly generates a logical tree, eliminates the manual combing process, automatically completes structured code generation and syntax verification, avoids errors in manually written code, combines NLP with flowchart generation technology, and realizes automatic drawing of what you want is what you get; users can directly drag and drop nodes and modify logical relationships in the visual flowchart, automatically and synchronously update the structured code and re-verify it without having to draw from scratch, and the structured code generated each time can be automatically archived, which is convenient for tracing the process change history, thereby solving the technical problem of low efficiency in business process analysis.

[0159] For the specific definition of the business process analysis device based on natural language, please refer to the definition of the business process analysis method based on natural language above, which will not be repeated here. The various modules in the above-mentioned business process analysis device based on natural language can be implemented in whole or in part by software, hardware and their combination. The above-mentioned modules can be embedded in or independent of the processor in the computer device in the form of hardware, or can be stored in the memory of the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

[0160] In one embodiment, a computer device is provided. The computer device may be a server, and its internal structure diagram may be as follows: Figure 6As shown. The computer device includes a processor, a memory, a network interface and a database connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile and / or volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external client via a network connection. When the computer program is executed by the processor, it realizes the functions or steps on the server side of a natural language-based business process analysis method.

[0161] In one embodiment, a computer device is provided. The computer device may be a client, and its internal structure diagram may be as follows: Figure 7 As shown. The computer device includes a processor, memory, network interface, display screen and input device connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it implements the functions or steps on the client side of a natural language-based business process analysis method.

[0162] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the following steps are performed:

[0163] Obtaining a target user's natural language instruction, identifying entity data and constraints in the natural language instruction, and analyzing semantic relationships between the entity data;

[0164] Generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions and the semantic relationship;

[0165] Converting the logical structure in the target logic tree into structured code of a preset target syntax, and performing syntax checking on the structured code;

[0166] Correcting the structured code that fails the syntax check to obtain a target structured code, and rendering the target structured code to obtain a visual flow chart;

[0167] Adjusting the visual flowchart according to the process requirements of the target user, updating the structured code based on the adjusted visual flowchart, and returning to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user;

[0168] When the visual flowchart meets the process requirements of the target user, the target flowchart corresponding to the natural language instruction is output, and the business process analysis of the natural language instruction is performed using the target flowchart.

[0169] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the following steps are implemented:

[0170] Obtaining a target user's natural language instruction, identifying entity data and constraints in the natural language instruction, and analyzing semantic relationships between the entity data;

[0171] Generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions and the semantic relationship;

[0172] Converting the logical structure in the target logic tree into structured code of a preset target syntax, and performing syntax checking on the structured code;

[0173] Correcting the structured code that fails the syntax check to obtain a target structured code, and rendering the target structured code to obtain a visual flow chart;

[0174] Adjusting the visual flowchart according to the process requirements of the target user, updating the structured code based on the adjusted visual flowchart, and returning to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user;

[0175] When the visual flowchart meets the process requirements of the target user, the target flowchart corresponding to the natural language instruction is output, and the business process analysis of the natural language instruction is performed using the target flowchart.

[0176] It should be noted that the above functions or steps that can be implemented by the computer-readable storage medium or computer device can be found in the relevant descriptions of the server side and the client side in the aforementioned method embodiment. To avoid repetition, they will not be described one by one here.

[0177] Those skilled in the art will appreciate that all or part of the processes in the above-mentioned embodiments can be implemented by instructing the relevant hardware through a computer program. The computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

[0178] Those skilled in the art will clearly understand that for the sake of convenience and brevity of description, only the division of the above-mentioned functional units and modules is used as an example. In actual applications, the above-mentioned functions can be distributed and completed by different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0179] It should be noted that if software tools or components other than those of our company appear in the embodiments of this application, they are only used for illustration and do not represent actual use.

[0180] The embodiments described above are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present invention, and should all be included in the scope of protection of the present invention.

Claims

1. A business process analysis method based on natural language, characterized in that: include: Obtaining a target user's natural language instruction, identifying entity data and constraints in the natural language instruction, and analyzing semantic relationships between the entity data; Generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions and the semantic relationship; Converting the logical structure in the target logic tree into structured code of a preset target syntax, and performing syntax checking on the structured code; Correcting the structured code that fails the syntax check to obtain a target structured code, and rendering the target structured code to obtain a visual flow chart; Adjusting the visual flowchart according to the process requirements of the target user, updating the structured code based on the adjusted visual flowchart, and returning to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user; When the visual flowchart meets the process requirements of the target user, the target flowchart corresponding to the natural language instruction is output, and the business process analysis of the natural language instruction is performed using the target flowchart.

2. The business process analysis method based on natural language according to claim 1, characterized in that: The identifying entity data and constraints in the natural language instruction includes: performing a text cleaning operation on the natural language instructions, and performing a standardization operation on the cleaned natural language instructions to obtain standardized natural language instructions; Using a pre-trained named entity recognition model, identifying entity data in the standardized natural language instructions; Performing grammatical analysis on the standardized natural language instructions to determine a grammatical structure; According to the grammatical structure and preset domain knowledge, the constraints in the natural language instruction are determined.

3. The business process analysis method based on natural language according to claim 1, characterized in that: Generating a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions, and the semantic relationship includes: Generate a root node according to the target topic in the natural language instruction, and use the entity data and the constraint conditions as child nodes corresponding to the root node; Determine an association relationship between the root node and the child nodes according to the semantic relationship; Connecting the child nodes to the root node through the association relationship to form an initial logic tree of the natural language instruction; The initial logic tree is layered according to the entity type and entity attributes of the entity data to obtain a target logic tree corresponding to the natural language instruction.

4. The business process analysis method based on natural language according to claim 1, characterized in that: The converting the logical structure in the target logic tree into a structured code of a preset target syntax includes: Determine the node type, node attributes and node connection relationship according to the logical structure in the target logical tree; Determining a target component corresponding to an entity node in the target logical tree according to the node type, and determining a component attribute of the target component according to the node attribute; According to the grammatical structure of the target grammar, the constraint conditions in the target logic tree are converted into constraint codes, and the node connection relationships are converted into relationship codes; The target components, the component attributes, the constraint codes and the relationship codes are combined into a structured code of the target syntax according to the logical relationship of the target logic tree.

5. The business process analysis method based on natural language according to claim 1, characterized in that: The step of correcting the structured code that fails the syntax check to obtain the target structured code includes: Identify error locations in structured code that fails syntax checking; identifying an error type of the structured code according to the error location; determining a correction logic for the structured code according to the error type; The structured code is modified according to the modification logic to obtain a target structured code.

6. The business process analysis method based on natural language according to claim 1, characterized in that: The adjusting the visual flowchart according to the process requirements of the target user includes: Identify the target user's process requirements; Identifying adjustment content of the visual flowchart according to the demand content; Determining an adjustment position of the visual flowchart according to the adjustment content; The visual flowchart is adjusted according to the adjustment position and the adjustment content.

7. The business process analysis method based on natural language according to claim 1, characterized in that: The updating of the structured code based on the adjusted visual flowchart includes: Perform code parsing on the adjusted visual flowchart to obtain the target code; Comparing the target code with the structured code to obtain code difference data; Determining update details of the structured code according to the code difference data; The structured code is updated according to the update details.

8. A business process analysis device based on natural language, characterized in that: include: A natural language instruction parsing module is used to obtain the natural language instructions of the target user, identify the entity data and constraints in the natural language instructions, and analyze the semantic relationship between the entity data; A target logic tree generation module, configured to generate a target logic tree corresponding to the natural language instruction according to the entity data, the constraint conditions, and the semantic relationship; a structured code conversion module, configured to convert the logical structure in the target logic tree into structured code of a preset target grammar, and perform syntax checking on the structured code; A target structured code rendering module is used to correct the structured code that fails the syntax check to obtain the target structured code, and render the target structured code to obtain a visual flow chart; a visual flowchart adjustment module, configured to adjust the visual flowchart according to the process requirements of the target user, update the structured code based on the adjusted visual flowchart, and return to the step of performing syntax checking on the structured code until the visual flowchart meets the process requirements of the target user; The business process analysis module is used to output a target flow chart corresponding to the natural language instruction when the visual flow chart meets the process requirements of the target user, and use the target flow chart to perform business process analysis on the natural language instruction.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the method for analyzing business processes based on natural language quotation is implemented as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the natural language-based business process analysis method according to any one of claims 1 to 7 is implemented.

Images