A low-code application development method and system based on AI-assisted generation model

Through AI-based natural language processing technology, combined with level evaluation and graph neural network, the challenges of developer level division and demand processing in low-code technology are solved, and more refined developer evaluation and efficient low-code development are achieved.

CN118760427BActive Publication Date: 2024-11-05GUANGDONG DO1 INFORMATION TECH CO LTD

Patent Information

Application Number
CN202411203791.8
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Filing Date
2024-08-30
Publication Date
2024-11-05
Estimated Expiration
2044-08-30

AI Technical Summary

Technical Problem

Low-code technology has challenges in the classification of developer levels and demand processing, especially for beginners and advanced developers, it is difficult to effectively utilize the platform, and professional developers find it difficult to troubleshoot problems when they encounter debugging, which affects efficiency and skill development. .

Method used

Using natural language processing technology based on AI, the code contribution degree and technical depth score are calculated through the developer level judgment module, combined with NLP for keyword extraction, intent recognition and context analysis, low-code DSL code is generated, and dynamically adjusted through graph neural network Graph structure to better understand user input.

Benefits of technology

Achieve more intelligent and refined developer level evaluation, improving the efficiency and accuracy of low-code development, especially in keyword extraction and intent recognition, multimodal information transformation and semantic similarity calculation are used to enable generation The keywords are more accurate and efficient, improving the intelligence level of the system.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118760427B_ABST
    Figure CN118760427B_ABST
Patent Text Reader

Abstract

The present invention discloses a low-code application development method and system based on an AI-assisted generation model, and belongs to the field of artificial intelligence technology. The system of the present invention includes: a visual development environment module, a developer level judgment module, a natural language generation low-code DSL engine module, a DSL code generation component module, and a cloud database; the visual development environment module provides a graphical interface and loads necessary components and plug-ins; the developer level judgment module divides the developer level; the natural language generation low-code DSL engine module captures and processes the application requirements input by the developer through natural language or artificial intelligence assistance, and performs keyword extraction, intent recognition, and context analysis; the DSL code generation component module generates the corresponding DSL code based on the parsing result of the natural language generation low-code DSL engine module; the cloud database stores and manages relevant information in the development process.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present invention relates to the field of artificial intelligence technology, and specifically to a low-code application development method and system based on AI-assisted generation of models. Background Art

[0002] Low-code technology, as an innovative force in modern software development, stems from the unremitting pursuit of efficient and flexible programming. It is based on visual programming, rapid application development (RAD) and model-driven architecture (MDA). Through prefabricated components, templates and intuitive graphical interfaces, it greatly accelerates the application development process and improves flexibility and scalability. Low-code technology not only seeks to simplify the application development process, but also lowers the technical threshold so that non-professional developers can also participate in the construction of applications, promote close collaboration and innovation among teams, improve development efficiency and response speed, and shorten product launch time.

[0003] Although low-code technology brings the advantages of rapid development and cost savings, it also has many limitations. For example, for beginners, it is challenging to learn how to use these platforms effectively and to use low-code for flexible expansion; for advanced developers, it is also necessary to spend time and energy to familiarize themselves with the platform's interface, tools, best practices, and even the platform's specific domain language (DSL) to fully utilize its advantages; for professional developers, the black box nature of the low-code framework makes it difficult for developers to troubleshoot and debug when they encounter problems, affecting development efficiency and limiting skill development. Summary of the invention

[0004] The purpose of the present invention is to provide a low-code application development method and system based on AI-assisted generation model to solve the problems raised in the above background technology.

[0005] In order to solve the above technical problems, the present invention provides the following technical solutions:

[0006] A low-code application development method based on AI-assisted generation model, comprising the following steps:

[0007] Step S100. The developer starts the visual development environment and enters the system through the login interface; in the visual development environment, the developer selects a project template and a low-code framework and configures the development platform;

[0008] Step S200. The developer inputs application requirements in a visual development environment through natural language or artificial intelligence assistance. The natural language generation low-code DSL engine module captures and processes user input and uses NLP technology to perform keyword extraction, intent recognition, and context analysis.

[0009] Step S300. The natural language generated low-code DSL engine module calls the NL2Form, NL2Page, NL2Process, and NL2Report components to generate corresponding DSL codes based on the analysis results of step S200. The generated DSL codes are stored in the model warehouse, and the generated forms, pages, processes, and report effects are previewed in real time in the visual development environment.

[0010] Furthermore, step S100 also includes: after the developer logs in, obtaining the history records of the corresponding developer account, and determining the level corresponding to the current developer, wherein the developer levels include beginner, advanced developer, and professional developer;

[0011] The level determination process for the current developer is as follows:

[0012] The code contribution score C is calculated by counting the number N and frequency F of code submissions by the current developer in the recent period, as well as the number H of code lines submitted by the developer. The specific calculation formula is: C=[(N×F)+H] / 2; N×F represents the developer's submission activity. Only the calculated value is retained without units, and the final score is the average value obtained by dividing the sum of the submission activity and the number of code lines by 2, so as to comprehensively consider the impact of the number and frequency of submissions and the actual code changes on the project.

[0013] The number and types of programming languages, frameworks, libraries and tools used by developers in the project, as well as the speed and efficiency of developers in solving technical problems, are counted to calculate the developer's technical depth score T. The specific calculation formula is: T=α×CT+β×SP; where CT represents the complexity of the technology stack used by the developer, SP represents the developer's technical problem-solving ability score, α and β both represent weight coefficients, and α+β=1; and CT=(JN×P) / M, JN represents the number of different programming languages, frameworks, libraries and tools used by developers in the project, P represents the average usage depth index, and M represents the project size; SP=(QN×L) / M, QN represents the number of technical problems solved by developers during the project development process, and L represents the average solution efficiency index;

[0014] Among them, for the average usage depth index P, the corresponding depth levels are defined according to programming languages, frameworks, libraries and tools, such as basic, intermediate, advanced and other levels; a depth weight is defined for each technology, for example: basic technology is 1, intermediate technology is 2, and advanced technology is 3; the depth weight of each technology is added up and then divided by the total number of technology types to obtain the average usage depth index P;

[0015] For the project size M, use code statistics tools to obtain the total number of code lines of the project, count the number of functional modules based on the project requirements document or functional specification, count the number of developers corresponding to the project, and use the weighted average method to calculate the project size M;

[0016] For the average resolution efficiency index L, for each technical problem, record the time difference required by the developer to solve the technical problem, average all the time differences to solve the problem, and get the average resolution time. The average resolution efficiency index L is expressed as the reciprocal of the average resolution time.

[0017] According to the code contribution score C and the technical depth score T, the comprehensive score S is calculated, and S=γ×C+(1-γ)×T, γ represents the coefficient; according to the result of the comprehensive score S, the developer is divided into levels. When the comprehensive score S≤threshold X, the developer is classified as a beginner; when threshold X<S≤threshold Y, the developer is classified as an advanced developer; when S>threshold Y, the developer is classified as a professional developer.

[0018] Furthermore, in step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform keyword extraction, intent recognition and context analysis, wherein the specific process of keyword extraction is as follows:

[0019] S201. The natural language generation low-code DSL engine module identifies whether the user input contains other modal information besides text. For multimodal input, the system uses multimodal fusion technology to convert information of different modalities into a unified semantic representation, and pre-processes the natural language text of the user input after multimodal information conversion, removes irrelevant characters, corrects grammatical errors, and performs word segmentation processing to decompose the text into operable units, thereby obtaining a number of text units;

[0020] S202. For each text unit, the frequency of occurrence of each word in the current text is calculated to obtain the word frequency TF, and the inverse document frequency IDF of each word in the entire corpus is calculated; the semantic vector representation of each word is obtained by using the pre-trained word embedding model, so as to obtain the corresponding word embedding vector world, and the cosine similarity CS between the words is calculated, and the specific calculation formula is: CS=(world·other_world) / [|world|·|other_world|], where other_world represents other word embedding vectors except the current word embedding vector world; the semantic similarities of all other words are averaged to obtain the average semantic similarity ACS, and the exponential function is applied to convert the average semantic similarity into an enhancement factor E, and the comprehensive score ES of each word is calculated by combining the TF-IDF value and the semantic enhancement factor E, and the calculation formula is: ES(world)=TF(world)×IDF(world)×E; according to the calculated comprehensive score ES, the words with a comprehensive score ES greater than or equal to the threshold q are selected as the final keywords, and the extracted keywords are used as the output of the module.

[0021] By semantically enhancing TF-IDF, not only word frequency and document frequency are considered, but also the semantic distance information of word embedding is integrated to make keyword extraction more accurate.

[0022] Furthermore, in step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform intent recognition, keyword extraction and context analysis. The specific process of intent recognition is as follows:

[0023] S203. Convert each text unit into a corresponding embedding vector representation, represented as: Token Embedding, and adjust the attention weight of each text unit, and the attention weight adjustment mechanism is:

[0024] Define the basic attention weight as the initial attention level of the model, expressed as: Base_Weight; calculate the keyword gain Keyword_Boost(u) according to the frequency of occurrence of keywords in text unit u. The specific calculation process is as follows:

[0025] According to the keyword recognition result in S202, a keyword set is formed. For the text unit u, the number of occurrences of each keyword in it is counted, and Keyword_Boost(u)=Σ world∈keywordsPresence(u,word)·Weight(word); Presence(u,word) indicates whether the keyword word appears in the text unit u. If so, it is 1, otherwise it is 0; Weight(word) indicates the weight of the keyword word;

[0026] According to the basic attention weight Base_Weight and the keyword gain Keyword_Boost(u), the final attention adjusted weight A(u) of the text unit u is calculated, and the calculation formula is: A(u)=Base_Weight+Keyword_Boost(u);

[0027] S204. For each intent category, calculate the corresponding intent score D, where D=Σ u Token Embedding(u)·A(u), where Token Embedding(u) represents the embedding vector of text unit u, and A(u) represents the attention-adjusted weight of text unit u. The calculated intent score D is input into the softmax function to obtain the probability distribution of each intent category, and the intent category with the highest probability is selected as the final intent recognition result.

[0028] An attention weight adjustment mechanism is introduced to dynamically adjust the weight of the attention layer in the model according to the keywords in the user input, thereby enhancing the ability to recognize key intents.

[0029] Furthermore, in step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform intent recognition, keyword extraction and context analysis, wherein the specific process of context analysis is as follows:

[0030] S205. The words in the text unit are used as nodes of the graph, and the dependency or co-occurrence relationship between the words is used as the edge to construct a graph structure, in which the nodes represent words and the edges represent the relationship between the words; the constructed text graph structure is input into the graph neural network, and the graph neural network updates the feature vector of each node by transmitting and aggregating information between nodes. In each layer of the graph neural network, according to the formula: h i (k+1) =f(∑ j A ij h j (k) W (k) +b (k) ), update the feature vector of the node; where h i (k+1) represents the feature vector of node i in the kth layer, A ijrepresents the connection strength between node i and node j, W (k) and b (k) They represent the weight and bias of the kth layer respectively, and f represents the activation function;

[0031] S206. By updating the feature vector of each node, a dynamic graph structure learning mechanism is introduced. By comparing the contribution index of the connection between two nodes to the model performance, if the contribution index is less than the threshold parameter, the corresponding edge is deleted or the corresponding weight is reduced, and new edges are dynamically added according to the new prediction results; repeat the above steps, continuously iteratively update the feature vector and graph structure of the node until the preset stop condition is met.

[0032] Introducing "dynamic graph structure learning", which automatically adjusts the structure of the graph according to the accuracy of model prediction during training, such as adding or deleting edges, to more accurately reflect the contextual information of the text.

[0033] Furthermore, step S300 includes:

[0034] The parsing results obtained by NLP technology in step S200 are integrated. According to the parsed user intention and context information, the natural language generation low-code DSL engine module calls the corresponding DSL component to generate DSL code snippets; the DSL code snippets generated by calling the DSL component are integrated into a complete DSL code, the generated DSL code file is uploaded to the model warehouse, and the relevant meta information, such as creation time, author, and project association, is recorded;

[0035] Use the preview function of the low-code platform to convert the DSL code into a visual interface display. In the visual development environment, an interactive interface is provided for developers, allowing them to view and test the actual effects of the generated forms, pages, processes and reports, allowing developers to provide instant feedback and adjustments to the preview effects, such as modifying the DSL code, adjusting the interface layout, etc.

[0036] A low-code application development system based on an AI-assisted generation model, the system comprising: a visual development environment module, a developer level judgment module, a natural language generation low-code DSL engine module, a DSL code generation component module, and a cloud database;

[0037] The visual development environment module provides a graphical interface and loads necessary components and plug-ins, including the development platform and the natural language generation low-code DSL engine module, supporting developers to select project templates and low-code frameworks and configure the development platform;

[0038] The developer level judgment module evaluates the developer's level based on the developer's history and activity, calculates the code contribution score and technical depth score; and classifies the developer into a beginner, advanced developer, or professional developer based on the comprehensive score;

[0039] The natural language generation low-code DSL engine module captures and processes application requirements input by developers through natural language or AI assistance, performs keyword extraction, intent recognition and context analysis, and supports the conversion of multimodal information into a unified semantic representation;

[0040] The DSL code generation component module generates the parsing results of the low-code DSL engine module based on the natural language, and calls the NL2Form, NL2Page, NL2Process, and NL2Report components to generate the corresponding DSL code;

[0041] The cloud database stores and manages the DSL code, project data and related information generated during the development process.

[0042] Further, the visual development environment module includes a login unit, a project template selection unit, a configuration unit, and a real-time preview unit;

[0043] The login unit is the entrance for developers to log into the system and is used for identity authentication and permission management; the project template selection unit allows developers to select preset templates that meet the corresponding project requirements; the configuration unit is used to configure the development platform and provide background support and services; the real-time preview unit displays the real-time effects of forms, pages, processes and reports generated during the development process.

[0044] Furthermore, the developer level judgment module includes a history record analysis unit, a code contribution score calculation unit, a technical depth score calculation unit, and a comprehensive score calculation unit;

[0045] The historical record analysis unit counts the number, frequency and number of code lines submitted by developers in the recent period; the code contribution score calculation unit calculates the code contribution score C based on the developer's code submission; the technical depth score calculation unit analyzes the complexity of the technology stack used by the developer in the project and the ability to solve technical problems, and calculates the technical depth score T; the comprehensive score calculation unit comprehensively considers the code contribution score and the technical depth score, calculates the comprehensive score S, and divides the developer level accordingly.

[0046] Furthermore, the natural language generation low-code DSL engine module includes a multimodal information conversion unit, a keyword extraction unit, an intent recognition unit, and a context analysis unit;

[0047] The multimodal information conversion unit converts the multimodal input into a unified semantic representation; the keyword extraction unit extracts keywords from the user input through NLP technology for the input of subsequent DSL code generation; the intention recognition unit recognizes the intention of the user input to determine the specific requirements for generating DSL code; the context analysis unit analyzes the context information of the user input in order to accurately generate DSL code;

[0048] The DSL code generation component module includes NL2Form component, NL2Page component, NL2Process component and NL2Report component;

[0049] The NL2Form component generates DSL code for the form interface; the NL2Page component generates DSL code for the page; the NL2Process component generates DSL code for the process; and the NL2Report component generates DSL code for the report.

[0050] Compared with the prior art, the beneficial effects achieved by the present invention are as follows: the present invention divides the developer level (beginner, advanced developer, professional developer) by calculating the developer's code contribution score and technical depth score, and combining the comprehensive score S. This evaluation mechanism is more intelligent and refined than the traditional level division; this method not only takes into account the quality and quantity of the developer's code, but also takes into account the breadth of the technology stack and the ability to solve problems, so as to more comprehensively evaluate the developer's actual ability. Combined with natural language processing (NLP) technology, through intent recognition, keyword extraction and context analysis, it can automatically process the developer's application demand input; especially in the keyword extraction process, multimodal information conversion and semantic similarity calculation are used to make the generated keywords more accurate and efficient. This multi-level processing method is innovative and efficient in low-code development. In the context analysis step, a graph neural network is used to dynamically update the graph structure of the text unit, and better adaptability and flexibility to application requirements are achieved through the update of node feature vectors and dynamic adjustment of edges. This dynamic learning mechanism can help the system continuously optimize its understanding and processing capabilities of user input and improve the intelligence level of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0051] The accompanying drawings are used to provide a further understanding of the present invention and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention and do not constitute a limitation of the present invention. In the accompanying drawings:

[0052] Figure 1 It is a schematic diagram of a low-code application development system module based on an AI-assisted generation model of the present invention;

[0053] Figure 2It is a schematic diagram of a low-code description business domain specific language of a low-code application development system based on an AI-assisted generation model of the present invention;

[0054] Figure 3 The present invention provides a visual modeling and runtime rendering architecture for a low-code application development system based on an AI-assisted generation model;

[0055] Figure 4 This is the implementation process of the business domain specific language (NL2DSL) for describing a low-code application development system based on an AI-assisted generation model in the present invention. DETAILED DESCRIPTION

[0056] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0057] See also Figure 1 , the present invention provides a technical solution:

[0058] A low-code application development system based on an AI-assisted generation model, the system comprising: a visual development environment module, a developer level judgment module, a natural language generation low-code DSL engine module, a DSL code generation component module, and a cloud database;

[0059] The visual development environment module provides a graphical interface and loads necessary components and plug-ins, including the development platform and the natural language generation low-code DSL engine module, supporting developers to select project templates and low-code frameworks and configure the development platform;

[0060] The developer level judgment module evaluates the developer's level based on the developer's history and activity, calculates the code contribution score and technical depth score; and classifies the developer into a beginner, advanced developer, or professional developer based on the comprehensive score;

[0061] The natural language generation low-code DSL engine module captures and processes application requirements input by developers through natural language or AI assistance, performs keyword extraction, intent recognition and context analysis, and supports the conversion of multimodal information into a unified semantic representation;

[0062] The DSL code generation component module generates the parsing results of the low-code DSL engine module based on the natural language, and calls the NL2Form, NL2Page, NL2Process, and NL2Report components to generate the corresponding DSL code;

[0063] The cloud database stores and manages the DSL code, project data and related information generated during the development process.

[0064] The visual development environment module includes a login unit, a project template selection unit, a configuration unit, and a real-time preview unit;

[0065] The login unit is the entrance for developers to log into the system and is used for identity authentication and permission management; the project template selection unit allows developers to select preset templates that meet the corresponding project requirements; the configuration unit is used to configure the development platform and provide background support and services; the real-time preview unit displays the real-time effects of forms, pages, processes and reports generated during the development process.

[0066] The developer level judgment module includes a history analysis unit, a code contribution score calculation unit, a technical depth score calculation unit, and a comprehensive score calculation unit;

[0067] The historical record analysis unit counts the number, frequency and number of code lines submitted by developers in the recent period; the code contribution score calculation unit calculates the code contribution score C based on the developer's code submission; the technical depth score calculation unit analyzes the complexity of the technology stack used by the developer in the project and the ability to solve technical problems, and calculates the technical depth score T; the comprehensive score calculation unit comprehensively considers the code contribution score and the technical depth score, calculates the comprehensive score S, and divides the developer level accordingly.

[0068] The natural language generation low-code DSL engine module includes a multimodal information conversion unit, a keyword extraction unit, an intent recognition unit, and a context analysis unit;

[0069] The multimodal information conversion unit converts the multimodal input into a unified semantic representation; the keyword extraction unit extracts keywords from the user input through NLP technology for the input of subsequent DSL code generation; the intention recognition unit recognizes the intention of the user input to determine the specific requirements for generating DSL code; the context analysis unit analyzes the context information of the user input in order to accurately generate DSL code;

[0070] The DSL code generation component module includes NL2Form component, NL2Page component, NL2Process component and NL2Report component;

[0071] The NL2Form component generates DSL code for the form interface; the NL2Page component generates DSL code for the page; the NL2Process component generates DSL code for the process; and the NL2Report component generates DSL code for the report.

[0072] A low-code application development method based on AI-assisted generation model, comprising the following steps:

[0073] Step S100. The developer starts the visual development environment and enters the system through the login interface. The system loads necessary components and plug-ins, including the development platform and the natural language generation low-code DSL engine module. In the visual development environment, the developer selects a project template and a low-code framework and configures the development platform.

[0074] Step S200. The developer inputs application requirements in a visual development environment through natural language or artificial intelligence assistance. The natural language generation low-code DSL engine module captures and processes user input and uses NLP technology to perform keyword extraction, intent recognition, and context analysis.

[0075] Step S300. The natural language generates low-code DSL engine module calls NL2Form, NL2Page, NL2Process, and NL2Report components to generate corresponding DSL codes based on the parsing results. The generated DSL codes are stored in the model warehouse, and the generated forms, pages, processes, and report effects are previewed in real time in the visual development environment.

[0076] Step S100 also includes: after the developer logs in, obtaining the history records of the corresponding developer account, and determining the level corresponding to the current developer, where the developer levels include beginner, advanced developer, and professional developer;

[0077] The level determination process for the current developer is as follows:

[0078] The code contribution score C is calculated by counting the number N and frequency F of code submissions by the current developer in the recent period, as well as the number H of code lines submitted by the developer. The specific calculation formula is: C=[(N×F)+H] / 2; N×F represents the developer's submission activity. Only the calculated value is retained without units, and the final score is the average value obtained by dividing the sum of the submission activity and the number of code lines by 2, so as to comprehensively consider the impact of the number and frequency of submissions and the actual code changes on the project.

[0079] The number and types of programming languages, frameworks, libraries and tools used by developers in the project, as well as the speed and efficiency of developers in solving technical problems, are counted to calculate the developer's technical depth score T. The specific calculation formula is: T=α×CT+β×SP; where CT represents the complexity of the technology stack used by the developer, SP represents the developer's technical problem-solving ability score, α and β both represent weight coefficients, and α+β=1; and CT=(JN×P) / M, JN represents the number of different programming languages, frameworks, libraries and tools used by developers in the project, P represents the average usage depth index, and M represents the project size; SP=(QN×L) / M, QN represents the number of technical problems solved by developers during the project development process, and L represents the average solution efficiency index;

[0080] Among them, for the average usage depth index P, the corresponding depth levels are defined according to programming languages, frameworks, libraries and tools, such as basic, intermediate, advanced and other levels; a depth weight is defined for each technology, for example: basic technology is 1, intermediate technology is 2, and advanced technology is 3; the depth weight of each technology is added up and then divided by the total number of technology types to obtain the average usage depth index P;

[0081] For example, if the developer uses 5 technologies, including 2 basic, 2 intermediate and 1 advanced technologies, the calculation method is: P = [(2×1) + (2×2) + (1×3)] / 5 = 1.5;

[0082] For the project scale M, use the code statistics tool to obtain the total number of lines of code of the project, count the number of functional modules according to the project requirement document or functional specification, count the number of developers corresponding to the project, and use the weighted average method to calculate the project scale M; for example, the total number of lines of code is SL, the number of functional modules is m1, and the number of developers is m2; assuming that the corresponding weight factors are: 0.4, 0.3, and 0.3 respectively; project scale M = (0.4×SL) + (0.3×m1) + (0.4×m2), only keep the calculated value without unit;

[0083] For the average resolution efficiency index L, for each technical problem, record the time difference required by the developer to solve the technical problem, average all the time differences to solve the problem, and get the average resolution time. The average resolution efficiency index L is expressed as the reciprocal of the average resolution time.

[0084] For example, suppose there are three technical issues and the time taken to resolve each of them is as follows (in hours):

[0085] Problem 1: (t_1=4) hours; Problem 2: (t_2=6) hours; Problem 3: (t_3=3) hours;

[0086] L=1 / [(4+6+3) / 3]. For the average solution efficiency index L, only the calculated value is retained without considering the unit.

[0087] According to the code contribution score C and the technical depth score T, the comprehensive score S is calculated, and S=γ×C+(1-γ)×T, γ represents the coefficient; according to the result of the comprehensive score S, the developer is divided into levels. When the comprehensive score S≤threshold X, the developer is classified as a beginner; when threshold X<S≤threshold Y, the developer is classified as an advanced developer; when S>threshold Y, the developer is classified as a professional developer.

[0088] In this embodiment, if Figure 2 The figure shows a schematic diagram of a low-code system describing a domain-specific language for a business, including form DSL, page DSL, process DSL, report DSL, business orchestration DSL, connector DSL, and automation DSL. These DSLs (domain-specific languages) are domain-specific languages ​​for describing business in a low-code system, and are used to define data structures, describe application business rules, and the interactive logic of pages. Specifically, this technical solution uses JSON and XML, two common basic data structures in the industry, to describe DSLs.

[0089] In step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform keyword extraction, intent recognition, and context analysis. The specific process of keyword extraction is as follows:

[0090] S201. The natural language generation low-code DSL engine module identifies whether the user input contains other modal information besides text. For multimodal input, the system uses multimodal fusion technology to convert information of different modalities into a unified semantic representation, and pre-processes the natural language text of the user input after multimodal information conversion, removes irrelevant characters, corrects grammatical errors, and performs word segmentation processing to decompose the text into operable units, thereby obtaining a number of text units;

[0091] S202. For each text unit, the frequency of occurrence of each word in the current text is calculated to obtain the word frequency TF, and the inverse document frequency IDF of each word in the entire corpus is calculated; the semantic vector representation of each word is obtained by using the pre-trained word embedding model, so as to obtain the corresponding word embedding vector world, and the cosine similarity CS between the words is calculated, and the specific calculation formula is: CS=(world·other_world) / [|world|·|other_world|], where other_world represents other word embedding vectors except the current word embedding vector world; the semantic similarities of all other words are averaged to obtain the average semantic similarity ACS, and the exponential function is applied to convert the average semantic similarity into an enhancement factor E, and the comprehensive score ES of each word is calculated by combining the TF-IDF value and the semantic enhancement factor E, and the calculation formula is: ES(world)=TF(world)×IDF(world)×E; according to the calculated comprehensive score ES, the words with a comprehensive score ES greater than or equal to the threshold q are selected as the final keywords, and the extracted keywords are used as the output of the module.

[0092] By semantically enhancing TF-IDF, not only word frequency and document frequency are considered, but also the semantic distance information of word embedding is integrated to make keyword extraction more accurate.

[0093] In step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform intent recognition, keyword extraction and context analysis. The specific process of intent recognition is as follows:

[0094] S203. Convert each text unit into a corresponding embedding vector representation, represented as: Token Embedding, and adjust the attention weight of each text unit, and the attention weight adjustment mechanism is:

[0095] Define the basic attention weight as the initial attention level of the model, expressed as: Base_Weight; calculate the keyword gain Keyword_Boost(u) according to the frequency of occurrence of keywords in text unit u. The specific calculation process is as follows:

[0096] According to the keyword recognition result in S202, a keyword set is formed. For the text unit u, the number of occurrences of each keyword in it is counted, and Keyword_Boost(u)=Σ world∈keywordsPresence(u,word)·Weight(word); Presence(u,word) indicates whether the keyword word appears in the text unit u. If so, it is 1, otherwise it is 0; Weight(word) indicates the weight of the keyword word;

[0097] According to the basic attention weight Base_Weight and the keyword gain Keyword_Boost(u), the final attention adjusted weight A(u) of the text unit u is calculated, and the calculation formula is: A(u)=Base_Weight+Keyword_Boost(u);

[0098] S204. For each intent category, calculate the corresponding intent score D, where D=Σ u Token Embedding(u)·A(u), where Token Embedding(u) represents the embedding vector of text unit u, and A(u) represents the attention-adjusted weight of text unit u. The calculated intent score D is input into the softmax function to obtain the probability distribution of each intent category, and the intent category with the highest probability is selected as the final intent recognition result.

[0099] An attention weight adjustment mechanism is introduced to dynamically adjust the weight of the attention layer in the model according to the keywords in the user input, thereby enhancing the ability to recognize key intents.

[0100] In step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform intent recognition, keyword extraction and context analysis. The specific process of context analysis is as follows:

[0101] S205. The words in the text unit are used as nodes of the graph, and the dependency or co-occurrence relationship between the words is used as the edge to construct a graph structure, in which the nodes represent words and the edges represent the relationship between the words; the constructed text graph structure is input into the graph neural network, and the graph neural network updates the feature vector of each node by transmitting and aggregating information between nodes. In each layer of the graph neural network, according to the formula: h i (k+1) =f(∑ j A ij h j (k) W (k) +b (k) ), update the feature vector of the node; where h i (k+1) represents the feature vector of node i in layer k, A ij represents the connection strength between node i and node j, W(k) and b (k) They represent the weight and bias of the kth layer respectively, and f represents the activation function;

[0102] S206. By updating the feature vector of each node, a dynamic graph structure learning mechanism is introduced. By comparing the contribution index of the connection between two nodes to the model performance, if the contribution index is less than the threshold parameter, the corresponding edge is deleted or the corresponding weight is reduced, and new edges are dynamically added according to the new prediction results; repeat the above steps, continuously iteratively update the feature vector and graph structure of the node until the preset stop condition is met.

[0103] Introducing "dynamic graph structure learning", which automatically adjusts the structure of the graph according to the accuracy of model prediction during training, such as adding or deleting edges, to more accurately reflect the contextual information of the text.

[0104] In this embodiment, if Figure 3 As shown, the functional modules in the development platform include form designer, page designer, process designer, report designer and model warehouse, among which the form designer is used to visually edit the form data model, business model and page layout model of the application. The page designer is used to visually edit the page components, properties and event models of the application. The process designer is used to visually edit the approval process nodes, approval permissions and notification models of the application. The report designer is used to visually edit the report chart components, filter components and dashboard layout of the application.

[0105] Specifically, the form designer generates form DSL, the page designer generates page DSL, the process designer generates process DSL, and the report designer generates report DSL. After the user performs the save and publish operations, these DSLs are stored in the model warehouse in JSON and XML data structures.

[0106] Furthermore, the development platform reads DSL data from the model repository, parses and runs it through the engine module of the development platform, and renders the application page presented to the end user in real time, generating application software based on the B / S architecture.

[0107] Step S300 includes:

[0108] The parsing results obtained by NLP technology in step S200 are integrated. According to the parsed user intention and context information, the natural language generation low-code DSL engine module calls the corresponding DSL component to generate DSL code snippets; the DSL code snippets generated by calling the DSL component are integrated into a complete DSL code, the generated DSL code file is uploaded to the model warehouse, and the relevant meta information, such as creation time, author, and project association, is recorded;

[0109] Use the preview function of the low-code platform to convert the DSL code into a visual interface display. In the visual development environment, an interactive interface is provided for developers, allowing them to view and test the actual effects of the generated forms, pages, processes and reports, allowing developers to provide instant feedback and adjustments to the preview effects, such as modifying the DSL code, adjusting the interface layout, etc.

[0110] In this embodiment, if Figure 4 As shown, in addition to the form designer, page designer, process designer, report designer and model warehouse, the functional modules of the development platform also include the AI ​​Prompt Input module and the natural language generation low-code DSL (NL2DSL) engine module.

[0111] The AI ​​Prompt Input module is embedded in the form designer, page designer, process designer, and report designer modules. The AI ​​Prompt Input module allows users to enter or edit prompts for interacting with the AI ​​system (AIAgent Platform). Embedding it in the above designers can enhance the human-computer interaction experience of the designer and call the natural language generation low-code DSL (NL2DSL) engine module to generate personalized content in real time.

[0112] The natural language generation low-code DSL (NL2DSL) engine module includes NL2Form, NL2Page, NL2Process, NL2Report and AI Agent Platform modules. The core capability of the natural language generation low-code DSL (NL2DSL) engine module is to convert natural language into a low-code system to describe a specific language for the business domain, and to achieve conversion between natural language and a low-code system to describe a specific language for the business domain through steps such as natural language processing and code generation. Among them, the NL2Form submodule calls the AI ​​Agent Platform module to achieve conversion between natural language and form DSL, the NL2Page submodule calls the AI ​​Agent Platform module to achieve conversion between natural language and page DSL, the NL2Process submodule calls the AI ​​Agent Platform module to achieve conversion between natural language and process DSL, and the NL2Report submodule calls the AIAgent Platform module to achieve conversion between natural language and report DSL.

[0113] Next, the AI ​​Agent Platform module connects to the capabilities of the private large model platform or the public cloud large model platform. First, perform natural language understanding (NLU): the system performs grammatical analysis, lexical analysis, and semantic analysis on the natural language input by the user to understand and parse the semantics of the natural language. Then perform semantic parsing: parse the semantics of the natural language in the previous step and generate an abstract syntax tree (AST) for intermediate representation. Finally, perform code generation: generate the corresponding low-code system description business domain specific language (DSL) based on the intermediate representation of the abstract syntax tree (AST) generated in the previous step.

[0114] It should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device.

[0115] Finally, it should be noted that the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art can still modify the technical solutions described in the aforementioned embodiments or replace some of the technical features therein by equivalents. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.

Claims

1. A low-code application development method based on AI-assisted generation model, characterized by: The method comprises the following steps: Step S100. The developer starts the visual development environment and enters the system through the login interface; in the visual development environment, the developer selects a project template and a low-code framework and configures the development platform; Step S200. The developer inputs application requirements in a visual development environment through natural language or artificial intelligence assistance. The natural language generation low-code DSL engine module captures and processes user input and uses NLP technology to perform keyword extraction, intent recognition, and context analysis. Step S300. The natural language generation low-code DSL engine module calls the NL2Form, NL2Page, NL2Process, and NL2Report components to generate corresponding DSL codes according to the analysis results of step S200. The generated DSL codes are stored in the model warehouse, and the generated forms, pages, processes, and report effects are previewed in real time in the visual development environment; The step S100 also includes: after the developer logs in, obtaining the history records of the corresponding developer account, and determining the level corresponding to the current developer, wherein the developer levels include beginner, advanced developer, and professional developer; The level determination process for the current developer is as follows: Count the number of code submissions N and frequency F of the current developer in the recent period, as well as the number of code lines H submitted by the developer, and calculate the code contribution score C. The specific calculation formula is: C = [(N×F)+H] / 2; The number and types of programming languages, frameworks, libraries, and tools used by developers in their projects, as well as the speed and efficiency of developers in solving technical problems, are counted to calculate the developer's technical depth score T. The specific calculation formula is: T = α × CT + β × SP; where CT represents the complexity of the technology stack used by the developer, SP represents the developer's technical problem-solving ability score, α and β both represent weight coefficients, and α + β = 1; And CT = (JN × P) / M, JN represents the number of different programming languages, frameworks, libraries and tools used by developers in the project, P represents the average usage depth index, and M represents the project scale; SP = (QN × L) / M, QN represents the number of technical problems solved by developers in the project development process, and L represents the average resolution efficiency index; wherein, for the average usage depth index P, the corresponding depth level is defined according to the programming language, framework, library and tool, a depth weight is defined for each technology, the depth weight of each technology is summed up, and then divided by the total number of technology types to obtain the average usage depth index P; for the project scale M, the total number of code lines of the project is obtained through the code statistics tool, the number of functional modules is counted according to the project requirement document or functional specification, the number of developers corresponding to the project is counted, and the project scale M is calculated using the weighted average method; for the average resolution efficiency index L, for each technical problem, the time difference required by the developer to solve the technical problem is recorded, all the time differences for solving the problem are averaged to obtain the average resolution time, and the average resolution efficiency index L is represented by the inverse of the average resolution time; for the above average usage depth index P and average resolution efficiency index L, the corresponding values ​​are retained without units; According to the code contribution score C and the technical depth score T, the comprehensive score S is calculated, and S = γ × C + (1-γ) × T, γ represents the coefficient; according to the result of the comprehensive score S, the developer is divided into levels. When the comprehensive score S ≤ threshold X, the developer is classified as a beginner; when threshold X < S ≤ threshold Y, the developer is classified as an advanced developer; when S > threshold Y, the developer is classified as a professional developer; In step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform keyword extraction, intent recognition and context analysis. The specific process of keyword extraction is as follows: The natural language generation low-code DSL engine module identifies whether the user input contains other modal information besides text. For multimodal input, the system uses multimodal fusion technology to convert information of different modalities into a unified semantic representation, and pre-processes the natural language text of the user input after multimodal information conversion to remove irrelevant characters, correct grammatical errors, and perform word segmentation to decompose the text into operable units, thereby obtaining several text units; For each text unit, the frequency of occurrence of each word in the current text is calculated to obtain the word frequency TF, and the inverse document frequency IDF of each word in the entire corpus is calculated; the pre-trained word embedding model is used to obtain the semantic vector representation of each word, thereby obtaining the corresponding word embedding vector world, and the cosine similarity CS between words is calculated. The specific calculation formula is: CS = (world·other_world) / [|world|·|other_world|], where other_world represents other word embedding vectors except the current word embedding vector world; the semantic similarities of all other words are averaged to obtain the average semantic similarity ACS, and the exponential function is used to convert the average semantic similarity into the enhancement factor E. Combined with the TF-IDF value and the semantic enhancement factor E, the comprehensive score ES of each word is calculated, and the calculation formula is: ES(world) = TF(world)×IDF(world)×E; according to the calculated comprehensive score ES, the words with a comprehensive score ES greater than or equal to the threshold q are selected as the final keywords, and the extracted keywords are used as the output of the module; The specific process of context analysis is as follows: The words in the text unit are used as nodes of the graph, and the dependency or co-occurrence relationship between words is used as the edge to build a graph structure, where the nodes represent words and the edges represent the relationship between words. The constructed text graph structure is input into the graph neural network, and the graph neural network updates the feature vector of each node by transferring and aggregating information between nodes. In each layer of the graph neural network, according to the formula: h i (k+1) =f(∑ j A ij h j (k) W (k) +b (k) ), update the feature vector of the node; where h i (k+1) represents the feature vector of node i in the kth layer, A ij represents the connection strength between node i and node j, W (k) and b (k) They represent the weight and bias of the kth layer respectively, and f represents the activation function; By updating the feature vector of each node, a dynamic graph structure learning mechanism is introduced. By comparing the contribution index of the connection between two nodes to the model performance, if the contribution index is less than the threshold parameter, the corresponding edge is deleted or the corresponding weight is reduced, and new edges are dynamically added according to the new prediction results; repeat the above steps, continuously iteratively update the node feature vector and graph structure until the preset stop condition is met.

2. A low-code application development method based on AI-assisted generation model according to claim 1, characterized in that: In step S200, the natural language generation low-code DSL engine module captures and processes user input, and uses NLP technology to perform intent recognition, keyword extraction and context analysis. The specific process of intent recognition is as follows: Each text unit is converted into a corresponding embedding vector representation, expressed as: Token Embedding, and the attention weight is adjusted for each text unit, and the attention weight adjustment mechanism is: Define the basic attention weight as the initial attention level of the model, expressed as: Base_Weight; calculate the keyword gain Keyword_Boost(u) according to the frequency of occurrence of keywords in text unit u. The specific calculation process is as follows: According to the keyword recognition results, a keyword set is formed. For the text unit u, the number of occurrences of each keyword in it is counted, Keyword_Boost(u) = Σ world∈keywords Presence(u,word)·Weight(word); Presence(u,word) indicates whether the keyword word appears in the text unit u. If so, it is 1, otherwise it is 0; Weight(word) indicates the weight of the keyword word; According to the basic attention weight Base_Weight and the keyword gain Keyword_Boost(u), the final attention adjusted weight A(u) of the text unit u is calculated, and the calculation formula is: A(u)=Base_Weight+Keyword_Boost(u); For each intent category, calculate the corresponding intent score D, and D = Σ u Token Embedding(u)·A(u), where Token Embedding(u) represents the embedding vector of text unit u, and A(u) represents the attention-adjusted weight of text unit u. The calculated intent score D is input into the softmax function to obtain the probability distribution of each intent category, and the intent category with the highest probability is selected as the final intent recognition result.

3. According to claim 1, a low-code application development method based on AI-assisted generation model is characterized in that: The step S300 includes: The parsing results obtained by NLP technology in step S200 are integrated. According to the parsed user intention and context information, the natural language generation low-code DSL engine module calls the corresponding DSL component to generate DSL code snippets; the DSL code snippets generated by calling the DSL component are integrated into a complete DSL code, the generated DSL code file is uploaded to the model warehouse, and the relevant meta information is recorded; Use the preview function of the low-code platform to convert DSL code into a visual interface display. In a visual development environment, an interactive interface is provided for developers, allowing them to view and test the actual effects of generated forms, pages, processes, and reports, allowing developers to provide instant feedback and adjustments to the preview effects.

4. A low-code application development system based on an AI-assisted generation model, applied to a low-code application development method based on an AI-assisted generation model as claimed in any one of claims 1 to 3, characterized in that: The system includes: a visual development environment module, a developer level judgment module, a natural language generation low-code DSL engine module, a DSL code generation component module and a cloud database; The visual development environment module provides a graphical interface, loads necessary components and plug-ins, including a development platform and a natural language generation low-code DSL engine module, supports developers in selecting project templates and low-code frameworks, and configures the development platform; The developer level judgment module evaluates the developer's level based on the developer's historical records and activity, calculates the code contribution score and the technical depth score; and classifies the developer into a beginner, advanced developer or professional developer based on the comprehensive score; The natural language generation low-code DSL engine module captures and processes application requirements input by developers through natural language or artificial intelligence assistance, performs keyword extraction, intent recognition and context analysis, and supports the conversion of multimodal information into a unified semantic representation; The DSL code generation component module generates the parsing result of the low-code DSL engine module according to the natural language, and calls the NL2Form, NL2Page, NL2Process, and NL2Report components to generate the corresponding DSL code; The cloud database stores and manages DSL codes, project data and related information generated during the development process.

5. A low-code application development system based on an AI-assisted generation model according to claim 4, characterized in that: The visual development environment module includes a login unit, a project template selection unit, a configuration unit and a real-time preview unit; The login unit is the entrance for developers to log into the system and is used for identity authentication and authority management; the project template selection unit is used for developers to select preset templates for corresponding project requirements; The configuration unit is used to configure the development platform and provide background support and services; The real-time preview unit displays the real-time effects of the forms, pages, processes and reports generated during the development process.

6. A low-code application development system based on an AI-assisted generation model according to claim 4, characterized in that: The developer level judgment module includes a history analysis unit, a code contribution score calculation unit, a technical depth score calculation unit and a comprehensive score calculation unit; The history analysis unit counts the number, frequency and number of code lines submitted by the developer in the recent period; the code contribution score calculation unit calculates the code contribution score C according to the code submission of the developer; the technical depth score calculation unit analyzes the complexity of the technology stack used by the developer in the project and the ability to solve technical problems, and calculates the technical depth score T; The comprehensive score calculation unit comprehensively considers the code contribution score and the technical depth score, calculates a comprehensive score S, and divides the developer level accordingly.

7. A low-code application development system based on an AI-assisted generation model according to claim 4, characterized in that: The natural language generation low-code DSL engine module includes a multimodal information conversion unit, a keyword extraction unit, an intent recognition unit, and a context analysis unit; The multimodal information conversion unit converts the multimodal input into a unified semantic representation; the keyword extraction unit extracts keywords from the user input by using NLP technology for input of subsequent DSL code generation; the intention recognition unit recognizes the intention of the user input to determine the specific requirements for generating the DSL code; the context analysis unit analyzes the context information of the user input so as to accurately generate the DSL code; The DSL code generation component module includes NL2Form component, NL2Page component, NL2Process component and NL2Report component; The NL2Form component generates DSL code for the form interface; the NL2Page component generates DSL code for the page; the NL2Process component generates DSL code for the process; The NL2Report component generates the DSL code for the report.

Citation Information

Patent Citations

  • Method and device for digitally measuring user code contribution in low-code platform

    CN116431133A

  • Application building method and device, equipment and storage medium

    CN117193738A

  • Software development management method based on artificial intelligence

    CN118295640A

  • Code injection from natural language derived intent

    US20220350574A1

Cited By

  • A multimodal perception and self-evolving code generation agent method

    CN123089819A