Software Development System Based on Artificial Intelligence Technology

Abstract

The present invention discloses a software development system based on artificial intelligence technology, and relates to the field of software development technology. A software development system based on artificial intelligence technology includes: a user demand analysis module, a self-awareness module, an automatic code generation module and an intelligent feedback optimization module. The present invention simulates human intelligence through the self-awareness module, perceives changes in the development process in real time, and performs self-learning and adjustment according to historical data and real-time feedback; this adaptive capability enables the system to automatically optimize the development strategy according to different needs, technical changes and development progress, ensuring that the software development process can flexibly respond to various dynamic changes, avoiding frequent manual intervention in the traditional development process due to demand changes or technical bottlenecks.

Description

Technical Field

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

[0002] With the continuous changes in software development requirements and the rapid advancement of technology, traditional software development methods face many challenges, including frequent changes in requirements, low development efficiency, difficulty in ensuring code quality, and long development cycles. At present, although there are many tools and methods that try to improve development efficiency through automation, these methods generally have shortcomings such as poor adaptability, lack of real-time feedback and optimization, and cannot effectively cope with dynamic changes in the development process.

[0003] The traditional software development process usually includes stages such as requirements analysis, design, coding, testing and maintenance. However, in actual operation, these links rely on manual intervention, especially in the process of requirements analysis and code generation. Since changes in requirements are not reflected in the development process in a timely manner, the development team needs to make a lot of manual adjustments, resulting in low development efficiency and unstable code quality. In addition, existing code generation tools and automated testing methods are mostly limited to static inspection and post-correction, and lack the ability to perceive and self-correct in real time.

[0004] In order to solve these problems, AI-based technologies have been applied to software development in recent years, especially in demand analysis, automated code generation, and performance optimization, and have made some progress. However, existing technologies are still unable to form an intelligent closed-loop system, especially in the adaptive development process, which lacks intelligent mechanisms that can adjust, optimize, and correct based on real-time feedback and historical data during the development process. Summary of the invention

[0005] The present invention proposes a software development system based on artificial intelligence technology, in which the self-awareness module simulates the self-learning and self-correction capabilities of human intelligence. The module can perform self-evaluation, diagnosis and correction according to real-time feedback, historical data and development status during the entire software development process, thereby improving development efficiency, ensuring code quality, and realizing dynamic optimization of the development process.

[0006] A software development system based on artificial intelligence technology, the system comprising the following modules:

[0007] Module S1: a user demand analysis module, used to receive and process demand data input by a user; the user demand analysis module includes a natural language processing unit, a demand parsing unit and a demand priority analysis unit;

[0008] A natural language processing unit is used to analyze the user's demand information input through natural language and identify the functions, performance and other constraints in the demand;

[0009] A requirement parsing unit, used to convert the information parsed by the natural language processing unit into structured data to form a requirement model, wherein the requirement model includes at least descriptions of functional requirements, performance requirements, and user interface requirements;

[0010] The requirement priority analysis unit is used to evaluate the priority of each requirement and generate the execution order of software development tasks according to the requirement priority;

[0011] Module S2: Self-awareness module, used to simulate the structure of human intelligence, so that the software can perceive its own state, understand environmental changes, and conduct self-learning and adaptive adjustments based on historical experience, perform self-assessment and self-correction, so as to adjust and optimize the software development strategy; the self-awareness module includes a self-assessment unit, a self-diagnosis unit, and a self-correction unit;

[0012] A self-assessment unit to evaluate the quality of generated code, functional implementation and its consistency with user requirements during the development process;

[0013] A self-diagnosis unit that automatically identifies potential defects, performance bottlenecks, or logic errors in the code based on the evaluation results;

[0014] A self-correction unit, which is used to automatically generate correction strategies and adjust the logic or algorithm of the generated code according to the results of self-diagnosis to optimize the development process;

[0015] Module S3: an automatic code generation module, used to automatically generate source code according to the user demand model; the code generation module includes a program template matching unit and a deep learning code generation unit;

[0016] The program template matching unit selects and matches appropriate program templates based on development requirements and automatically generates code;

[0017] A deep learning code generation unit generates code through a trained deep neural network model based on user demand data and previous development data;

[0018] Module S4: an intelligent feedback optimization module, which is used to monitor the execution effect of the automatically generated code in real time, and automatically optimize the logic, structure and performance of the generated code according to the feedback information; the intelligent feedback optimization module includes an execution result evaluation unit and an optimization strategy generation unit;

[0019] An execution result evaluation unit is used to monitor and evaluate the actual running results of the generated code and compare the differences with the predetermined goals;

[0020] The optimization strategy generation unit adjusts the algorithm, data structure or optimization strategy of the generated code according to the evaluation results, generates a new code version and automatically updates the system.

[0021] As a preferred technical solution of the present invention, the user demand analysis module includes:

[0022] Analyze the user input requirement description through natural language processing technology (NLP) and use machine learning algorithms to extract key functional requirements;

[0023] Functional requirements analysis: identifying and extracting users’ specific requirements for system functions, including data processing capabilities, algorithm requirements, and interface design;

[0024] Performance requirements analysis: identifying and extracting user requirements for system performance, including response time, throughput, and resource consumption;

[0025] User interface requirements analysis, extracting interface design requirements from user requirements. Interface design requirements include interface layout, interaction method and style.

[0026] As a preferred technical solution of the present invention, the self-awareness module includes:

[0027] Self-learning mechanism, through reinforcement learning algorithm, based on the feedback data in the development process, continuously adjusts and optimizes the development strategy, code generation method and self-correction mechanism; uses historical development data and real-time feedback to improve the system's adaptive and optimization capabilities;

[0028] The self-assessment unit evaluates the quality of the generated code according to the following criteria:

[0029] Functional integrity, including whether the functions fully meet user needs; performance compliance, including code execution efficiency and resource consumption; maintainability, including the clarity and scalability of the code structure; security, including vulnerabilities or potential security risks in the code;

[0030] The self-assessment unit automatically generates code optimization strategies based on the results of self-diagnosis. The optimization strategies include:

[0031] Improve algorithms or data structures to improve code performance; refactor code to improve maintainability and readability; automatically fix errors or vulnerabilities in code to improve software stability and security;

[0032] The self-correction unit automatically generates a correction plan based on the following information:

[0033] Execution logs and operation data during the development process; real-time feedback or evaluation from users; detection results of errors, warnings, or performance bottlenecks in the system;

[0034] The Self-Awareness Module works in conjunction with the Requirements Analysis Module to optimize the requirements analysis process by:

[0035] Automatically extract implicit needs and infer needs that users may have missed by learning from historical data; dynamically adjust the demand model according to the needs input by users, and optimize the demand analysis strategy based on historical feedback;

[0036] The self-awareness module works in conjunction with the automatic code generation module to optimize the code generation process by:

[0037] When generating code, monitor the quality of the generated code in real time and adjust the code generation strategy based on the evaluation results;

[0038] Automatically select appropriate algorithms, data structures or templates to optimize the execution efficiency and quality of generated code;

[0039] The self-awareness module works in conjunction with the intelligent feedback optimization module, which is used to perform real-time evaluation of the execution results of the generated code, including but not limited to:

[0040] Whether the function meets the user's needs; the execution performance of the code, such as response time and memory consumption; user feedback, including bug reports and performance evaluations;

[0041] The self-correction and optimization process of the self-awareness module is a closed-loop process, which includes:

[0042] After the code is generated, evaluation data is collected through automated testing and user feedback; the evaluation results are fed back to the self-awareness module for self-correction and optimization; the optimized code is tested and evaluated by users again to form new feedback and enter the next round of optimization.

[0043] As a preferred technical solution of the present invention, the automatic code generation module adopts one or a combination of the following technologies:

[0044] Program synthesis technology, which analyzes user requirements and selects corresponding program templates or frameworks to automatically synthesize source code that meets the requirements. The technology can generate efficient and easy-to-maintain code;

[0045] Code generation based on generative adversarial networks (GANs) generates program code based on the input requirement description by training the generative adversarial network model;

[0046] Graph Neural Network (GNN) generates code, which processes the requirement data and code structure diagram through the graph neural network to automatically generate code consistent with the requirements.

[0047] As a preferred technical solution of the present invention, the intelligent feedback optimization module includes:

[0048] The intelligent feedback optimization module optimizes the generated code according to the real-time evaluation results, and the optimization includes but is not limited to:

[0049] Adjust generated code based on performance bottlenecks; optimize code structure based on user feedback; automatically fix problems in the code based on bug fix suggestions;

[0050] Anomaly detection unit, used to detect possible anomalies in the generated code, including runtime errors, logical errors, or code that does not meet performance requirements;

[0051] Adaptive optimization unit, which automatically adjusts the development process or optimization strategy based on detected anomalies or performance bottlenecks, including algorithm improvement and parallel processing;

[0052] The reinforcement learning optimization mechanism uses reinforcement learning algorithms to automatically adjust the code generation strategy based on the system's historical feedback and optimization results, thereby achieving more efficient development.

[0053] A software development method based on artificial intelligence technology, the method comprising:

[0054] Receive demand data input by users, analyze and abstract user needs through natural language processing and machine learning technology, and generate a structured demand model;

[0055] Automatically generate source code, using an automatic code generation module to generate source code that meets the requirements according to the requirement model;

[0056] Evaluate the execution effect of the generated code in real time. Use the intelligent feedback optimization module to evaluate the actual effect of the generated code, including the completeness of the function and the compliance of the performance.

[0057] Perform self-correction and optimization based on the evaluation results, and automatically adjust the development strategy, optimize code logic, and improve code quality through the self-correction module;

[0058] The optimized code is returned to the user and further optimized based on user feedback.

[0059] As a preferred technical solution of the present invention, the demand data analysis includes:

[0060] Semantic understanding of requirements: using natural language processing technology to convert users’ natural language requirements into structured data that can be understood by machines;

[0061] Functional requirement extraction: extract the functional modules and specific requirements that the system must implement through requirement analysis technology;

[0062] Performance requirements analysis: analyzing users’ specific requirements for system performance, including response time and processing power, and incorporating them into development tasks;

[0063] Interface requirements analysis, identifying user requirements for the system interface, including interface layout and user interaction methods.

[0064] As a preferred technical solution of the present invention, self-correction and optimization include:

[0065] Automatically identify code defects, using automated tools or machine learning algorithms to identify defects in the code, including syntax errors, logic errors, and performance issues;

[0066] Generate repair strategies based on defects, generate repair solutions through self-correction modules, and automatically repair source code;

[0067] Self-optimization: By learning feedback data from historical development processes, it automatically adjusts development strategies and code generation methods to improve the quality and efficiency of subsequent code generation.

[0068] As a preferred technical solution of the present invention, the intelligent feedback optimization process includes:

[0069] User feedback analysis: evaluate the actual performance of the system based on user feedback and determine its compliance with requirements;

[0070] Automatically generate optimization solutions. Automatically generate code optimization solutions through intelligent algorithms, and return the optimized code to the user to form a closed loop.

[0071] The present invention has the following advantages:

[0072] The present invention simulates human intelligence through a self-awareness module, perceives changes in the development process in real time, and performs self-learning and adjustments based on historical data and real-time feedback; this adaptive capability enables the system to automatically optimize development strategies according to different requirements, technological changes, and development progress, ensuring that the software development process can flexibly respond to various dynamic changes, avoiding frequent manual intervention in the traditional development process due to changes in requirements or technical bottlenecks.

[0073] The present invention uses self-assessment, self-diagnosis and self-correction functions to identify defects, performance bottlenecks and logical errors in the code in real time, and automatically generates correction strategies to optimize code structure and algorithms; this closed-loop self-correction process greatly improves code quality, reduces the workload of manual debugging and later modifications, and shortens the development cycle.

[0074] The present invention reduces the tedious manual operations in the traditional development process and significantly improves development efficiency by automating demand analysis, code generation, real-time monitoring and performance optimization. The introduction of the self-awareness module makes the code generation process not only rely on template matching or static rules, but also continuously optimizes based on dynamic feedback and historical data, thereby generating more efficient and more demand-oriented codes, ensuring the high quality of software products. BRIEF DESCRIPTION OF THE DRAWINGS

[0075] Figure 1 A schematic diagram of the structure of a software development system based on artificial intelligence technology adopted in an embodiment of the present invention. DETAILED DESCRIPTION

[0076] In order to enable persons skilled in the art to better understand the technical solutions in the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present invention.

[0077] Example 1, a software development system based on artificial intelligence technology, see Figure 1 As shown, it includes the following modules:

[0078] A software development system based on artificial intelligence technology, the system comprising the following modules:

[0079] Module S1: a user demand analysis module, used to receive and process demand data input by a user; the user demand analysis module includes a natural language processing unit, a demand parsing unit and a demand priority analysis unit;

[0080] A natural language processing unit is used to analyze the user's demand information input through natural language and identify the functions, performance and other constraints in the demand;

[0081] A requirement parsing unit, used to convert the information parsed by the natural language processing unit into structured data to form a requirement model, wherein the requirement model includes at least descriptions of functional requirements, performance requirements, and user interface requirements;

[0082] The requirement priority analysis unit is used to evaluate the priority of each requirement and generate the execution order of software development tasks according to the requirement priority;

[0083] The user needs analysis module includes:

[0084] Analyze the user input requirement description through natural language processing technology (NLP) and use machine learning algorithms to extract key functional requirements;

[0085] Functional requirements analysis: identifying and extracting users’ specific requirements for system functions, including data processing capabilities, algorithm requirements, and interface design;

[0086] Performance requirements analysis: identifying and extracting user requirements for system performance, including response time, throughput, and resource consumption;

[0087] User interface requirements analysis, extracting interface design requirements from user requirements. Interface design requirements include interface layout, interaction method and style.

[0088] Module S2: Self-awareness module, used to simulate the structure of human intelligence, so that the software can perceive its own state, understand environmental changes, and conduct self-learning and adaptive adjustments based on historical experience, perform self-assessment and self-correction, so as to adjust and optimize the software development strategy; the self-awareness module includes a self-assessment unit, a self-diagnosis unit, and a self-correction unit;

[0089] A self-assessment unit to evaluate the quality of generated code, functional implementation and its consistency with user requirements during the development process;

[0090] A self-diagnosis unit that automatically identifies potential defects, performance bottlenecks, or logic errors in the code based on the evaluation results;

[0091] A self-correction unit, which is used to automatically generate correction strategies and adjust the logic or algorithm of the generated code according to the results of self-diagnosis to optimize the development process;

[0092] The Self-Awareness Module includes:

[0093] Self-learning mechanism, through reinforcement learning algorithm, based on the feedback data in the development process, continuously adjusts and optimizes the development strategy, code generation method and self-correction mechanism; uses historical development data and real-time feedback to improve the system's adaptive and optimization capabilities;

[0094] The self-assessment unit evaluates the quality of the generated code according to the following criteria:

[0095] Functional integrity, including whether the functions fully meet user needs; performance compliance, including code execution efficiency and resource consumption; maintainability, including the clarity and scalability of the code structure; security, including vulnerabilities or potential security risks in the code;

[0096] The self-assessment unit automatically generates code optimization strategies based on the results of self-diagnosis. The optimization strategies include:

[0097] Improve algorithms or data structures to improve code performance; refactor code to improve maintainability and readability; automatically fix errors or vulnerabilities in code to improve software stability and security;

[0098] The self-correction unit automatically generates a correction plan based on the following information:

[0099] Execution logs and operation data during the development process; real-time feedback or evaluation from users; detection results of errors, warnings, or performance bottlenecks in the system;

[0100] The Self-Awareness Module works in conjunction with the Requirements Analysis Module to optimize the requirements analysis process by:

[0101] Automatically extract implicit needs and infer needs that users may have missed by learning from historical data; dynamically adjust the demand model according to the needs input by users, and optimize the demand analysis strategy based on historical feedback;

[0102] The self-awareness module works in conjunction with the automatic code generation module to optimize the code generation process by:

[0103] When generating code, monitor the quality of the generated code in real time and adjust the code generation strategy based on the evaluation results;

[0104] Automatically select appropriate algorithms, data structures or templates to optimize the execution efficiency and quality of generated code;

[0105] The self-awareness module works in conjunction with the intelligent feedback optimization module, which is used to perform real-time evaluation of the execution results of the generated code, including but not limited to:

[0106] Whether the function meets the user's needs; the execution performance of the code, such as response time and memory consumption; user feedback, including bug reports and performance evaluations;

[0107] The self-correction and optimization process of the self-awareness module is a closed-loop process, which includes:

[0108] After the code is generated, evaluation data is collected through automated testing and user feedback; the evaluation results are fed back to the self-awareness module for self-correction and optimization; the optimized code is tested and evaluated by users again to form new feedback and enter the next round of optimization.

[0109] Module S3: an automatic code generation module, used to automatically generate source code according to the user demand model; the code generation module includes a program template matching unit and a deep learning code generation unit;

[0110] The program template matching unit selects and matches appropriate program templates based on development requirements and automatically generates code;

[0111] A deep learning code generation unit generates code through a trained deep neural network model based on user demand data and previous development data;

[0112] The automatic code generation module uses one or a combination of the following techniques:

[0113] Program synthesis technology, which analyzes user requirements and selects corresponding program templates or frameworks to automatically synthesize source code that meets the requirements. The technology can generate efficient and easy-to-maintain code;

[0114] Code generation based on generative adversarial networks (GANs) generates program code based on the input requirement description by training the generative adversarial network model;

[0115] Graph Neural Network (GNN) generates code, which processes the requirement data and code structure diagram through the graph neural network to automatically generate code consistent with the requirements.

[0116] Module S4: an intelligent feedback optimization module, which is used to monitor the execution effect of the automatically generated code in real time, and automatically optimize the logic, structure and performance of the generated code according to the feedback information; the intelligent feedback optimization module includes an execution result evaluation unit and an optimization strategy generation unit;

[0117] An execution result evaluation unit is used to monitor and evaluate the actual running results of the generated code and compare the differences with the predetermined goals;

[0118] The optimization strategy generation unit adjusts the algorithm, data structure or optimization strategy of the generated code according to the evaluation results, generates a new code version and automatically updates the system.

[0119] The intelligent feedback optimization module includes:

[0120] The intelligent feedback optimization module optimizes the generated code according to the real-time evaluation results, and the optimization includes but is not limited to:

[0121] Adjust generated code based on performance bottlenecks; optimize code structure based on user feedback; automatically fix problems in the code based on bug fix suggestions;

[0122] Anomaly detection unit, used to detect possible anomalies in the generated code, including runtime errors, logical errors, or code that does not meet performance requirements;

[0123] Adaptive optimization unit, which automatically adjusts the development process or optimization strategy based on detected anomalies or performance bottlenecks, including algorithm improvement and parallel processing;

[0124] The reinforcement learning optimization mechanism uses reinforcement learning algorithms to automatically adjust the code generation strategy based on the system's historical feedback and optimization results, thereby achieving more efficient development.

[0125] Embodiment 2, a software development method based on artificial intelligence technology, comprising:

[0126] In traditional software development methods, although process-oriented, object-oriented, and component-oriented technologies have achieved remarkable success in certain scenarios, an important problem they face is that these methods lack sufficient adaptability when faced with complex and dynamically changing intelligent behaviors. Process-oriented technology focuses on the description of system functions, object-oriented technology improves the modularity of the system through object abstraction, and component technology further promotes the reusability and encapsulation of the system. However, in actual software development, the intelligent behavior of software does not rely entirely on static code and data structures, but more on dynamic self-learning and adaptation processes.

[0127] Key Characteristics of Self-Awareness:

[0128] Self-awareness: the software is aware of its own state and can respond to its environment.

[0129] Dynamic learning: the software is able to self-learn and adjust based on historical experience, constantly updating its knowledge base.

[0130] Human-computer collaboration, software and developers collaborate through a human-computer integration mechanism to give full play to human creativity and computer automation.

[0131] The method framework includes the following parts:

[0132] Based on the self-aware modeling language, it uses graphical and semi-formal methods to model the knowledge and behavior in the software, and supports visual modeling and analysis of the software.

[0133] The software development process covers the traditional software development life cycle, including requirements analysis, design, and coding, but adds self-awareness-based analysis methods on this basis.

[0134] The self-awareness-based software development method regards the structure of the software as a dynamic, self-perceiving and self-adjusting system, which includes core parts such as beliefs, abilities, desires, planning and execution. The design goal of this structure is to simulate the cognitive process of human intelligence and enable the software to make adaptive adjustments based on external input and internal knowledge.

[0135] The components of the software include:

[0136] Beliefs describe the software's understanding of the real world, including data, entities and their relationships. These beliefs are dynamic and are constantly updated as the software interacts with the external environment and learns by itself.

[0137] Capability refers to the specific functions or operations that the software can perform. Each capability consists of a set of executable action functions, which can be executed independently or combined to achieve more complex functions.

[0138] Desire is the goal or expected state of software, similar to human needs. Software desires can be divided into long-term desires and short-term desires. Short-term desires have a certain degree of certainty, while long-term desires are more vague.

[0139] Planning (Plan), according to the software's wishes, carries out specific functional design and program generation. Planning is the prediction and design of software behavior, the purpose is to ensure that the software can achieve its goals in a dynamic environment.

[0140] Execution is the process by which the software actually executes the program to ensure that the planned design can be implemented.

[0141] Perception is the process by which software perceives its own state and changes in the external environment in order to obtain feedback and adjust software behavior.

[0142] Understanding: analyzing and processing the perceived information to form software requirements or goals and help the software make corresponding decisions.

[0143] The specific implementation is as follows:

[0144] Receive demand data input by users, analyze and abstract user needs through natural language processing and machine learning technology, and generate a structured demand model;

[0145] Demand data analysis includes:

[0146] Semantic understanding of requirements: using natural language processing technology to convert users’ natural language requirements into structured data that can be understood by machines;

[0147] Functional requirement extraction: extract the functional modules and specific requirements that the system must implement through requirement analysis technology;

[0148] Performance requirements analysis: analyzing users’ specific requirements for system performance, including response time and processing power, and incorporating them into development tasks;

[0149] Interface requirements analysis, identifying user requirements for the system interface, including interface layout and user interaction methods.

[0150] Automatically generate source code, using an automatic code generation module to generate source code that meets the requirements according to the requirement model;

[0151] Evaluate the execution effect of the generated code in real time. Use the intelligent feedback optimization module to evaluate the actual effect of the generated code, including the completeness of the function and the compliance of the performance.

[0152] Perform self-correction and optimization based on the evaluation results, and automatically adjust the development strategy, optimize code logic, and improve code quality through the self-correction module;

[0153] Self-correction and optimization include:

[0154] Automatically identify code defects, using automated tools or machine learning algorithms to identify defects in the code, including syntax errors, logic errors, and performance issues;

[0155] Generate repair strategies based on defects, generate repair solutions through self-correction modules, and automatically repair source code;

[0156] Self-optimization: By learning feedback data from historical development processes, it automatically adjusts development strategies and code generation methods to improve the quality and efficiency of subsequent code generation.

[0157] The optimized code is returned to the user and further optimized based on user feedback.

[0158] The intelligent feedback optimization process includes:

[0159] User feedback analysis: evaluate the actual performance of the system based on user feedback and determine its compliance with requirements;

[0160] Automatically generate optimization solutions. Automatically generate code optimization solutions through intelligent algorithms, and return the optimized code to the user to form a closed loop.

[0161] Example 3: Automated code generation and optimization based on user needs during actual implementation includes:

[0162] User demand input and analysis: Users input software requirements through a natural language interface, for example: "Create an e-commerce website that supports user registration and login functions, with a response time of no more than 2 seconds and a simple and intuitive interface."

[0163] The system first performs natural language processing (NLP) through the user demand analysis module to convert user needs into structured data that can be understood by machines.

[0164] The natural language processing unit identifies elements such as functional requirements (such as user registration and login functions), performance requirements (such as response time ≤ 2 seconds), and interface requirements (simple and intuitive).

[0165] The requirement analysis unit converts these requirements into specific structured data models, including functional requirements (such as user authentication module), performance requirements (such as response time requirements), interface design requirements, etc.

[0166] Demand priority assessment,After demand analysis, the demand priority analysis unit prioritizes,demands according to preset rules and historical data.

[0167] For example, user login functionality and response time requirements are given higher priority, while secondary requirements such as interface style and layout are ranked lower.

[0168] This priority information will help the subsequent code generation module to reasonably arrange the execution order of development tasks.

[0169] Code generation,Based on the structured requirement model, the automatic code generation module,automatically generates code.

[0170] The program template matching unit first selects a suitable program template according to the demand model, for example, selects an existing e-commerce website user authentication module template.

[0171] The deep learning code generation unit combines historical development data and further automatically generates codes for specific functions through the trained neural network model. For example, it generates codes for user registration and login functions, including the front-end interface and back-end verification logic.

[0172] Real-time execution effect evaluation, after the generated code is completed, the intelligent feedback optimization module begins to evaluate the execution effect of the code in real time.

[0173] The execution result evaluation unit performs automated testing on the generated code, simulates user operations, and evaluates the system's response time, functional integrity, performance bottlenecks, etc.

[0174] The evaluation results show that although the system's response time meets the requirements, performance bottlenecks may occur under high concurrency conditions.

[0175] Self-correction and optimization,Based on the test feedback, the self-awareness module identifies,performance bottlenecks through the self-assessment unit.

[0176] The self-diagnosis unit analyzed the results and found that the problem was with database query and server concurrent processing.

[0177] The self-correction unit automatically generates optimization strategies, such as improving database query logic, adding caching mechanisms, optimizing concurrent processing algorithms, and adjusting code logic to improve performance.

[0178] The optimized code was tested again and user feedback was obtained. Ultimately, the system performance was significantly improved, meeting the user's response time requirements.

[0179] Closed-loop optimization, through the above process, the generated code is continuously optimized, forming a closed-loop feedback mechanism. After each code optimization, the system will perform automated testing and make further corrections and optimizations based on user feedback or operating data. Each optimization can effectively improve code quality and development efficiency, ensuring that the system always meets user needs.

[0180] Example 4: Dynamically adjusting the development strategy during actual implementation includes:

[0181] Requirements change and dynamic adjustment: During the development process, users may raise new requirements or modify existing requirements. For example, they may request to add a verification code to the "login function" to prevent machine registration and improve the throughput of the website.

[0182] The system automatically identifies changes in requirements through the self-awareness module and initiates the adjustment process.

[0183] The requirement parsing unit converts new requirements (captcha functionality, increased throughput) into new structured data and integrates them with the original requirements.

[0184] The self-correction unit adaptively adjusts the original code according to the new requirements, automatically generates verification code function modules and optimizes the database and cache strategies related to throughput.

[0185] Code adjustment and performance optimization,After generating new code, the intelligent feedback optimization module,performs real-time testing and evaluation of the new,functions.

[0186] By comparing the performance data before and after optimization, the system found that the newly added verification code function had a slight impact on the response time.

[0187] The system further optimizes the verification logic of the verification code through the self-awareness module, reducing the impact on the response time, while enhancing the throughput of the website to ensure that the overall performance meets the new requirements.

[0188] The process of continuous optimization, code optimization and requirement changes forms a continuous closed loop in the system. After each evaluation through intelligent feedback, the self-awareness module continuously adjusts and corrects the development strategy to ensure that the software always runs in the optimal state.

[0189] It should be understood that those skilled in the art can make improvements or changes based on the above description, and all such improvements and changes should fall within the scope of protection of the appended claims of the present invention. Parts not described in detail in this specification belong to the prior art known to those skilled in the art.

Claims

1. A software development system based on artificial intelligence technology, characterized in that: The system includes the following modules: Module S1: a user demand analysis module, used to receive and process demand data input by a user; the user demand analysis module includes a natural language processing unit, a demand parsing unit and a demand priority analysis unit; A natural language processing unit is used to analyze the user's demand information input through natural language and identify the functions, performance and other constraints in the demand; A requirement parsing unit, used to convert the information parsed by the natural language processing unit into structured data to form a requirement model, wherein the requirement model includes at least descriptions of functional requirements, performance requirements, and user interface requirements; The requirement priority analysis unit is used to evaluate the priority of each requirement and generate the execution order of software development tasks according to the requirement priority; Module S2: Self-awareness module, used to simulate the structure of human intelligence, so that the software can perceive its own state, understand environmental changes, and conduct self-learning and adaptive adjustments based on historical experience, perform self-assessment and self-correction, so as to adjust and optimize the software development strategy; the self-awareness module includes a self-assessment unit, a self-diagnosis unit, and a self-correction unit; A self-assessment unit to evaluate the quality of generated code, functional implementation and its consistency with user requirements during the development process; A self-diagnosis unit that automatically identifies potential defects, performance bottlenecks, or logic errors in the code based on the evaluation results; A self-correction unit, which is used to automatically generate correction strategies and adjust the logic or algorithm of the generated code according to the results of self-diagnosis to optimize the development process; Module S3: an automatic code generation module, used to automatically generate source code according to the user demand model; the code generation module includes a program template matching unit and a deep learning code generation unit; The program template matching unit selects and matches appropriate program templates based on development requirements and automatically generates code; A deep learning code generation unit generates code through a trained deep neural network model based on user demand data and previous development data; Module S4: an intelligent feedback optimization module, which is used to monitor the execution effect of the automatically generated code in real time, and automatically optimize the logic, structure and performance of the generated code according to the feedback information; the intelligent feedback optimization module includes an execution result evaluation unit and an optimization strategy generation unit; An execution result evaluation unit is used to monitor and evaluate the actual running results of the generated code and compare the differences with the predetermined goals; The optimization strategy generation unit adjusts the algorithm, data structure or optimization strategy of the generated code according to the evaluation results, generates a new code version and automatically updates the system; The Self-Awareness Module works in conjunction with the Requirements Analysis Module to optimize the requirements analysis process by: Automatically extract implicit needs and infer needs that users may have missed by learning from historical data; dynamically adjust the demand model according to the needs input by users, and optimize the demand analysis strategy based on historical feedback; The self-awareness module works in conjunction with the automatic code generation module to optimize the code generation process by: When generating code, monitor the quality of the generated code in real time and adjust the code generation strategy based on the evaluation results; Automatically select appropriate algorithms, data structures or templates to optimize the execution efficiency and quality of generated code; The self-awareness module works in conjunction with the intelligent feedback optimization module, which is used to perform real-time evaluation of the execution results of the generated code, including but not limited to: Whether the function meets the user's needs; the execution performance of the code, such as response time and memory consumption; User feedback, including bug reports and performance evaluations; The self-correction and optimization process of the self-awareness module is a closed-loop process, which includes: After the code is generated, evaluation data is collected through automated testing and user feedback; the evaluation results are fed back to the self-awareness module for self-correction and optimization; the optimized code is tested and evaluated by users again to form new feedback and enter the next round of optimization.

2. A software development system based on artificial intelligence technology according to claim 1, characterized in that: The user needs analysis module includes: Analyze the user input requirement description through natural language processing technology, and use machine learning algorithms to extract key functional requirements; Functional requirements analysis: identifying and extracting users’ specific requirements for system functions, including data processing capabilities, algorithm requirements, and interface design; Performance requirements analysis: identifying and extracting user requirements for system performance, including response time, throughput, and resource consumption; User interface requirements analysis, extracting interface design requirements from user requirements. Interface design requirements include interface layout, interaction method and style.

3. The software development system based on artificial intelligence technology according to claim 1, characterized in that: The Self-Awareness Module includes: Self-learning mechanism, through reinforcement learning algorithm, adjusts and optimizes development strategy, code generation method and self-correction mechanism according to feedback data in the development process; uses historical development data and real-time feedback to improve the system's adaptive and optimization capabilities; The self-assessment unit evaluates the quality of the generated code according to the following criteria: Functional integrity, including whether the functions fully meet user needs; performance compliance, including code execution efficiency and resource consumption; maintainability, including the clarity and scalability of the code structure; security, including vulnerabilities or potential security risks in the code; The self-assessment unit automatically generates code optimization strategies based on the results of self-diagnosis. The optimization strategies include: Improve algorithms or data structures to improve code performance; refactor code to improve maintainability and readability; automatically fix errors or vulnerabilities in code to improve software stability and security; The self-correction unit automatically generates a correction plan based on the following information: Execution logs and operation data during the development process; real-time feedback or evaluation from users; detection results of errors, warnings, or performance bottlenecks in the system.

4. The software development system based on artificial intelligence technology according to claim 1, characterized in that: The automatic code generation module uses one or a combination of the following techniques: Program synthesis technology, which analyzes user requirements and selects corresponding program templates or frameworks to automatically synthesize source code that meets the requirements. The technology can generate efficient and easy-to-maintain code; Code generation based on generative adversarial networks: Generate program code based on the input requirement description by training the generative adversarial network model; Graph neural network generates code, which processes the requirement data and code structure diagram through the graph neural network to automatically generate code consistent with the requirements.

5. The software development system based on artificial intelligence technology according to claim 1, characterized in that: The intelligent feedback optimization module includes: The intelligent feedback optimization module optimizes the generated code according to the real-time evaluation results, and the optimization includes but is not limited to: Adjust generated code based on performance bottlenecks; optimize code structure based on user feedback; automatically fix problems in the code based on bug fix suggestions; Anomaly detection unit, used to detect possible anomalies in the generated code, including runtime errors, logical errors, or code that does not meet performance requirements; Adaptive optimization unit, which automatically adjusts the development process or optimization strategy based on detected anomalies or performance bottlenecks, including algorithm improvement and parallel processing; The reinforcement learning optimization mechanism uses reinforcement learning algorithms to automatically adjust the code generation strategy based on the system's historical feedback and optimization results, thereby achieving more efficient development.

6. A software development method based on artificial intelligence technology, characterized in that: The method is applied to a software development system based on artificial intelligence technology as described in any one of claims 1 to 5 above, comprising: Receive demand data input by users, analyze and abstract user needs through natural language processing and machine learning technology, and generate a structured demand model; Automatically generate source code, using an automatic code generation module to generate source code that meets the requirements according to the requirement model; Evaluate the execution effect of the generated code in real time. Use the intelligent feedback optimization module to evaluate the actual effect of the generated code, including the completeness of the function and the compliance of the performance. Perform self-correction and optimization based on the evaluation results, and automatically adjust the development strategy, optimize code logic, and improve code quality through the self-correction module; The optimized code is returned to the user and further optimized based on user feedback.

7. The software development method based on artificial intelligence technology according to claim 6, characterized in that: Demand data analysis includes: Semantic understanding of requirements: using natural language processing technology to convert users’ natural language requirements into structured data that can be understood by machines; Functional requirement extraction: extract the functional modules and specific requirements that the system must implement through requirement analysis technology; Performance requirements analysis: analyzing users’ specific requirements for system performance, including response time and processing power, and incorporating them into development tasks; Interface requirements analysis, identifying user requirements for the system interface, including interface layout and user interaction methods.

8. The software development method based on artificial intelligence technology according to claim 6, characterized in that: Self-correction and optimization include: Automatically identify code defects, using automated tools or machine learning algorithms to identify defects in the code, including syntax errors, logic errors, and performance issues; Generate repair strategies based on defects, generate repair solutions through self-correction modules, and automatically repair source code; Self-optimization: By learning feedback data from historical development processes, it automatically adjusts development strategies and code generation methods to improve the quality and efficiency of subsequent code generation.

9. The software development method based on artificial intelligence technology according to claim 6, characterized in that: The intelligent feedback optimization process includes: User feedback analysis: evaluate the actual performance of the system based on user feedback and determine its compliance with requirements; Automatically generate optimization solutions. Automatically generate code optimization solutions through intelligent algorithms, and return the optimized code to the user to form a closed loop.

Images