Zero-code software development and test system based on artificial intelligence

Abstract

The invention relates to the technical field of software development, in particular to a zero-code software development and test system based on artificial intelligence, and provides the following scheme that the system comprises a natural language analysis module, a code generation module, a code optimization module, an intelligent test module and a cross-platform deployment module. The natural language analysis module analyzes the natural language description input by the user into a software development requirement document; the code generation module generates source codes based on the demand document and can select a programming language and a framework; the code optimization module is used for performing static analysis and reconstruction optimization on the generated codes; the intelligent test module automatically generates a test script through interface model extraction, case generation and case analysis logic, executes a test and feeds back a test result; and the cross-platform deployment module realizes automatic packaging, compatibility check, deployment configuration and release management of software. The invention aims to simplify the software development process and improve the development efficiency and quality.

Description

Technical Field

[0001] The present invention relates to the technical field of software development, and in particular to a zero-code software development and testing system based on artificial intelligence. Background Art

[0002] With the continuous development of software technology, the complexity and scale of software development are increasing. Traditional software development methods require developers to have high programming skills and spend a lot of time on code writing, debugging, optimization and testing. In addition, software needs to run on different operating systems and hardware platforms, which brings additional compatibility challenges to development and deployment. In order to lower the development threshold and improve development efficiency and quality, zero-code development platforms have gradually attracted attention. Zero-code development is a development method that requires no programming or very little programming. Through a graphical interface and configuration operations, users can quickly build and deploy applications. However, most of the current zero-code platforms have limited functions and cannot handle complex application requirements, especially in terms of efficient code generation, automated testing, code optimization and cross-platform deployment. There are still deficiencies. Traditional zero-code platforms mainly rely on predefined component libraries and templates, lack a deep understanding and conversion ability of users' natural language needs, and cannot flexibly respond to diverse business scenarios.

[0003] For example, the Chinese patent with the authorization announcement number CN116301811B involves a zero-code visual software development platform, including a storage unit for storing functional logic units, which can be divided into a startup logic unit, a middle logic unit and a destination logic unit; an operation unit for actively inputting the startup logic unit and the destination logic unit; a processing unit for matching the stored functional logic units with each other, and automatically generating a complete middle logic chain after clarifying the startup logic unit and the destination logic unit; and a display unit for providing a visual operation module to the user. Through the designed software development platform, using the set processing unit, it can automatically construct the middle logic chain after the user determines the startup logic unit and the destination logic unit, and display it in the display unit in the form of keyword groups, so that the user can more efficiently develop the software.

[0004] The above patents all have the problems raised by this background technology: traditional zero-code platforms mainly rely on predefined component libraries and templates, lack the ability to deeply understand and convert users' natural language needs, and cannot flexibly respond to diverse business scenarios. To solve the above problems, the present invention designs a zero-code software development and testing system based on artificial intelligence. Summary of the invention

[0005] The technical problem to be solved by the present invention is to address the deficiencies of the prior art and provide a zero-code software development and testing system based on artificial intelligence, the system comprising a natural language parsing module, a code generation module, a code optimization module, an intelligent testing module and a cross-platform deployment module. The natural language parsing module parses the natural language description input by the user into a software development requirement document; the code generation module generates source code based on the requirement document, and can select programming languages ​​and frameworks; the code optimization module performs static analysis and reconstruction optimization on the generated code; the intelligent testing module automatically generates test scripts, executes tests and feeds back test results through interface model extraction, use case generation and use case analysis logic; the cross-platform deployment module realizes automatic packaging, compatibility checking, deployment configuration and release management of the software. The present invention aims to simplify the software development process and improve development efficiency and quality.

[0006] To achieve the above object, the present invention provides the following technical solutions:

[0007] A zero-code software development and testing system based on artificial intelligence, the system comprising:

[0008] Natural language parsing module, code generation module, code optimization module, intelligent testing module and cross-platform deployment module;

[0009] The natural language parsing module is configured with a requirement processing strategy, and the requirement processing strategy is used to parse the natural language description input by the user and convert it into a software development requirement document;

[0010] The code generation module is connected to the natural language parsing module and generates corresponding source code according to the software development requirement document. The code generation module is configured with a code generation engine for selecting a programming language, framework and library and generating corresponding code according to the requirements;

[0011] The intelligent testing module is configured with a code testing strategy, which is used to generate test cases, locate error locations and predict code failure rates through machine learning methods.

[0012] The natural language parsing module comprises:

[0013] A semantic recognition unit, used to perform word segmentation, part-of-speech tagging, and syntactic analysis on the natural language description through NLP technology, extract key intentions, verbs, and target objects, and output semantic information;

[0014] A context analysis unit, used to analyze the correlation between the semantic information, perform synonym replacement and pronoun reference, merge the semantic information, and output paragraph semantic information;

[0015] A requirement mapping unit, used to map the paragraph semantic information to a predefined standardized requirement template through a knowledge graph, and output a software development requirement document;

[0016] The demand processing strategy includes semantic recognition logic, semantic fusion logic and semantic transformation logic;

[0017] The semantic recognition logic is used to decompose the user's natural language description into functional requirements and intentions, and the semantic recognition logic is configured in the semantic recognition unit;

[0018] The semantic fusion logic is used to analyze the overlap between the functional requirements and the intentions, and to fuse the functional requirements and intentions with high similarity. The semantic fusion logic is configured in the context analysis unit;

[0019] The semantic conversion logic is used to convert the integrated functional requirements and intentions into a technical requirement document, and the semantic conversion logic is configured in the requirement mapping unit.

[0020] The semantic recognition logic includes:

[0021] Perform word segmentation and part-of-speech tagging on the natural language description according to the pkuseg toolkit, obtain a candidate word sequence, and vectorize the candidate word sequence through a word embedding model;

[0022] The word weight of each word vector in the candidate word sequence is calculated through the attention mechanism, the word weight is enhanced according to the convolution operation, and the semantic weight is calculated;

[0023] Performing tensor decomposition on the word vector to construct a high-order semantic tensor, and performing singular value decomposition on the high-order semantic tensor to calculate dynamic semantics;

[0024] The word vector, semantic weight and dynamic semantics are used for intention inference through Bayesian reasoning, the output probability corresponding to the word vector is filtered according to the cascade classifier, the output probability is compared with the predefined development requirements, and the semantic information is output.

[0025] The semantic fusion logic includes:

[0026] Calculating a window size according to the semantic information, and analyzing the correlation between the semantic information by constructing a context window;

[0027] Perform dependency analysis on the semantic information in each context window according to the association degree, construct a dependency tree, and connect the dependency of each word in the sentence in the form of edges to form a directed graph;

[0028] Check whether the core intent of each branch in the dependency tree matches, if so, merge the semantic information of the branches, if not, isolate the semantic information.

[0029] The code optimization module is used to optimize the code generated by the code generation module to obtain the code to be tested, including:

[0030] A code analysis unit, used to perform static analysis on the source code to identify format problems and potential vulnerabilities in the code;

[0031] Performance optimization unit, which is used to identify data processing functions, loop functions and recursive functions in the code, analyze the complexity of the functions, and automatically reconstruct high-complexity functions based on dynamic programming algorithms;

[0032] The code refactoring unit is used to improve the readability and maintainability of the code and optimize the code structure through refactoring technology.

[0033] The intelligent testing module comprises:

[0034] An element extraction unit, used to obtain the interface element diagram of the software and extract the software interface model according to the code to be tested;

[0035] A use case generation unit, used to generate a test script according to the software interface model;

[0036] A test case execution unit is used to convert the test script into a format executable by the automated test tool, execute the test script through the automated test tool, and collect test result data;

[0037] A code feedback unit is used to analyze the test result data, generate a test report and feed it back to the code generation engine, and the code generation engine modifies the code to be tested according to the test report;

[0038] The code testing strategy includes interface model extraction logic, use case generation logic and use case analysis logic;

[0039] The interface model extraction logic is used to extract UI elements from the interface generated by the code to be tested and construct an interface model of the software;

[0040] The use case generation logic is used to automatically generate test cases and test scripts according to the extracted interface model;

[0041] The use case analysis logic is used to analyze the test execution results and generate a feedback report, and also includes analyzing the execution data collected during the test process, identifying functional errors and performance bottlenecks, and generating a test report;

[0042] The interface model extraction logic is configured in the element extraction unit, the use case generation logic is configured in the use case generation unit, and the use case analysis logic is configured in the code feedback unit.

[0043] The interface model extraction logic includes:

[0044] Calling the interface running part of the code to be tested to generate an interface element diagram;

[0045] Extract the frame matching features of the interface element graph through image processing technology, identify the frame matching features through artificial intelligence algorithm, and obtain the interface element category;

[0046] Extract text matching features of the interface element diagram through semantic recognition technology, extract the text matching features through artificial intelligence algorithm, and obtain the meaning of the interface text;

[0047] A software interface model is generated according to the interface element categories and the interface text meanings.

[0048] The use case generation logic includes:

[0049] Automatically generate different test scenarios using a combined testing method according to the software interface model, wherein the test scenarios include forward testing, reverse testing, and boundary testing;

[0050] According to the test scenario, convert the test scenario into an executable automated test script through a script generation algorithm;

[0051] In the process of automated test script generation, the optimal use case execution sequence is determined by combining static analysis and dynamic analysis.

[0052] The cross-platform deployment module manages the packaging, compatibility checking, deployment configuration and feedback process of software code in an automated manner. The module includes:

[0053] Packaging and verification unit: used to package the software source code and dependent files into an installation package suitable for the target platform, and perform compatibility checks before and after packaging;

[0054] Configuration management unit, which is used to automatically generate configuration files required for deployment according to the characteristics and requirements of the target platform and supports dynamic configuration adjustment;

[0055] The monitoring feedback unit is used to monitor the steps in the deployment process in real time, collect log information and generate feedback reports.

[0056] Compared with the prior art, the present invention has the following beneficial effects:

[0057] 1. The present invention uses a natural language parsing module, so users can use natural language to describe their needs, and the system automatically converts them into software development requirements documents and generates source code, without the need for professional programming skills, thus lowering the technical threshold for software development;

[0058] 2. The present invention can automatically generate test cases and test scripts, execute tests and analyze test results, automatically identify functional errors and performance bottlenecks in the code, and provide feedback suggestions, thereby reducing the workload of manual testing and improving software quality and reliability.

[0059] 3. Through the collaborative work between modules, the present invention realizes the automation of the entire process from demand input to code generation, optimization, testing and deployment, and supports rapid iterative development. The monitoring feedback mechanism ensures that problems in the deployment process can be discovered and fixed in a timely manner, further accelerating the software development cycle. BRIEF DESCRIPTION OF THE DRAWINGS

[0060] Other features, objects and advantages of the present invention will become more apparent from the detailed description of non-limiting embodiments made with reference to the following drawings:

[0061] Figure 1 This is a flowchart of a zero-code software development and testing method based on artificial intelligence according to Embodiment 1 of the present invention;

[0062] Figure 2 This is a schematic diagram of the natural language parsing process in Example 1 of the present invention;

[0063] Figure 3 This is a schematic diagram of the semantic recognition process of Embodiment 1 of the present invention;

[0064] Figure 4 This is a schematic diagram of a corner feature determination area according to Embodiment 1 of the present invention;

[0065] Figure 5 Identify the network structure diagram for Embodiment 1 of the present invention;

[0066] Figure 6 This is a text extraction network structure diagram of Example 1 of the present invention;

[0067] Figure 7 This is a module diagram of an artificial intelligence-based zero-code software development and testing system according to Embodiment 2 of the present invention. DETAILED DESCRIPTION

[0068] The technical solutions in the embodiments of the present invention will be described clearly and completely below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all the embodiments.

[0069] Example 1

[0070] See also Figure 1 , an embodiment provided by the present invention: a zero-code software development and testing method based on artificial intelligence, the specific steps of the method are as follows:

[0071] S1: Process the natural language description provided by the user through NLP technology and convert it into a software development requirements document;

[0072] In this step, the user inputs software development requirements in natural language through the front-end interface or API, such as "I want an application that can manage inventory". The description entered by the user is analyzed to identify the key elements, including functional requirements, non-functional requirements and performance requirements, and the key elements are converted into a structured software development requirements document, including clear functional modules, data structures and user interaction logic;

[0073] S2: Generate corresponding source code according to the software development requirement document;

[0074] In this step, functions and logic are extracted from the software development requirements document, and appropriate programming languages, frameworks and libraries are selected through a code generation engine. The code generation engine automatically generates corresponding source code according to the functional requirements in the requirements document based on predefined template libraries and algorithms;

[0075] S3: Optimizing the source code according to a set optimization strategy to generate a code to be tested;

[0076] In this step, the optimization process includes code simplification, improving algorithm efficiency, refactoring code structure, and enhancing readability;

[0077] S4: Performing automated testing on the code to be tested through a code testing strategy, modifying the code according to the test results, and generating a final version of the code;

[0078] S5: deploying the final version of the code to the required target platform through a cross-platform deployment module, automatically adjusting the requirement document according to the feedback result of the target platform, and regenerating the source code, testing and deploying;

[0079] See also Figure 2 , a schematic diagram of the natural language parsing process of an embodiment of the present invention, wherein the specific steps of processing the natural language description provided by the user by using the NLP technology are as follows:

[0080] S1.1: Use NLP technology to perform word segmentation, part-of-speech tagging, and syntactic analysis on the natural language description, extract key intents, verbs, and target objects, and output semantic information;

[0081] Through word segmentation and part-of-speech tagging, sentences in natural language are structured; then, through syntactic analysis of dependency relationships, verbs and noun phrases in sentences are parsed, and high-level semantic information (intention and target object) is extracted using deep learning models. This process ensures the accuracy and completeness of subsequent semantic information processing and requirement document generation by mapping complex natural language to precise semantic units;

[0082] S1.2: Analyze the semantic information, extract the associated set, merge the speech information in the same set, and output the paragraph semantic information;

[0083] Using semantic similarity technology, the extracted semantic information such as intent and target objects are aggregated, and the internal associations of different semantic units are identified through the graph model. By merging semantically related content, the logical consistency in the paragraphs can be ensured, making the requirements description more concise and coherent, reducing information redundancy, and improving the simplicity and logical consistency of the generated requirements document;

[0084] S1.3: Map the paragraph semantic information to a predefined standardized requirement template through a knowledge graph, and output a software development requirement document;

[0085] Through knowledge graph technology, the system can map complex semantic information into predefined structured templates, realizing the automatic conversion from natural language to standardized requirements;

[0086] By performing multi-level semantic understanding and intention reasoning on the natural language description, the parsing results are finally mapped to software development requirements. The specific steps of S1.1 are as follows:

[0087] S1.1.1: Perform word segmentation and part-of-speech tagging on the natural language description according to the pkuseg toolkit, obtain a candidate word sequence, and vectorize the candidate word sequence through a word embedding model;

[0088] pkuseg is an efficient Chinese word segmentation toolkit. It can accurately segment the input natural language description through pre-trained models and extract candidate word sequences. Next, use word embedding models (such as Word2Vec, BERT, etc.) to vectorize the candidate word sequences and map each word to a high-dimensional vector space for subsequent semantic calculations.

[0089] S1.1.2: Calculate the word weight of each word vector in the candidate word sequence through the attention mechanism, enhance the word weight according to the convolution operation, and calculate the semantic weight;

[0090] By introducing convolution operations, the local semantic understanding ability is enhanced, thus solving the problem of ignoring local semantic relations in the traditional attention mechanism;

[0091] S1.1.3: performing tensor decomposition on the word vector to construct a high-order semantic tensor, and performing singular value decomposition on the high-order semantic tensor to calculate dynamic semantics;

[0092] By performing high-order tensor decomposition on word embedding vectors, we can better capture the high-dimensional relationship between words and enhance the understanding of polysemous words and context-dependent words.

[0093] S1.1.4: Perform intent inference on the word vector, semantic weight and dynamic semantics through Bayesian reasoning, filter the output probability corresponding to the word vector according to the cascade classifier, compare the output probability with the predefined development requirements, and output semantic information;

[0094] By combining Bayesian reasoning and cascade classifiers, the system can quickly screen out the most appropriate development requirements and improve the accuracy of converting natural language descriptions into technical requirements documents;

[0095] See also Figure 3 , Schematic diagram of the semantic recognition process of an embodiment of the present invention, assuming that the natural language description input by the user is: "The system needs to be able to process the user's login request and allocate corresponding resources according to the user's authority."

[0096] First, use pkuseg to segment the description and obtain the word sequence: ["system", "need", "process", "user", "login", "request", "authority", "allocation", "resource"]. Each word is converted into a word vector through the word embedding model to form a word vector matrix.

[0097] By calculating the attention weight of each word through the self-attention mechanism, it is found that there is a high dependency between the words "user", "authority" and "resource". The weights of these words are enhanced using convolutional enhancement to calculate higher semantic weights.

[0098] The word vector is decomposed into tensors to capture the multi-level semantic information in the context, and the dynamic representation of the word vector is optimized through singular value decomposition. At this point, it can be identified that "login request and permission allocation" is the core functional intent in the description.

[0099] Use Bayesian reasoning to infer word vectors, semantic weights, and dynamic semantics, and ultimately map "processing login requests" and "authority allocation resources" to predefined development requirement templates, and output specific requirement documents, such as "the system must have a user login module and a permission management module."

[0100] By constructing a context window, analyzing the correlation between semantic information, parsing the dependency tree of the semantic information in each window, and finally integrating the matching core intents and isolating the unmatched semantic information, the specific steps of S1.2 are as follows:

[0101] S1.2.1: Calculate the window size according to the semantic information, and analyze the correlation between the semantic information by constructing a context window;

[0102] The size of the window is dynamically adjusted according to the complexity of the sentence, semantic relevance, context clues, etc. By constructing the context window, the relevance between semantic information can be analyzed at the sentence or paragraph level, and the size of the context window can be dynamically adjusted by analyzing the complexity and semantic density of the sentence;

[0103] S1.2.2: Perform dependency analysis on the semantic information in each context window according to the association degree, and construct a dependency tree. The dependency tree is used to represent the grammatical and semantic relationship between words in a sentence. By identifying the dependency structure of each word, the core intention in the sentence can be identified and represented in a tree structure. The dependency relationship of each word in the sentence is connected in the form of edges to form a directed graph.

[0104] S1.2.3: Check whether the core intention of each branch in the dependency tree matches. By comparing the subject-predicate-object structure of each branch, it is possible to determine whether the semantic information of different sentences or paragraphs is similar or overlapping. If they match, the semantic information of the branches is merged. If they do not match, the semantic information is isolated.

[0105] Assume that the two pieces of semantic information input are as follows:

[0106] Semantic information 1: "The system needs to implement user login function and allocate resources according to user permissions."

[0107] Semantic information 2: "The system should support user authentication and allocate different resources based on user identity."

[0108] Because both pieces of semantic information involve the core requirements of user authentication and permission allocation, the window size is determined to be 2 by analyzing the semantic density;

[0109] Dependency analysis is performed on the sentences in each description to construct a dependency tree. The dependency tree of semantic information 1 identifies the two core intents of "user login" and "resource allocation", while the dependency tree of semantic information 2 identifies "user authentication" and "resource allocation".

[0110] By comparing the dependency trees of the two descriptions, we found that "user login" and "user authentication" are highly similar in intent, and the matching degree is higher than the threshold, so they are merged into the "user identity authentication" function.

[0111] At the same time, it was found that the "resource allocation" intentions in the two descriptions matched perfectly, and the system further integrated them to form a complete resource management function requirement.

[0112] Finally, the output paragraph semantic information is: "The system needs to support user identity authentication and allocate resources based on user identity."

[0113] Combined with the analysis results of the software development requirements document, the code generation engine selects appropriate programming languages, frameworks and libraries to automatically generate high-quality source code. S2 specifically includes:

[0114] First, identify key information such as functional modules, data structures, interface requirements, etc. in the requirements document and map them to the code generation engine;

[0115] The code generation engine includes a set of pre-trained programming language models, which are trained through a large-scale source code library and can generate source code that is highly matched with the requirements based on the requirements document;

[0116] The code generation engine can intelligently select the appropriate programming language, framework, and library based on different requirements. For example, when the requirements involve Web development, common Web frameworks such as Django (Python) or Spring (Java) will be preferred; when dealing with data-intensive requirements, data processing libraries such as Pandas (Python) or NumPy (Python) will be selected;

[0117] Code optimization aims to optimize the generated source code through static analysis, performance optimization, and code refactoring to improve the quality and performance of the code. The specific steps of the optimization strategy are as follows:

[0118] S3.1: Perform static analysis on the generated source code, using static code analysis tools and algorithms to detect potential problems in the code, including irregular formats, unused variables, duplicate code, unhandled exceptions, and null pointer references;

[0119] Specifically, it parses the code structure through the abstract syntax tree, identifies common coding standards and potential problems through pattern matching, uses data flow analysis to track the status of variables and data, detects security vulnerabilities and logical errors, and integrates static code analysis tools (such as SonarQube, PMD, Checkstyle) to conduct a comprehensive code inspection;

[0120] S3.2: Identify data processing functions, loop functions, and recursive functions in the code, and analyze the time and space complexity of the functions to check whether there are performance bottlenecks. If there are performance bottlenecks, automatically reconstruct them through optimization algorithms (such as dynamic programming and greedy algorithms) to reduce time and space complexity. Use memory analysis and CPU analysis techniques to optimize memory allocation, garbage collection strategies, and thread management.

[0121] Dynamic programming optimizes functions with overlapping subproblems by recording the solutions to the subproblems to avoid repeated computations.

[0122] Detecting hot code segments through memory analysis tools and optimizing them can significantly reduce the average response time and resource consumption of the program;

[0123] S3.3: Refactor source code to improve code readability and maintainability, including simplifying nested structures, eliminating magic numbers, splitting and merging functions, refactoring long functions, and simplifying conditional expressions;

[0124] Through refactoring, the code becomes more modular, concise and easy to read, reducing maintenance costs, improving development efficiency and code quality, and adapting to the needs of rapid iterative development;

[0125] Through a series of automated steps, test case generation, execution and result analysis of the code to be tested are realized, thereby improving software quality and development efficiency. The specific steps of the code testing strategy are as follows:

[0126] S4.1: Call the interface running part of the code to be tested, generate an interface element diagram by taking screenshots or capturing interface information in real time, extract UI elements from the interface generated by the code to be tested, and build an interface model of the software;

[0127] Through the combination of computer vision technology and NLP technology, automatic recognition and understanding of interface elements can be achieved, providing an accurate data basis for subsequent test script generation;

[0128] S4.2: Automatically generate test scripts based on the extracted interface model, convert the test scripts into a format executable by the automated testing tool, execute the test scripts through the automated testing tool, and collect test result data to achieve full coverage of different test scenarios and ensure the stability and correctness of the software in various usage scenarios;

[0129] Use combinatorial testing methods (such as cause-and-effect diagram method, classification tree method, and path coverage method) to automatically generate different test scenarios, covering forward testing (normal operation), reverse testing (wrong input), and boundary testing (extreme situations);

[0130] Use script generation algorithms (e.g., template matching algorithms, rule inference algorithms) to convert test scenarios into executable test scripts suitable for automated testing tools (e.g., Selenium, Appium, Robot Framework);

[0131] Deploy the generated test scripts to the automated testing tool, execute the test scripts, and collect test result data (such as pass / fail status, error logs, performance metrics, etc.) in real time;

[0132] S4.3: Analyze the test execution results and generate feedback reports, including analyzing the execution data collected during the test process, identifying functional errors and performance bottlenecks, and generating test reports;

[0133] Conduct preliminary analysis on test execution results, classify and count pass / fail cases, and generate test coverage report and defect distribution report;

[0134] Combine machine learning algorithms (such as random forest and support vector machine (SVM)) to conduct further error location analysis on failed test cases to identify specific error modules and potential logic vulnerabilities in the code.

[0135] Perform cluster analysis and trend prediction on performance indicator data (such as CPU usage, memory consumption, response time, etc.), identify performance bottlenecks (such as high latency, memory leaks, etc.), and generate performance optimization suggestions.

[0136] Generate structured feedback reports, including functional error analysis, performance problem analysis, optimization suggestions, etc., and feed them back to the code generation engine to trigger automatic optimization and refactoring of the code;

[0137] The specific steps of S4.1 are as follows:

[0138] S4.1.1: Call the interface running part of the code to be tested to generate an interface element diagram;

[0139] S4.1.2: Extract frame matching features of the interface element graph by image processing technology, build a frame recognition network, identify the frame matching features by the frame recognition network, and obtain interface element categories, where the interface element categories include buttons, check boxes, menus, text boxes, and pictures;

[0140] Perform histogram statistics on the interface element map, take the peak-to-valley grayscale value between the two peaks as the segmentation threshold 1, calculate the segmentation threshold 2 according to the probability density function of the element grayscale map, obtain the optimal segmentation threshold by weighted summation of the segmentation threshold 1 and the segmentation threshold 2, compare the pixel point of the element grayscale map with the optimal segmentation threshold, if it is greater than or equal to the optimal segmentation threshold, mark the pixel point as the target area, if it is less than the optimal segmentation threshold, mark the pixel point as the background area, and cut out the target area map of the element grayscale map;

[0141] The corner features and grayscale centroid of the target area map are extracted, and the frame descriptor is calculated according to the angle between the corner features and the grayscale centroid. The frame descriptor is converted into high-dimensional data using the MLP network and added to the grayscale centroid to generate the frame matching feature. The calculation formula of the frame descriptor is:

[0142]

[0143] in, represents the frame descriptor, a represents the serial number of a single corner feature of the target area map, A represents the total number of corner features of the target area map, represents the angle between the ath corner feature and the grayscale centroid, represents the weighted value of the feature of the ath corner point, F(•) represents the Fourier transform function, and represents the horizontal and vertical coordinates of the grayscale centroid, represents the ath corner feature of the target area graph, Represents the average value of the corner features of the target area map;

[0144] The calculation formula of the frame matching feature is:

[0145] ,

[0146] Where i represents the frame matching feature number, represents a high-dimensional feature vector, and Represent the grayscale value of the i-th grayscale centroid and the frame descriptor, respectively. Represents a multi-layer perceptron network layer;

[0147] Multilayer perceptron is used to increase the dimension of frame descriptor, so that the grayscale centroid and frame descriptor are added to form a feature vector. Each frame descriptor is combined with its coordinates and confidence. Multilayer perceptron is used to embed feature points into high-dimensional vector. First, the frame descriptor is added with five-layer fully connected perceptron. Converted to 256-dimensional data, the number of channels of the five-layer perceptron are 3, 32, 64, 128 and 256 respectively;

[0148] See also Figure 4 , a schematic diagram of a corner feature judgment area according to an embodiment of the present invention, wherein the corner feature extraction comprises:

[0149] Randomly select any pixel point in the target area map, mark it as point P, and calculate the gray value of P ;

[0150] Draw a circle with P as the center and 4 pixels as the radius, and select 20 pixels on the circle boundary;

[0151] Set the grayscale threshold t. If the grayscale values ​​of 10 consecutive pixels out of 20 pixels are less than or greater than , then point P is determined to be a corner feature of the image;

[0152] The grayscale centroid extraction method includes: first obtaining an area with significant features in the image, calculating the significant center of the image, and then setting a difference threshold, calculating the difference between the grayscale value of the significant center and each pixel in the neighborhood, and comparing the accumulated difference with the difference threshold. If the sum of the accumulated grayscale value differences between the significant center and each pixel in the neighborhood is greater than the difference threshold, the significant center is marked as the grayscale centroid.

[0153] See also Figure 5 , the embodiment of the present invention identifies the network structure diagram, and the construction of the identification network includes:

[0154] An input layer, used for decoding the frame matching features through an attention mechanism, obtaining an input feature sequence, performing logarithmic operations and resizing the input feature sequence, and obtaining input parameters of a hidden layer;

[0155] Hidden layer, used to calculate the similarity between the input parameters of the hidden layer and the typical framework element data set through the normalized embedded Gaussian function, enhance and classify the similarity through the adjacency matrix and mask, and obtain the classification probability of the input parameters of each hidden layer;

[0156] The voting decision layer is used to vote on the hidden layer input parameter categories according to the classification probability. The hidden layer input parameter category with the most votes is counted as the interface element category. If the votes are the same, the probability value of the vote is added as an additional weight to recalculate the votes. The specific voting method is as follows:

[0157] Find the largest classification probability in the probability sequence of the hidden layer input parameters, vote for the category to which the largest classification probability belongs, and re-sort the remaining classification probabilities of the input parameters, take the largest classification probability among the remaining classification probabilities, and compare it with the largest classification probability. If the difference between the two probabilities is less than a comparison threshold, vote for the category corresponding to the largest classification probability among the remaining classification probabilities. The comparison threshold is determined by those skilled in the art based on a large number of experiments;

[0158] S4.1.3: Extract text matching features of the interface element diagram through semantic recognition technology, build a text extraction network, extract the text matching features through the text extraction network, and obtain the meaning of the interface text;

[0159] Adaptively binarize the interface element map to obtain the binarized element map, extract the continuous curve in the binarized element map through edge detection, perform straight line fitting on the curve, obtain the straight line and significant vanishing line in the binarized element map, and use the intersection area of ​​the significant vanishing line and the straight line as the text area;

[0160] Perform vertical projection on the text area, divide the row boundary and column boundary of the text area according to the maximum value of the vertical projection function, search for the position of half of the maximum value of the vertical integral projection function value in the forward and backward directions starting from the maximum value position of the vertical projection function, and use it as the row boundary of the text area; search for the position of two-thirds of the minimum value of the vertical integral projection function value in the forward and backward directions starting from the minimum value position of the vertical projection function, and use it as the column boundary of the text area; match the function values ​​at the row boundary and column boundary with the function value of the text area to obtain the text content vector;

[0161] The gray-level co-occurrence matrix of the text content vector is calculated, and the gray-level co-occurrence matrix includes energy features, contrast features, entropy features and correlation features. The frequency distribution function of the text content vector is obtained by Fourier transform. The text matching features are calculated according to the gray-level co-occurrence matrix and the frequency distribution function. The text matching features include contour features, geometric features and structural features. The calculation formula of the text matching features is:

[0162] ,

[0163] in, represents the text matching feature, E{•} represents the annealing genetic function, represents the Boltzmann constant, G represents the gray-level co-occurrence matrix, F represents the frequency distribution function, n represents the unit vector of the text content vector, N represents the total length of the text content vector, represents the frequency of the nth text content vector, represents the magnitude of the nth text content vector;

[0164] See also Figure 6 , a text extraction network structure diagram of an embodiment of the present invention, wherein the text extraction network comprises:

[0165] The input layer takes the text matching features as input parameters, normalizes and matrix quantizes the text matching features, and converts them into a feature matrix of size 64×64;

[0166] The convolution pooling layer convolves the input 64×64 feature matrix with a 3×3 convolution kernel in four stages, and obtains a 2×2 mapping feature through a RELU activation function and a maximum pooling operation, wherein the maximum pooling operation includes a 2×2 pooling kernel;

[0167] The output layer flattens the mapping features into a compact feature vector to obtain the text descriptor. The semantic similarity between the text descriptor and the text semantic library is calculated through character pattern matching to determine whether the convergence condition is met. If the convergence condition is not met, the error of the semantic similarity is back-propagated through the loss function. If the convergence condition is met, the text semantics corresponding to the highest semantic similarity is output as the interface text meaning;

[0168] S4.1.4: Generate a software interface model based on the interface element categories and interface text meanings.

[0169] Example 2

[0170] See also Figure 7 The present invention provides an embodiment: a zero-code software development and testing system based on artificial intelligence, the system comprising:

[0171] Natural language parsing module, code generation module, code optimization module, intelligent testing module and cross-platform deployment module;

[0172] The natural language parsing module is configured with a requirement processing strategy, and the requirement processing strategy is used to parse the natural language description input by the user and convert it into a software development requirement document;

[0173] The code generation module is connected to the natural language parsing module and generates corresponding source code according to the software development requirement document. The code generation module is configured with a code generation engine for selecting a programming language, framework and library and generating corresponding code according to the requirements;

[0174] The intelligent testing module is configured with a code testing strategy, which is used to generate test cases, locate error locations and predict code failure rates through machine learning methods.

[0175] The natural language parsing module comprises:

[0176] A semantic recognition unit, used to perform word segmentation, part-of-speech tagging, and syntactic analysis on the natural language description through NLP technology, extract key intentions, verbs, and target objects, and output semantic information;

[0177] A context analysis unit, used to analyze the correlation between the semantic information, perform synonym replacement and pronoun reference, merge the semantic information, and output paragraph semantic information;

[0178] A requirement mapping unit, used to map the paragraph semantic information to a predefined standardized requirement template through a knowledge graph, and output a software development requirement document;

[0179] The demand processing strategy includes semantic recognition logic, semantic fusion logic and semantic transformation logic;

[0180] The semantic recognition logic is used to decompose the user's natural language description into functional requirements and intentions, and the semantic recognition logic is configured in the semantic recognition unit;

[0181] The semantic fusion logic is used to analyze the overlap between the functional requirements and the intentions, and to fuse the functional requirements and intentions with high similarity. The semantic fusion logic is configured in the context analysis unit;

[0182] The semantic conversion logic is used to convert the integrated functional requirements and intentions into a technical requirement document, and the semantic conversion logic is configured in the requirement mapping unit.

[0183] The code optimization module is used to optimize the code generated by the code generation module to obtain the code to be tested, including:

[0184] A code analysis unit, used to perform static analysis on the source code to identify format problems and potential vulnerabilities in the code;

[0185] Performance optimization unit, which is used to identify data processing functions, loop functions and recursive functions in the code, analyze the complexity of the functions, and automatically reconstruct high-complexity functions based on dynamic programming algorithms;

[0186] The code refactoring unit is used to improve the readability and maintainability of the code and optimize the code structure through refactoring technology.

[0187] The intelligent testing module comprises:

[0188] An element extraction unit, used to obtain the interface element diagram of the software and extract the software interface model according to the code to be tested;

[0189] A use case generation unit, used to generate a test script according to the software interface model;

[0190] A test case execution unit is used to convert the test script into a format executable by the automated test tool, execute the test script through the automated test tool, and collect test result data;

[0191] A code feedback unit is used to analyze the test result data, generate a test report and feed it back to the code generation engine, and the code generation engine modifies the code to be tested according to the test report;

[0192] The code testing strategy includes interface model extraction logic, use case generation logic and use case analysis logic;

[0193] The interface model extraction logic is used to extract UI elements from the interface generated by the code to be tested and construct an interface model of the software;

[0194] The use case generation logic is used to automatically generate test cases and test scripts according to the extracted interface model;

[0195] The use case analysis logic is used to analyze the test execution results and generate a feedback report, and also includes analyzing the execution data collected during the test process, identifying functional errors and performance bottlenecks, and generating a test report;

[0196] The interface model extraction logic is configured in the element extraction unit, the use case generation logic is configured in the use case generation unit, and the use case analysis logic is configured in the code feedback unit.

[0197] The cross-platform deployment module manages the packaging, compatibility checking, deployment configuration and feedback process of software code in an automated manner. The module includes:

[0198] Packaging and verification unit: used to package the software source code and dependent files into an installation package suitable for the target platform, and perform compatibility checks before and after packaging;

[0199] Configuration management unit, which is used to automatically generate configuration files required for deployment according to the characteristics and requirements of the target platform and supports dynamic configuration adjustment;

[0200] The monitoring feedback unit is used to monitor the steps in the deployment process in real time, collect log information and generate feedback reports.

[0201] Although the embodiments of the present invention have been shown and described above, it is to be understood that the above embodiments are exemplary and are not to be construed as limitations of the present invention. A person skilled in the art may change, modify, replace and vary the above embodiments within the scope of the present invention.

Claims

1. A zero-code software development and testing system based on artificial intelligence, characterized in that: The system comprises: Natural language parsing module, code generation module, code optimization module, intelligent testing module and cross-platform deployment module; The natural language parsing module is configured with a requirement processing strategy, and the requirement processing strategy is used to parse the natural language description input by the user and convert it into a software development requirement document; The code generation module is connected to the natural language parsing module and generates corresponding source code according to the software development requirement document. The code generation module is configured with a code generation engine for selecting a programming language, framework and library and generating corresponding code according to the requirements; The intelligent testing module is configured with a code testing strategy, which is used to generate test cases, locate error locations and predict code failure rates through machine learning methods.

2. According to claim 1, a zero-code software development and testing system based on artificial intelligence is characterized in that: The natural language parsing module comprises: A semantic recognition unit, used to perform word segmentation, part-of-speech tagging, and syntactic analysis on the natural language description through NLP technology, extract key intentions, verbs, and target objects, and output semantic information; A context analysis unit, used to analyze the correlation between the semantic information, perform synonym replacement and pronoun reference, merge the semantic information, and output paragraph semantic information; A requirement mapping unit, used to map the paragraph semantic information to a predefined standardized requirement template through a knowledge graph, and output a software development requirement document; The demand processing strategy includes semantic recognition logic, semantic fusion logic and semantic transformation logic; The semantic recognition logic is used to decompose the user's natural language description into functional requirements and intentions, and the semantic recognition logic is configured in the semantic recognition unit; The semantic fusion logic is used to analyze the overlap between the functional requirements and the intentions, and to fuse the functional requirements and intentions with high similarity. The semantic fusion logic is configured in the context analysis unit; The semantic conversion logic is used to convert the integrated functional requirements and intentions into a technical requirement document, and the semantic conversion logic is configured in the requirement mapping unit.

3. According to claim 2, a zero-code software development and testing system based on artificial intelligence is characterized in that: The semantic recognition logic includes: Perform word segmentation and part-of-speech tagging on the natural language description according to the pkuseg toolkit, obtain a candidate word sequence, and vectorize the candidate word sequence through a word embedding model; The word weight of each word vector in the candidate word sequence is calculated through the attention mechanism, the word weight is enhanced according to the convolution operation, and the semantic weight is calculated; Performing tensor decomposition on the word vector to construct a high-order semantic tensor, and performing singular value decomposition on the high-order semantic tensor to calculate dynamic semantics; The word vector, semantic weight and dynamic semantics are used for intention inference through Bayesian reasoning, the output probability corresponding to the word vector is filtered according to the cascade classifier, the output probability is compared with the predefined development requirements, and the semantic information is output.

4. According to claim 2, a zero-code software development and testing system based on artificial intelligence is characterized in that: The semantic fusion logic includes: Calculating a window size according to the semantic information, and analyzing the correlation between the semantic information by constructing a context window; Perform dependency analysis on the semantic information in each context window according to the association degree, construct a dependency tree, and connect the dependency of each word in the sentence in the form of edges to form a directed graph; Check whether the core intent of each branch in the dependency tree matches, if so, merge the semantic information of the branches, if not, isolate the semantic information.

5. According to claim 1, a zero-code software development and testing system based on artificial intelligence is characterized in that: The code optimization module is used to optimize the code generated by the code generation module to obtain the code to be tested, including: A code analysis unit, used to perform static analysis on the source code to identify format problems and potential vulnerabilities in the code; Performance optimization unit, which is used to identify data processing functions, loop functions and recursive functions in the code, analyze the complexity of the functions, and automatically reconstruct high-complexity functions based on dynamic programming algorithms; The code refactoring unit is used to improve the readability and maintainability of the code and optimize the code structure through refactoring technology.

6. According to claim 5, a zero-code software development and testing system based on artificial intelligence is characterized in that: The intelligent testing module comprises: An element extraction unit, used to obtain the interface element diagram of the software and extract the software interface model according to the code to be tested; A use case generation unit, used to generate a test script according to the software interface model; A test case execution unit is used to convert the test script into a format executable by the automated test tool, execute the test script through the automated test tool, and collect test result data; A code feedback unit is used to analyze the test result data, generate a test report and feed it back to the code generation engine, and the code generation engine modifies the code to be tested according to the test report; The code testing strategy includes interface model extraction logic, use case generation logic and use case analysis logic; The interface model extraction logic is used to extract UI elements from the interface generated by the code to be tested and construct an interface model of the software; The use case generation logic is used to automatically generate test cases and test scripts according to the extracted interface model; The use case analysis logic is used to analyze the test execution results and generate a feedback report, and also includes analyzing the execution data collected during the test process, identifying functional errors and performance bottlenecks, and generating a test report; The interface model extraction logic is configured in the element extraction unit, the use case generation logic is configured in the use case generation unit, and the use case analysis logic is configured in the code feedback unit.

7. According to claim 6, a zero-code software development and testing system based on artificial intelligence is characterized in that: The interface model extraction logic includes: Calling the interface running part of the code to be tested to generate an interface element diagram; Extract the frame matching features of the interface element graph through image processing technology, identify the frame matching features through artificial intelligence algorithm, and obtain the interface element category; Extract text matching features of the interface element diagram through semantic recognition technology, extract the text matching features through artificial intelligence algorithm, and obtain the meaning of the interface text; A software interface model is generated according to the interface element categories and the interface text meanings.

8. According to claim 7, a zero-code software development and testing system based on artificial intelligence is characterized in that: The use case generation logic includes: Automatically generate different test scenarios using a combined testing method according to the software interface model, wherein the test scenarios include forward testing, reverse testing, and boundary testing; According to the test scenario, convert the test scenario into an executable automated test script through a script generation algorithm; In the process of automated test script generation, the optimal use case execution sequence is determined by combining static analysis and dynamic analysis.

9. According to claim 1, a zero-code software development and testing system based on artificial intelligence is characterized in that: The cross-platform deployment module manages the packaging, compatibility checking, deployment configuration and feedback process of software code in an automated manner. The module includes: Packaging and verification unit: used to package the software source code and dependent files into an installation package suitable for the target platform, and perform compatibility checks before and after packaging; Configuration management unit, which is used to automatically generate configuration files required for deployment according to the characteristics and requirements of the target platform and supports dynamic configuration adjustment; The monitoring feedback unit is used to monitor the steps in the deployment process in real time, collect log information and generate feedback reports.

Images