Intelligent graph programming language application system and method based on large model technology

Abstract

The invention discloses an intelligent graphic programming language application system and method based on a large model technology, and the system comprises an input module which is used for obtaining a programming logic document; the large model analysis and generation module is used for performing semantic analysis on the programming logic document and generating corresponding graphical programming language initial code representation; the graphical language generation module is used for converting the initial code representation into a program structure of a graphical programming language; the small model proofreading and optimizing module is used for verifying a program structure according to a preset graphic language grammar rule and automatically modifying and optimizing when a part which does not conform to the grammar rule is detected; and the output module is used for outputting the verified and optimized graphical programming language program. According to the intelligent graphic programming language application system and method based on the large model technology, the advantages of an artificial intelligence large model and an artificial intelligence small model are comprehensively utilized, and automatic conversion and optimization verification from a text requirement to a graphic program are achieved.

Description

Technical Field

[0001] The present invention belongs to the field of artificial intelligence and software development technology, and specifically relates to an intelligent graphics programming language application system and method based on large model technology. Background Art

[0002] With the rapid development of low-code and graphical programming technologies, the method of using a graphical interface to drag and drop modules to build program logic has received widespread attention. However, existing graphical programming tools have many shortcomings when expressing complex logic. For example, when a program contains multiple layers of nested conditionals and loops, existing graphical programming environments often require a large number of nested nodes, resulting in complex logical relationships, inefficient expression of programming logic, and difficulty in intuitive understanding and maintenance. At the same time, most visual programming tools are more suitable for simple scenarios and lack sufficient abstraction capabilities for complex algorithms and business logic, resulting in their inability to handle complex nested logic. Another pain point is that manually drawing flowcharts or logic diagrams is not only time-consuming and labor-intensive, but also requires manual synchronization of graphics updates when the logic is modified, which is prone to inconsistencies or errors. In addition, existing technologies lack intelligent optimization of graphical logic. For example, node layout optimization, merging redundant steps, and automatic verification of business rules are mainly completed manually by developers, and visual optimization capabilities are limited.

[0003] In recent years, breakthroughs have been made in artificial intelligence technology, with large-scale pre-trained models (such as large language models) demonstrating powerful capabilities for natural language understanding and code generation. However, applying large models to graphical programming still faces challenges: graphical code generated directly from large models may have formatting or rule deviations, requiring manual proofreading. Furthermore, while large models excel at semantic understanding, they may not be as reliable as dedicated algorithms in terms of consistency with specific graphical grammars and rules. Therefore, it is necessary to provide a new technical solution that combines the advantages of large and small models, leveraging the intelligent generation capabilities of large models while using small models to rigorously verify graphical rules, thereby addressing the aforementioned pain points of existing technologies. Summary of the Invention

[0004] The present invention provides an intelligent graphics programming language application system and method based on large model technology to solve the above-mentioned technical problems, specifically adopting the following technical solutions: An intelligent graphics programming language application system based on large model technology, comprising: An input module for acquiring programming logic documents written in natural language or pseudocode; A large model parsing and generation module, connected to the input module, for performing semantic analysis on the programming logic document and generating a corresponding graphical programming language initial code representation; A graphical language generation module, connected to the large model parsing and generation module, for converting the initial code representation into a program structure in a graphical programming language; A small model proofreading and optimization module, connected to the graphical language generation module, is used to verify the program structure according to preset graphical language grammar rules, and automatically modify and optimize when a part that does not conform to the grammar rules is detected; The output module is connected to the small model proofreading and optimization module and is used to output the graphical programming language program after verification and optimization.

[0005] Furthermore, the large model parsing and generation module includes a large-scale pre-trained language model for understanding the semantics of the input document; The small model proofreading and optimization module includes a verification model or rule engine trained according to the grammar of the graphical programming language, which is used to detect and correct grammatical violations or suboptimal structures in the program structure.

[0006] Furthermore, the small model proofreading and optimization module automatically corrects the graphical program structure when violations are found during verification, including adding missing process nodes, removing redundant or unconnected nodes, correcting incorrect connection relationships, and adjusting the flow chart layout to improve readability; The proofreading and optimization module rechecks the modified program structure to ensure that all changes comply with preset rules.

[0007] Furthermore, the graphical programming language program structure supports multi-layer nested conditional judgment and loop structures; The large model parsing and generation module is capable of identifying nested logic in the input document and generating a corresponding nested structure in the initial code representation; The small model proofreading and optimization module ensures that each layer of the nested structure has a correct start and end node and complies with a predetermined logical relationship, thereby accurately achieving a graphical representation of complex nested logic.

[0008] Furthermore, the input module supports multiple input formats, including text files, PDF files, or text content directly input in the system interface.

[0009] Furthermore, the output module can display the final generated graphical program in the form of a flowchart, and can also be exported to a file for further use.

[0010] Furthermore, the small model proofreading and optimization module integrates a deep learning-based layout algorithm, which can intelligently arrange node positions, automatically adjust connections, avoid crossing or overlapping, and improve visual readability.

[0011] Furthermore, when the small model proofreading and optimization module finds serious errors during verification, it can request the large model to regenerate specific paragraphs or nodes to continuously correct the defects of the initial generation.

[0012] A method for implementing an intelligent graphics programming language based on large model technology includes the following steps: Obtain programming logic documentation written in natural language or pseudocode; Performing semantic analysis on the programming logic document using a large-scale pre-trained language model to generate a corresponding graphical programming language initial code representation; converting the initial code representation into a program structure in a graphical programming language; Performing graphical grammar rule verification on the program structure using a preset small model; Verify the program structure according to the preset graphic language grammar rules, If the verification passes, the final graphical programming language program is output. If the verification fails, the part of the program structure that does not conform to the rules is automatically modified according to the information fed back by the small model, and the previous step is returned to execute until the verification passes.

[0013] Furthermore, the method further includes requesting the large model to regenerate a specific paragraph or node when a serious error is found in the small model proofreading and optimization module, so as to continuously correct the defects of the initial generation; The method also includes optimizing the layout of the graphical program using a deep learning-based layout algorithm to improve visual readability.

[0014] The benefit of the present invention lies in the intelligent graphic programming language application system and method based on large model technology, which comprehensively utilizes the advantages of artificial intelligence large models and small models to achieve automatic conversion and optimized verification from text requirements to graphical programs.

[0015] The benefit of the present invention lies in the intelligent graphical programming language application system and method based on large model technology, which significantly reduces the labor cost of complex flowchart design. Users no longer need to manually draw tedious graphical logic; they only need to provide a requirements document to automatically generate the program. This effectively solves the problem that existing graphical programming has difficulty expressing complex nested logic, and uses AI to ensure the correct visualization of complex logic. It provides an automated graphical grammar checking and optimization mechanism, reduces human errors, and ensures the standardization and high readability of graphical code. Through intelligent optimization, the layout and structure of the graphical program are improved, making the resulting graphical logic more intuitive and clear. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] In order to more clearly illustrate the embodiments of the present application 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 of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0017] Figure 1 It is a schematic diagram of an intelligent graphic programming language application system based on large model technology of the present invention; Figure 2 It is a schematic diagram of an application method of an intelligent graphic programming language based on large model technology of the present invention. DETAILED DESCRIPTION

[0018] The following describes in detail embodiments of the present application. Examples of the embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals throughout represent the same or similar elements or elements having the same or similar functions. The embodiments described below with reference to the accompanying drawings are exemplary and are intended to be used to explain the present application, and should not be construed as limiting the present application.

[0019] like Figure 1 The following figure shows an intelligent graphical programming language application system based on large-scale model technology. It includes an input module, a large-scale model parsing and generation module, a graphical language generation module, a small-scale model proofreading and optimization module, and an output module. These modules work together to achieve efficient conversion and optimization from text requirements to graphical programs.

[0020] Specifically, the input module is used to obtain programming logic documents written in natural language or pseudocode. It supports a variety of input formats, including requirements documents described in natural language, pseudocode, or algorithmic step descriptions. Users can upload files or directly enter text content through the front-end interface, and the system stores this content in a temporary buffer for subsequent processing. This module design ensures the system's flexibility and ease of use, adapting to the needs and usage habits of different users.

[0021] The large model parsing and generation module, connected to the input module, performs semantic analysis on programming logic documents and generates the corresponding initial code representation in a graphical programming language. This module understands the logical structure and functional requirements in natural language or pseudocode, extracts key information, and converts it into a preliminary representation in a graphical programming language. For example, it can identify key logical nodes such as conditionals and loop structures and convert them into flowchart nodes and connections. This process not only reduces the manual workload of flowchart creation but also improves development efficiency and accuracy.

[0022] The graphical language generation module, connected to the large-scale model parsing and generation module, converts the initial code representation into a graphical programming language program structure. This module converts logical nodes and connections into the data structure of a visual programming platform (such as a node-based flowchart), allowing users to intuitively view and edit program logic within a graphical interface. This module's design ensures that the generated graphical program is not only logically correct but also visually clear. The graphical programming language program structure supports multi-layer nested conditional judgments and loop structures.

[0023] The small model proofreading and optimization module is connected to the graphical language generation module. It verifies the program structure according to the preset graphical language grammar rules and automatically modifies and optimizes any sections that do not conform to the grammatical rules. This module can be a lightweight model pre-trained for the graphical programming language rules, or it can include a set of graphical grammar rule engines. It can automatically check whether the graphical code generated by the large model contains logical errors, incomplete structure, or irregularities, and provide modification suggestions or directly make adjustments. For example, it can automatically correct the graphical program structure, including adding missing process nodes, removing redundant or unconnected nodes, correcting incorrect connection relationships, and adjusting the flowchart layout to improve readability. Through the small model's proofreading feedback mechanism, the system can implement a repetitive optimization of the initial graphical code until all verification items pass. The small model proofreading and optimization module ensures that the final output graphical program is correct in both logic and form.

[0024] In the implementation of this application, the small model proofreading and optimization module incorporates a deep learning-based layout algorithm, which can intelligently arrange node positions and automatically adjust connections to avoid intersections or overlaps, thereby improving visual readability. If the small model proofreading and optimization module detects serious errors during verification, it can request the large model to regenerate specific paragraphs or nodes to continuously correct defects in the initial generation.

[0025] The output module connects to the small model proofreading and optimization module to output the verified and optimized graphical programming language program. The resulting graphical program can be displayed as a flowchart on the front-end interface or exported to a file for further use. Users can select different output formats as needed, allowing the generated graphical program to be used in different development environments or tools. This module design ensures the system's output flexibility and practicality.

[0026] In the embodiments of the present application, the large model parsing and generation module includes a large-scale pre-trained language model for understanding the semantics of the input document. The small model proofreading and optimization module includes a verification model or rule engine trained based on the grammar of the graphical programming language to detect and correct grammatical violations or suboptimal structures in the program structure.

[0027] In the embodiments of the present application, the small model proofreading and optimization module automatically corrects the graphical program structure when violations are detected during verification. This includes adding missing process nodes, removing redundant or unconnected nodes, correcting incorrect connection relationships, and adjusting the flowchart layout to improve readability. The small model proofreading and optimization module re-verifies the modified program structure to ensure that all changes comply with preset rules.

[0028] The large model parsing and generation module can identify the nested logic in the input document and generate the corresponding nested structure in the initial code representation.

[0029] The small model proofreading and optimization module ensures that each layer of the nested structure has the correct start and end nodes and conforms to the predetermined logical relationship, thereby accurately realizing the graphical representation of complex nested logic.

[0030] In the implementation manner of the present application, the input module supports multiple input formats, including text files, PDF files, or text content directly input in the system interface.

[0031] In the embodiment of the present application, the output module can display the finally generated graphical program in the form of a flowchart, and can also be exported to a file for further use.

[0032] like Figure 2 The present invention shows a method for implementing an intelligent graphics programming language based on large model technology, which includes the following steps: Retrieve programming logic documents written in natural language or pseudocode. Users upload or input programming logic documents such as natural language requirements, pseudocode, or algorithmic step descriptions through the input module. The input module supports multiple input formats, including text files, PDF files, and text entered directly into the system interface.

[0033] A large-scale pre-trained language model is used to perform semantic analysis on programming logic documents and generate the corresponding initial code representation in a graphical programming language. The large-scale model parsing and generation module performs semantic analysis on the input document, extracting the logical structure and functional requirements, and converting them into a preliminary representation in a graphical programming language. For example, it can identify key logical nodes such as conditionals and loop structures and convert them into the nodes and connections of a flowchart. This process leverages the large-scale model's powerful language understanding and generation capabilities, significantly reducing the workload of manually drawing flowcharts.

[0034] The initial code representation is converted into a program structure in a graphical programming language. The graphical language generation module further converts the preliminary graphical code generated by the large model into a specific graphical programming language program structure. This module converts the logical nodes and connection relationships into the data structure of a visual programming platform (such as a flowchart based on node connections), allowing users to intuitively view and edit program logic in a graphical interface.

[0035] Use the preset mini-model to perform graphical grammar rule verification on the program structure. The mini-model proofreading and optimization module intelligently verifies the generated graphical program to check for logical errors, incomplete structures, or irregularities. If any non-compliant parts are found, the mini-model will automatically modify and optimize them, such as adding missing process nodes, removing redundant or unconnected nodes, correcting incorrect connection relationships, and adjusting the flowchart layout to improve readability. The mini-model incorporates a deep learning-based layout algorithm that can intelligently arrange node positions and automatically adjust connections to avoid crossing or overlapping, thereby improving visual readability.

[0036] The program structure is verified according to the preset graphical language grammar rules. If the verification passes, the final graphical programming language program is output. If the verification fails, the non-compliant parts of the program structure are automatically modified based on the information provided by the small model, and the program returns to the previous step until the verification passes. If the small model passes the verification, the final graphical programming language program is output. If the verification fails, the non-compliant parts of the program structure are automatically modified based on the information provided by the small model, and the program returns to the previous step until the verification passes. This process ensures that the final output graphical program is correct in both logic and form.

[0037] In an embodiment of the present application, the method further includes requesting the large model to regenerate specific paragraphs or nodes when a critical error is detected during verification by the small model's proofreading and optimization module, thereby continuously correcting defects in the initial generation. The method also includes optimizing the layout of the graphical program using a deep learning-based layout algorithm to improve visual readability.

[0038] The above shows and describes the basic principles, main features and advantages of the present invention. Those skilled in the art should understand that the above embodiments do not limit the present invention in any form, and any technical solutions obtained by equivalent replacement or equivalent transformation fall within the scope of protection of the present invention.

Claims

1. An intelligent graphics programming language application system based on large model technology, characterized in that: include: An input module for acquiring programming logic documents written in natural language or pseudocode; A large model parsing and generation module, connected to the input module, for performing semantic analysis on the programming logic document and generating a corresponding graphical programming language initial code representation; A graphical language generation module, connected to the large model parsing and generation module, for converting the initial code representation into a program structure in a graphical programming language; A small model proofreading and optimization module, connected to the graphical language generation module, is used to verify the program structure according to preset graphical language grammar rules, and automatically modify and optimize when a part that does not conform to the grammar rules is detected; The output module is connected to the small model proofreading and optimization module and is used to output the graphical programming language program after verification and optimization.

2. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: The large model parsing and generation module includes a large-scale pre-trained language model for understanding the semantics of the input document; The small model proofreading and optimization module includes a verification model or rule engine trained according to the grammar of the graphical programming language, which is used to detect and correct grammatical violations or suboptimal structures in the program structure.

3. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: The small model proofreading and optimization module automatically corrects the graphical program structure when violations are found during verification, including adding missing process nodes, removing redundant or unconnected nodes, correcting incorrect connection relationships, and adjusting the flow chart layout to improve readability; The proofreading and optimization module rechecks the modified program structure to ensure that all changes comply with preset rules.

4. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: The graphical programming language program structure supports multi-layer nested conditional judgment and loop structures; The large model parsing and generation module is capable of identifying nested logic in the input document and generating a corresponding nested structure in the initial code representation; The small model proofreading and optimization module ensures that each layer of the nested structure has a correct start and end node and complies with a predetermined logical relationship, thereby accurately achieving a graphical representation of complex nested logic.

5. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: The input module supports multiple input formats, including text files, PDF files or text content directly entered into the system interface.

6. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: The output module can display the final generated graphical program in the form of a flow chart, and can also be exported to a file for further use.

7. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: The small model proofreading and optimization module integrates a deep learning-based layout algorithm, which can intelligently arrange node positions, automatically adjust connections, avoid crossing or overlapping, and improve visual readability.

8. The intelligent graphic programming language application system based on large model technology according to claim 1 is characterized in that: When the small model proofreading and optimization module finds serious errors during verification, it can request the large model to regenerate specific paragraphs or nodes to continuously correct the defects of the initial generation.

9. A method for implementing an intelligent graphics programming language based on large model technology, characterized in that: The following steps are involved: Obtain programming logic documentation written in natural language or pseudocode; Performing semantic analysis on the programming logic document using a large-scale pre-trained language model to generate a corresponding graphical programming language initial code representation; converting the initial code representation into a program structure in a graphical programming language; Performing graphical grammar rule verification on the program structure using a preset small model; Verify the program structure according to the preset graphic language grammar rules, If the verification passes, the final graphical programming language program is output. If the verification fails, the part of the program structure that does not conform to the rules is automatically modified according to the information fed back by the small model, and the previous step is returned to execute until the verification passes.

10. The method for implementing an intelligent graphics programming language based on large model technology according to claim 9, characterized in that: The method further includes requesting the large model to regenerate a specific paragraph or node when a serious error is found during verification by the small model proofreading and optimization module, so as to continuously correct the defects of the initial generation; The method also includes optimizing the layout of the graphical program using a deep learning-based layout algorithm to improve visual readability.

Images