Intelligent system development method and device based on large model

Abstract

The invention provides an intelligent system development method and device based on a large model. Receiving an original demand input by a user, and carrying out demand clarification and improvement through a multi-round dialogue reinforcement learning mechanism; synchronously generating a user story, an application architecture model, an executable code and a test case based on the improved original demand; constructing a three-dimensional task scheduling model and dynamic optimization of a retrograde development plan according to the generated development elements; running static risk mode detection and dynamic progress risk prediction in parallel in a development full cycle; and when the project is finished, automatically executing a knowledge distillation process, and carrying out vectorization storage and model iteration of development experience. According to the embodiment of the invention, the intelligent level of software development is improved, and the development efficiency is improved, the quality risk is controllable and the knowledge is continuously evolved by establishing the full-link digital twinning of demand-design-development-test-operation and maintenance.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a large model-based intelligent system development method and device. Background Art

[0002] Under the traditional software development paradigm, systemic flaws exist in multiple key areas, including distorted demand transmission, fragmented development processes, lagging risk management, and loss of knowledge assets. Currently, research has attempted to introduce artificial intelligence (AI) into the development field, but due to the limitations of early technologies, existing solutions suffer from three common flaws: Rule-based engines or shallow NLP-based approaches struggle to parse complex business contexts; single-point intelligent tools lack a unified knowledge representation and transfer mechanism; and poor interpretability of predictive models leads to insufficient trust in human-machine collaboration.

[0003] The breakthrough progress of large-scale pre-trained models (LLM) in recent years has provided a new technical path to the above problems. However, there is still a significant technical gap in how to build an LLM application architecture that adapts to the complex characteristics of software development and realizes intelligent collaboration throughout the entire life cycle. Summary of the Invention

[0004] The embodiments of the present invention provide a large-model-based intelligent system development method and device. To address the systemic defects of the traditional development model, such as distorted demand transmission, inefficient process collaboration, lagging risk control, and difficulty in knowledge reuse, a five-dimensional collaborative intelligent development architecture is proposed, thereby improving the intelligence level of software development.

[0005] According to one aspect of the present invention, a method for developing an intelligent system based on a large model is provided, comprising:

[0006] Receive original user input and clarify and improve the requirements through multi-round dialogue reinforcement learning mechanism;

[0007] Based on the improved original requirements, user stories, application architecture models, executable codes and test cases are generated simultaneously;

[0008] Construct a three-dimensional task scheduling model based on the generated development elements and dynamically optimize the retrograde development plan;

[0009] Run static risk pattern detection and dynamic progress risk prediction in parallel throughout the development cycle;

[0010] At the end of the project, the knowledge distillation process is automatically executed to perform vectorized storage of development experience and model iteration.

[0011] Optionally, the requirements clarification and improvement through a multi-round dialogue reinforcement learning mechanism may include:

[0012] Locate demand ambiguity points through at least three rounds of dialogue path decision trees, where:

[0013] The first round of dialogue extracts the core elements of the requirements, including the action subject, business objectives, and constraints;

[0014] The second round of dialogue identifies the set of fuzzy points in the requirement description based on dependency syntax analysis;

[0015] The dialogue after the second round of dialogue uses reinforcement learning strategy to dynamically generate follow-up questions until the requirement completeness coverage reaches the preset threshold.

[0016] Optionally, the method further includes:

[0017] Construct a three-dimensional demand knowledge graph, which includes: the user story map node association relationship in the functional dimension, which is used to describe the hierarchy and dependencies of the user's original demand; the demand and business process mapping matrix in the business dimension, which is used to mark the business links and execution logic corresponding to the original demand; the architecture model and technology selection association rules in the technical dimension, which are used to match the technical implementation plan corresponding to the original demand.

[0018] Optionally, based on the improved original requirements, user stories, application architecture models, executable codes, and test cases are generated simultaneously, including:

[0019] Based on the INVEST principle verifier, the generated user stories are atomically verified and a standardized template of role-function-value triples is output;

[0020] Automatically generate a 4+1 architecture document including logical view, deployment view, and process view through the domain-specific language DSL conversion engine;

[0021] Maintain a context-aware code synthesis environment, implement code completion based on 500token context window memory, and integrate SonarQube rule sets for instant compliance checking;

[0022] Analyze boundary conditions based on the control flow graph CFG and generate a path coverage test set in combination with the combination test algorithm.

[0023] Optionally, constructing a three-dimensional task scheduling model based on the generated development elements includes:

[0024] Constructing the complexity evaluation module, which calculates the code entropy value based on the Halstead complexity index and performs regression calibration through historical similar task working time data;

[0025] Construct a dependency mining module that uses a graph neural network (GNN) to construct a task topology graph and identify implicit dependencies and critical paths in the demand graph.

[0026] A resource optimization module is constructed, which uses genetic algorithms to encode and optimize personnel skill matrices, task priorities, and equipment resources, and dynamically adjusts critical path resource allocation in combination with Monte Carlo simulation.

[0027] Optionally, the static risk pattern detection includes:

[0028] Built-in quantitative analysis model covering 21 risk patterns, including security vulnerabilities, architecture smells, and code smells;

[0029] Perform pattern matching on code and architectural design, assign weighted scores based on risk frequency and severity, and generate static risk assessment reports;

[0030] The dynamic progress risk prediction includes:

[0031] A two-layer LSTM network is used to build a progress prediction model, with input features including task complexity, personnel load factor, and historical delay rate;

[0032] The DS evidence theory is applied to integrate the static risk detection results and the dynamic progress prediction results to generate a three-dimensional risk radar chart including technical risk, progress risk and resource risk.

[0033] Optionally, the knowledge distillation process includes:

[0034] Extract key decision points from code submission records and meeting minutes to build a Bayesian causal reasoning network for technology selection, quality indicators, and project outcomes.

[0035] Encode the solution into a 128-dimensional feature vector, store it in the knowledge graph, and establish the relationship between problem model, solution, and effect indicator;

[0036] The large-scale pre-trained model is incrementally iterated through the parameter efficient fine-tuning PEFT technology, and the user correction behavior is combined as the reward signal optimization generation strategy.

[0037] According to another aspect of the present invention, there is provided an intelligent system development device based on a large model, comprising:

[0038] The receiving unit is used to receive the original requirements input by the user and clarify and improve the requirements through a multi-round dialogue reinforcement learning mechanism;

[0039] A generation unit, configured to simultaneously generate user stories, application architecture models, executable codes, and test cases based on the improved original requirements;

[0040] As constructed, it is used to build a three-dimensional task scheduling model based on the generated development factors and dynamically optimize the retrograde development plan;

[0041] Detection unit, used to run static risk pattern detection and dynamic progress risk prediction in parallel throughout the development cycle;

[0042] The execution unit is used to automatically execute the knowledge distillation process at the end of the project, perform vectorized storage of development experience, and iterate the model.

[0043] According to another aspect of the present invention, an electronic device is provided, comprising:

[0044] At least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores a computer program executable by the at least one processor, and the computer program is executed by the at least one processor so that the at least one processor can execute the large model-based intelligent system development method described in any embodiment of the present invention.

[0045] According to another aspect of the present invention, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores computer instructions, and the computer instructions are used to enable a processor to implement the large model-based intelligent system development method described in any embodiment of the present invention when executed.

[0046] The embodiments of the present invention provide an improvement in the intelligence level of software development. By establishing a full-link digital twin of requirements-design-development-testing-operation and maintenance, it achieves a triple breakthrough in improved development efficiency, controllable quality risks, and continuous evolution of knowledge.

[0047] It should be understood that the content described in this section is not intended to identify the key or important features of the embodiments of the present invention, nor is it intended to limit the scope of the present invention. Other features of the present invention will become readily understood through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0049] Figure 1 This is a flow chart of a method for developing an intelligent system based on a large model provided by one embodiment of the present invention;

[0050] Figure 2This is a schematic structural diagram of an intelligent system development device based on a large model provided by one embodiment of the present invention;

[0051] Figure 3 It is a structural diagram of an electronic device for implementing the large model-based intelligent system development method according to an embodiment of the present invention. DETAILED DESCRIPTION

[0052] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0053] It should be noted that the terms "first", "second", etc. in the description and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that the numbers used in this way can be interchanged where appropriate, so that the embodiments of the present invention described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions. For example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0054] like Figure 1 As shown, an embodiment of the present invention provides an intelligent system development method based on a large model, which may include the following steps:

[0055] S110: Receive the original requirements input by the user and clarify and improve the requirements through a multi-round dialogue reinforcement learning mechanism.

[0056] Original requirements can be vague, incomplete, or ambiguous, as users may not be able to accurately and clearly express all the details at once. For example, a user might simply describe their desire to develop an e-commerce platform, but without specifying the platform's specific functionality, user interface style, performance requirements, and so on. To clarify and refine these requirements, a multi-round dialogue reinforcement learning mechanism is used. In each round of dialogue, targeted questions are asked based on the user's previous responses and the system's own learning mechanisms, guiding the user to gradually clarify their requirements. Reinforcement learning continuously adjusts questioning strategies based on user feedback to improve the efficiency of obtaining accurate requirements. After multiple rounds of such interactions, the requirements are ultimately made clearer and more complete. Original requirements support multimodal input, such as natural language text, voice dialogue, and flowcharts. Domain adapters are also set up: through lightweight fine-tuning, the basic LLM is adapted to the terminology of vertical fields such as finance and healthcare.

[0057] S120. Based on the improved original requirements, user stories, application architecture models, executable codes and test cases are generated simultaneously.

[0058] User stories are a way to describe system functionality from the user's perspective, emphasizing the value the system brings to the user. For example, "As a customer, I hope to be able to easily search for the products I want on the e-commerce platform."

[0059] The application architecture model describes the overall structure of a system and the relationships between its components. It includes aspects such as the system's layered structure, module division, and data flow. Based on comprehensive requirements, the system can design a suitable application architecture model. For example, a microservices architecture can be adopted, splitting the e-commerce platform into multiple microservices, such as product management, order management, and user management, with each microservice responsible for a specific function.

[0060] Executable code is runnable code that is automatically generated by the system based on requirements and architectural models. This can greatly improve development efficiency and reduce errors that may occur when manually writing code.

[0061] To ensure that the generated code correctly implements the requirements, the system also generates test cases. A test case is a set of input data and expected output results used to verify the correctness of the code. For example, for the product search function, a test case might include entering different keywords and checking whether the relevant product list is correctly returned.

[0062] S130. Construct a three-dimensional task scheduling model based on the generated development factors and dynamically optimize the retrograde development plan.

[0063] The three-dimensional task scheduling model considers task scheduling from three perspectives: task complexity, inter-task dependencies, and available resources. Complexity reflects the workload and difficulty required to complete a task; dependencies describe the order in which tasks occur, such as requiring database design to be completed before data entry can be developed; and resources relate to aspects such as manpower and equipment. By comprehensively considering these three dimensions, the system can develop a reasonable task scheduling plan.

[0064] During the development process, actual conditions may change, such as inaccurate estimates of task complexity or resource shortages. Therefore, the system dynamically adjusts the development plan based on actual progress. For example, if a task proves to be more complex than expected, causing a delay, the system will reassess the schedule of other tasks and may adjust the order of tasks or increase resource input to ensure the entire project is completed on time.

[0065] S140. Run static risk pattern detection and dynamic progress risk prediction in parallel throughout the entire development cycle.

[0066] Throughout the development process, the system continuously performs static analysis on code and design documents to detect known risk patterns. For example, it detects security vulnerabilities (such as SQL injection and cross-site scripting) in the code and architectural design irregularities (such as circular dependencies and high coupling). Once a risk is detected, the system promptly issues an alert, prompting developers to address it.

[0067] In addition to static risk detection, the system also provides dynamic project progress forecasts. It predicts whether a project can be completed on time based on factors such as actual task completion and resource usage. If a risk of delay is detected, the system will take proactive measures, such as adjusting task schedules and adding resources, to mitigate the impact of the risk.

[0068] S150. Automatically execute the knowledge distillation process at the end of the project to perform vectorized storage of development experience and model iteration.

[0069] When the project is completed, the system will automatically summarize and refine the experience and knowledge of the entire development process, including the methods of demand analysis, ideas for architecture design, problems encountered and solutions, etc., and convert them into a storable and reusable form through knowledge distillation.

[0070] Extracted knowledge is vectorized for easy storage and retrieval. Vectorization converts knowledge into numerical vectors that computers can process. For example, different requirements analysis methods can be represented by a vector, with each dimension representing a characteristic of the method. In subsequent projects, relevant empirical knowledge can be quickly found through methods such as vector similarity calculation.

[0071] This stored empirical knowledge is fed back into the system's model to update and optimize it. For example, during subsequent requirements clarification, the system can draw on experience from previous projects to more accurately ask questions, improving the efficiency and quality of requirements elicitation. Through continuous project accumulation and model iteration, the system's performance will continue to improve.

[0072] The embodiments of the present invention significantly improve the intelligence level of software development. By establishing a full-link digital twin of requirements-design-development-testing-operation and maintenance, it achieves a triple breakthrough in improved development efficiency, controllable quality risks, and continuous evolution of knowledge.

[0073] In an embodiment of the present invention, requirements clarification and improvement are performed through a multi-round dialogue reinforcement learning mechanism, including:

[0074] Locate demand ambiguity points through at least three rounds of dialogue path decision trees, where:

[0075] The first round of dialogue extracts the core elements of the requirements, including the action subject, business objectives, and constraints;

[0076] The second round of dialogue identifies the set of fuzzy points in the requirement description based on dependency syntax analysis;

[0077] The dialogue after the second round of dialogue uses reinforcement learning strategies to dynamically generate follow-up questions until the requirement completeness coverage reaches the preset threshold.

[0078] First round of dialogue: Extract the core elements of the requirements, including:

[0079] Action subject: refers to the object that performs the action described in the requirement. For example, in the sentence "Users can query order information in the system", "User" is the action subject.

[0080] Business goal: Clarify the business outcomes that the requirements are intended to achieve. In the example above, the business goal is to enable users to query order information, which helps the system clarify its core functions.

[0081] Constraints: Restrictions on the implementation process or results of requirements, such as system response time requirements, data accuracy requirements, budget limitations, etc. When developing an online payment system, there may be constraints such as the transaction success rate must reach more than 99%.

[0082] The first round of dialogue involves a preliminary, structured analysis of the needs, extracting key information and providing a framework for subsequent analysis and follow-up questions. By clarifying these core elements, the system can gain a holistic understanding of the needs and determine their general direction and focus.

[0083] Second round of dialogue: Identifying fuzzy point sets based on dependency parsing:

[0084] Dependency parsing is a natural language processing technique that understands the grammatical structure and semantics of sentences by analyzing the dependencies between words. For example, in the sentence "Improve system performance to support more user access," dependency parsing can reveal the subject-object relationship between "improve" and "system performance," as well as the logical relationship between "support" and "user access."

[0085] Based on the results of dependency parsing, the system can identify areas of the requirements description where semantics are unclear and ambiguous. In the example above, it's unclear what aspects of "system performance" (such as response time and throughput) refer to, and the specific number or scale of "more users" is unclear, identifying these ambiguous areas.

[0086] The second round of dialogue can systematically identify potential areas of ambiguity in the requirements and clarify parts of the requirements where there may be misunderstandings.

[0087] Conversation after the second round of dialogue: Apply reinforcement learning strategy to dynamically generate follow-up questions:

[0088] Reinforcement learning is a machine learning method in which a system interacts with its environment (conversations with users) and receives rewards or penalties based on the results of those interactions (user responses), thereby continuously adjusting its behavioral strategies. In this scenario, the system dynamically generates follow-up questions most likely to clarify a request based on the results of the first two rounds of conversation and real-time user feedback.

[0089] Based on the previously identified set of ambiguities and the user's responses to previous follow-up questions, the system continuously adjusts the angle and content of follow-up questions. For example, if the user's explanation of "system performance" is vague, the system might further ask, "Does system performance refer to response time, throughput, or other aspects?" Through continuous follow-up questions and user feedback, the scope of the ambiguity is gradually narrowed.

[0090] Requirements completeness coverage is a measure of the degree of requirement completion, typically calculated as the ratio of defined requirements to the total number of requirements. A preset threshold is a standard set based on actual project requirements and experience. When the requirements completeness coverage reaches this threshold, the requirements are considered sufficiently clear and complete to proceed to the subsequent development or implementation phase.

[0091] Reinforcement learning strategies enable the system to flexibly adjust follow-up strategies based on actual circumstances, effectively clarifying requirements and avoiding blind follow-up questions, thereby improving the efficiency and accuracy of requirement clarification. Through this multi-round dialogue reinforcement learning mechanism, from extracting core elements to identifying ambiguities and then dynamically following up to refine the process, it can gradually delve deeper into user needs and eliminate ambiguity and ambiguity in the requirements.

[0092] In an embodiment of the present invention, the method may further include the following steps:

[0093] Construct a three-dimensional demand knowledge graph, which includes: the user story map node association relationship in the functional dimension, which is used to describe the hierarchy and dependency of the user's original needs; the demand and business process mapping matrix in the business dimension, which is used to mark the business links and execution logic corresponding to the original needs; the architectural model and technology selection association rules in the technical dimension, which are used to match the technical implementation plan corresponding to the original needs.

[0094] A user story is a way to describe system functionality from a user's perspective, typically using the format "As [user role], I want to [complete a certain function] in order to [achieve a certain value]." A user story map organizes and arranges user stories according to a certain logic and hierarchical relationship, forming a visual diagram.

[0095] In a user story map, each user story can be viewed as a node, and various relationships exist between nodes, such as parent-child relationships, sequential relationships, and dependency relationships. For example, in an e-commerce system, the user story "User Login" may be a prerequisite for the user story "User Order," creating a dependency relationship between them. Meanwhile, "Product Display" may include sub-functions such as "Display Products by Category" and "Display Products by Search Results," creating a parent-child relationship between these sub-functions and "Product Display."

[0096] By building the node association relationship of the user story map in the functional dimension, the hierarchical structure and dependency relationship of the original requirements can be clearly described, helping the development team understand the relationship between the overall architecture of the requirements and the functional modules, so as to better carry out functional planning, task allocation and development progress management.

[0097] A business process is the sequence of activities and operations that a business or organization performs to achieve a specific business objective. The requirements-to-business process mapping matrix maps and labels original requirements with the corresponding business process steps, clarifying the position and role of each requirement within the business process.

[0098] In the mapping matrix, not only should the business steps corresponding to the requirements be marked, but the execution logic of these business steps should also be explained, that is, how each step collaborates and flows with each other. For example, in an order processing system, the "order creation" requirement corresponds to the "customer order placement" step in the business process. The execution logic may be that the customer fills in the order information in the system, and the system verifies the information and generates an order number.

[0099] The business dimension mapping matrix can help development teams understand the business logic and business rules behind requirements, ensuring that the developed system aligns with actual business processes, improving system practicality and operability. It also facilitates communication and collaboration between business personnel and developers, reducing development errors caused by misunderstandings.

[0100] Architectural patterns refer to the overall structure and design approach of a software system, such as layered architecture and microservices architecture. Technology selection refers to the specific technologies and tools chosen to implement system functionality, such as programming languages, database management systems, and development frameworks. The rules for associating architectural patterns with technology selection establish a correspondence and selection rules between architectural patterns and technology selection based on the characteristics and requirements of the original requirements.

[0101] Based on the association rules, the most appropriate technical implementation solution is matched to the original requirement. For example, if the requirement places high demands on system scalability and flexibility, a microservices architecture and corresponding technology stack may be selected; if the requirement places high demands on data processing speed and concurrency, a suitable database management system and caching technology may be selected.

[0102] Association rules in the technical dimension can help development teams analyze and make decisions about technical requirements, select the most appropriate architecture and technology, and ensure good system performance, maintainability, and scalability. They also provide clear guidance for subsequent technical development and system integration.

[0103] The three-dimensional demand knowledge graph helps improve the clarity and accuracy of requirements by analyzing and associating original requirements from the three dimensions of function, business and technology, promotes communication and collaboration among team members, reduces development risks and increases the success rate of projects.

[0104] In an embodiment of the present invention, based on the improved original requirements, user stories, application architecture models, executable codes and test cases are generated simultaneously, including:

[0105] Based on the INVEST principle verifier, the generated user stories are atomically verified and a standardized template of role-function-value triples is output;

[0106] Automatically generate a 4+1 architecture document including logical view, deployment view, and process view through the domain-specific language DSL conversion engine;

[0107] Maintain a context-aware code synthesis environment, implement code completion based on 500token context window memory, and integrate SonarQube rule sets for instant compliance checking;

[0108] Analyze boundary conditions based on the control flow graph CFG and generate a path coverage test set in combination with the combination test algorithm.

[0109] The INVEST principle is a set of criteria used to evaluate the quality of user stories. These criteria stand for Independent, Negotiable, Valuable, Estimable, Small, and Testable. Atomicity means that a user story should be a minimal, indivisible unit of functionality. Use the INVEST principle validator to check generated user stories to ensure they meet these criteria, avoiding overly complex stories or those that include multiple, unrelated features.

[0110] The output user stories follow a standardized template of a persona-feature-value triple. For example, "As a customer (persona), I want to be able to modify the quantity of items in my shopping cart (feature) for more flexible order management (value)." This template clearly defines the elements of a user story, helping the development team understand user needs and facilitating subsequent communication and management.

[0111] A domain-specific language (DSL) is a programming language or notation designed specifically for a specific domain, capable of more accurately expressing the concepts and rules of that domain. The DSL conversion engine is responsible for converting refined requirements into the format required for architectural design.

[0112] The 4+1 architecture model consists of a logical view, a development view, a process view, a physical view, and a scenario view. The logical view primarily describes the functional requirements of the system, presenting the system's functional modules and the relationships between them, similar to a functional architecture diagram. The deployment view focuses on the system's deployment on physical hardware, including servers, network devices, and how software components are distributed across this hardware. The process view describes the system's runtime process and thread structure, showcasing the system's concurrency and synchronization mechanisms. The DSL conversion engine automatically generates a 4+1 architecture document containing these views based on requirements, providing a clear blueprint for system architectural design.

[0113] Context-aware means that the code synthesis environment can understand the context of the current code, such as variable definitions and function call relationships. It also uses a 500-token context window memory, which remembers the information of the most recent 500 tokens, to achieve smarter code completion.

[0114] SonarQube is an open-source code quality management platform that provides a series of rule sets for checking code quality, security, maintainability, and other aspects. During the code synthesis process, the SonarQube rule set is integrated to perform immediate compliance checks on the generated code. If any violations of the rules are found, prompts will be given in a timely manner to help developers ensure code quality.

[0115] A control flow graph is a graphical tool for representing a program's control structure. It abstracts the program's execution flow as a graph of nodes and edges. By analyzing a control flow graph, you can identify various boundary conditions within the program, such as the start and end conditions of loops and the different branches of conditional statements.

[0116] Combinatorial testing algorithms are used to generate a set of test cases that covers as many execution paths as possible within a program. Combined with the boundary conditions derived from control flow graph analysis, these algorithms generate a path coverage test set, ensuring that all possible execution scenarios of the system are fully tested, improving system reliability and stability.

[0117] In summary, the above steps, from the generation and verification of user stories, to the automatic generation of architecture documents, to the synthesis and inspection of code, and finally to the generation of test cases, achieve comprehensive and efficient preliminary preparations for software development based on complete requirements.

[0118] In an embodiment of the present invention, a three-dimensional task scheduling model is constructed based on the generated development factors, including:

[0119] Build a complexity assessment module, which calculates the code entropy value based on the Halstead complexity index and performs regression calibration using historical data on the working hours of similar tasks.

[0120] Build a dependency mining module, which uses graph neural network (GNN) to construct task topology graphs and identify implicit dependencies and critical paths in the demand graph.

[0121] Construct a resource optimization module, which uses genetic algorithms to encode and optimize personnel skill matrix, task priority, and equipment resources, and dynamically adjusts critical path resource allocation in combination with Monte Carlo simulation.

[0122] The Halstead complexity index is a method used to measure program complexity, calculated based on the number of operators and operands in the program. Operators include symbols such as +, -, *, and / , while operands are variables or constants involved in the calculation. By counting the number of these elements, indicators such as the length and vocabulary of the program can be calculated, and the entropy value of the code can be obtained. The code entropy value can reflect the complexity of the code. The higher the entropy value, the more complex the code. Therefore, it is necessary to combine the working time data of historical similar tasks for regression calibration. Regression analysis establishes a mathematical model by analyzing the relationship between complexity indicators and actual working hours in historical data. When evaluating new tasks, the working hours required for the task are predicted based on the calculated complexity indicators, making the complexity assessment more in line with actual conditions.

[0123] A graph neural network (GNN) is a type of neural network specifically designed for processing graph-structured data. In software development task scheduling scenarios, each task is considered a node in the graph, and the dependencies between tasks are considered edges between nodes, thereby constructing a task topology graph. For example, in a project, if the "database design" task must be completed before the "data entry function development" task can be carried out, then there is a dependency between the two tasks, and an edge can be used to connect the corresponding nodes.

[0124] There may be some implicit dependencies in the requirements graph, which may not be directly reflected in the requirements document. GNN can mine these implicit dependencies by learning the features of nodes and edges in the graph.

[0125] The critical path is the sequence of interconnected tasks that determines the total duration of a project. By analyzing the task topology diagram and identifying the critical path, you can determine the shortest possible completion time for the project and which tasks, if delayed, will impact the overall project schedule.

[0126] A genetic algorithm is an optimization algorithm that simulates natural selection and heredity. In the resource optimization module, information such as the personnel skill matrix, task priorities, and equipment resources are encoded to form a chromosome.

[0127] The personnel skills matrix records the skills and skill levels of each developer; the task priority indicates the importance of each task in the project; and the equipment resources involve the hardware equipment required for development, etc.

[0128] Genetic algorithms simulate the evolutionary process of organisms, perform operations such as selection, crossover, and mutation on chromosomes, and continuously optimize the quality of solutions to find the optimal resource allocation plan.

[0129] Monte Carlo simulation is a statistical method based on random sampling. In the resource allocation process, due to the existence of various uncertainties, Monte Carlo simulation can be used to simulate the impact of these uncertainties on project progress.

[0130] Through multiple simulations, we can determine the distribution of project completion times under different scenarios. Based on the simulation results, we can dynamically adjust resource allocation along the critical path to ensure that the project can be completed within the stipulated time. For example, if the simulation results indicate that a critical task may be delayed, we can increase the resource investment for that task, such as deploying more developers or equipment.

[0131] The complexity assessment module accurately assesses the complexity of tasks, the dependency mining module finds the dependencies and critical paths between tasks, and the resource optimization module allocates resources reasonably. The three-dimensional task scheduling model can comprehensively consider multiple factors and formulate a more scientific and reasonable task scheduling plan, thereby improving the development efficiency and success rate of the project.

[0132] In an embodiment of the present invention, static risk pattern detection includes:

[0133] Built-in quantitative analysis model covering 21 risk patterns, including security vulnerabilities, architecture smells, and code smells;

[0134] Perform pattern matching on code and architectural design, assign weighted scores based on risk frequency and severity, and generate static risk assessment reports;

[0135] Dynamic schedule risk prediction includes:

[0136] A two-layer LSTM network is used to build a progress prediction model, with input features including task complexity, personnel load factor, and historical delay rate;

[0137] The DS evidence theory is applied to integrate the static risk detection results and the dynamic progress prediction results to generate a three-dimensional risk radar chart including technical risk, progress risk and resource risk.

[0138] The system has a built-in quantitative analysis model that includes 21 risk patterns, including security vulnerabilities, architectural smells, and code smells. Security vulnerabilities refer to defects that may lead to system attacks, data leaks, and other security issues. Architectural smells refer to irregular and unreasonable architectural designs that may affect the maintainability, scalability, and performance of the system. For example, circular dependencies can lead to excessive coupling between modules, and modifying one module may affect multiple related modules. Code smells refer to potential problems in the code that, while not immediately causing errors, can affect the readability and maintainability of the code, such as overly long methods and large amounts of duplicated code.

[0139] When performing risk detection on software projects, the system performs pattern matching on the code and architectural design. It examines each code and architecture individually to see if they conform to known risk patterns. For example, it checks for string concatenation methods that could lead to SQL injection to determine if a security vulnerability exists. A weighted score is assigned based on the frequency and severity of the risk, with risks with high frequency and severity receiving a higher weight in the score. For example, if a SQL injection vulnerability has a high severity rating, even if it is not frequent, once detected, it will have a significant impact on the score. On the other hand, even if less severe code smells occur frequently, their impact on the score will be relatively small. This method allows for a comprehensive assessment of the static risk profile of a project.

[0140] A static risk assessment report is generated based on the weighted scoring results. This report details the types of risks detected, their locations, frequency, severity, and final scores. This report allows development teams to gain a clear understanding of the static risks within their projects, prioritize risk areas, and implement targeted remediation and improvements.

[0141] LSTM networks can effectively handle long-term dependencies in time series data. In dynamic progress risk prediction, a two-layer LSTM network is used to build a progress prediction model.

[0142] The model's input features include task complexity, staff load factor, and historical delay rate. Task complexity reflects the difficulty of completing a task. Complex tasks may take longer to complete and are more likely to cause delays. The staff load factor indicates the workload of developers. Excessive staff load may affect work efficiency and, in turn, project progress. The historical delay rate, based on past project performance, calculates the proportion of task delays and can reflect potential issues and trends during project execution. Using these input features, the LSTM network can learn the relationship between them and project progress, thereby predicting future project progress.

[0143] DS evidence theory is an uncertainty reasoning method used to integrate evidence from multiple sources. In risk prediction, static risk detection results and dynamic progress forecast results are considered as different sources of evidence. This theory uses a specific algorithm to integrate the results of static risk detection and dynamic progress forecasting, taking into account the credibility and uncertainty of different evidence sources. This allows for a more comprehensive and accurate assessment of project risks.

[0144] After integrating the DS evidence theory, the system generates a three-dimensional risk radar chart encompassing technical risk, schedule risk, and resource risk. Technical risk encompasses risks arising from improper technology selection and unresolved technical challenges; schedule risk reflects the risk of project delays; and resource risk involves the risk of insufficient or irrational allocation of human and material resources. The radar chart presents these three risk dimensions in an intuitive graphical format, enabling the project team to clearly understand the degree of risk faced by the project in different areas.

[0145] In this embodiment of the present invention, the knowledge distillation process includes:

[0146] Extract key decision points from code submission records and meeting minutes to build a Bayesian causal reasoning network for technology selection, quality indicators, and project outcomes.

[0147] Encode the solution into a 128-dimensional feature vector, store it in the knowledge graph, and establish the relationship between problem model, solution, and effect indicator;

[0148] The large-scale pre-trained model is incrementally iterated through the parameter efficient fine-tuning PEFT technology, and the user correction behavior is combined as the reward signal optimization generation strategy.

[0149] Code commit records and meeting minutes contain crucial information about the project development process. Code commit records provide insights into the decision-making process behind code modifications and optimizations at different stages. Meeting minutes document key decisions made by the project team, including technical solution selection and problem-solving strategies.

[0150] Bayesian causal inference networks are used to reveal the causal relationships between technology selection, quality indicators, and project outcomes. Technology selection influences quality indicators, which in turn influence project outcomes. By integrating the extracted key decision points into this network, we can clearly see how different technology choices affect quality indicators and, in turn, project outcomes.

[0151] During project implementation, solutions to various problems are generated. Encoding these solutions as 128-dimensional feature vectors is a way to transform complex solutions into something that computers can easily process and store. Using a specific encoding algorithm, the key features of the solution are mapped into a 128-dimensional vector space, with each dimension representing a specific attribute or characteristic of the solution.

[0152] The encoded solution is stored in the knowledge graph, and a relationship is established between problem patterns, solutions, and performance indicators. Problem patterns refer to the types of problems encountered in the project, such as "slow system response" and "data loss." Performance indicators measure the effectiveness of the implemented solution, such as the percentage of performance improvement or the reduction in error rates. This relationship allows for quick retrieval of the corresponding solution and its performance indicators when similar problem patterns are encountered later.

[0153] Large-scale pre-trained models have demonstrated powerful capabilities in many fields, but specific projects and tasks require fine-tuning to meet specific needs. PEFT technology optimizes the model for specific tasks by adjusting a small number of parameters while maintaining the overall structure and most parameters unchanged. This approach not only reduces training time and computing resources, but also avoids overfitting during fine-tuning.

[0154] During model application, user corrections serve as feedback. When the model's results don't meet user expectations, users will make corrections. These corrections are fed back to the model as reward signals, allowing the model to optimize its generation strategy based on this feedback. If the model's requirements analysis results contain errors and the user makes corrections, the model can learn from these changes and adjust its generation logic. This allows it to generate results that better meet user needs when processing similar tasks in the future, continuously improving the model's performance and accuracy.

[0155] The solution of the embodiment of the present invention has the following advantages and improvements:

[0156] 1. Establish a closed-loop intelligent generation system of requirements clarification - architecture design - code generation - test verification;

[0157] 2. Develop adaptive optimization capabilities for dynamic prediction of development progress and resource scheduling;

[0158] 3. Establish a continuous conversion channel from project experience data to model capabilities.

[0159] like Figure 2 As shown, an embodiment of the present invention provides an intelligent system development device based on a large model, the device comprising:

[0160] The receiving unit 210 is used to receive the original requirements input by the user and clarify and improve the requirements through a multi-round dialogue reinforcement learning mechanism;

[0161] A generation unit 220 is used to simultaneously generate user stories, application architecture models, executable codes, and test cases based on the improved original requirements;

[0162] A construction unit 230 is used to construct a three-dimensional task scheduling model based on the generated development factors and dynamically optimize the retrograde development plan;

[0163] Detection unit 240, used to run static risk pattern detection and dynamic progress risk prediction in parallel throughout the development cycle;

[0164] The execution unit 250 is used to automatically execute the knowledge distillation process at the end of the project, and perform vectorized storage and model iteration of development experience.

[0165] It should be understood that the structures illustrated in the embodiments of the present invention do not constitute a specific limitation on the large-scale model-based intelligent system development device. In other embodiments of the present invention, the large-scale model-based intelligent system development device may include more or fewer components than shown, or may combine or separate certain components, or arrange the components differently. The illustrated components may be implemented in hardware, software, or a combination of software and hardware.

[0166] The information interaction, execution process, etc. between the units in the above-mentioned device are based on the same concept as the embodiment of the method of the present invention. For specific contents, please refer to the description in the embodiment of the method of the present invention and will not be repeated here.

[0167] Figure 3 A schematic diagram of the structure of an electronic device 10 that can be used to implement an embodiment of the present invention is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processing, cellular phones, smart phones, wearable devices (such as helmets, glasses, watches, etc.) and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely examples and are not intended to limit the implementation of the present invention described and / or claimed herein.

[0168] like Figure 3As shown, the electronic device 10 includes at least one processor 11 and a memory, such as a read-only memory (ROM) 12, a random access memory (RAM) 13, etc., which is communicatively connected to the at least one processor 11. The memory stores a computer program that can be executed by the at least one processor. The processor 11 can perform various appropriate actions and processes according to the computer program stored in the read-only memory (ROM) 12 or the computer program loaded from the storage unit 18 into the random access memory (RAM) 13. Various programs and data required for the operation of the electronic device 10 can also be stored in the RAM 13. The processor 11, ROM 12, and RAM 13 are connected to each other via a bus 14. An input / output (I / O) interface 15 is also connected to the bus 14.

[0169] Multiple components in the electronic device 10 are connected to the I / O interface 15, including an input unit 16, such as a keyboard, a mouse, etc.; an output unit 17, such as various types of displays, speakers, etc.; a storage unit 18, such as a magnetic disk, an optical disk, etc.; and a communication unit 19, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit 19 allows the electronic device 10 to exchange information / data with other devices via a computer network such as the Internet and / or various telecommunication networks.

[0170] The processor 11 can be any general-purpose and / or specialized processing component with processing and computing capabilities. Some examples of the processor 11 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various specialized artificial intelligence (AI) computing chips, various processors that run machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The processor 11 executes the various methods and processes described above, such as the large model-based intelligent system development method.

[0171] In some embodiments, the large-model-based intelligent system development method can be implemented as a computer program, which is tangibly contained in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program can be loaded and / or installed on electronic device 10 via ROM 12 and / or communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the large-model-based intelligent system development method described above can be performed. Alternatively, in other embodiments, processor 11 can be configured to execute the large-model-based intelligent system development method by any other appropriate means (e.g., by means of firmware).

[0172] Various embodiments of the systems and techniques described herein can be implemented in digital electronic circuit systems, integrated circuit systems, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), system-on-chip systems (SOCs), programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments can include being implemented in one or more computer programs that are executable and / or interpreted on a programmable system that includes at least one programmable processor, which can be a special purpose or general purpose programmable processor that can receive data and instructions from a storage system, at least one input device, and at least one output device, and transmit data and instructions to the storage system, the at least one input device, and the at least one output device.

[0173] Computer programs for implementing the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when the computer program is executed by the processor, the functions / operations specified in the flowcharts and / or block diagrams are implemented. The computer program may be executed entirely on the machine, partially on the machine, as a stand-alone software package, partially on the machine and partially on a remote machine, or entirely on a remote machine or server.

[0174] In the context of the present invention, computer-readable storage media can be tangible media that can contain or store a computer program for use with an instruction execution system, device or equipment or used in combination with an instruction execution system, device or equipment. Computer-readable storage media can include but are not limited to electronic, magnetic, optical, electromagnetic, infrared or semiconductor systems, devices or equipment, or any suitable combination of the foregoing. Alternatively, computer-readable storage media can be machine-readable signal media. More specific examples of machine-readable storage media can include electrical connections based on one or more lines, portable computer disks, hard disks, random access memories (RAM), read-only memories (ROM), erasable programmable read-only memories (EPROM or flash memory), optical fibers, portable compact disk read-only memories (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0175] To provide interaction with a user, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user can provide input to the electronic device. Other types of devices can also be used to provide interaction with the user; for example, the feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including acoustic input, voice input, or tactile input).

[0176] The systems and techniques described herein can be implemented in a computing system that includes back-end components (e.g., as a data server), or a computing system that includes middleware components (e.g., an application server), or a computing system that includes front-end components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and techniques described herein), or a computing system that includes any combination of such back-end components, middleware components, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: a local area network (LAN), a wide area network (WAN), a blockchain network, and the Internet.

[0177] A computing system may include clients and servers. The clients and servers are typically remote from each other and typically interact via a communication network. This client-server relationship arises through computer programs running on the respective computers, creating a client-server relationship. The server may be a cloud server, also known as a cloud computing server or cloud host. This server is a hosting product within the cloud computing service ecosystem that addresses the management difficulties and limited scalability of traditional physical hosting and VPS services.

[0178] It should be understood that the various forms of the processes shown above can be used to reorder, add, or delete steps. For example, the steps described in the present invention can be performed in parallel, sequentially, or in a different order, as long as the desired results of the technical solution of the present invention can be achieved. This is not limited herein.

[0179] The above specific embodiments do not limit the scope of protection of the present invention. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions may be made based on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention are intended to be included within the scope of protection of the present invention.

Claims

1. A method for developing an intelligent system based on a large model, characterized in that: include: Receive original user input and clarify and improve the requirements through multi-round dialogue reinforcement learning mechanism; Based on the improved original requirements, user stories, application architecture models, executable codes and test cases are generated simultaneously; Construct a three-dimensional task scheduling model based on the generated development elements and dynamically optimize the retrograde development plan; Run static risk pattern detection and dynamic progress risk prediction in parallel throughout the development cycle; At the end of the project, the knowledge distillation process is automatically executed to perform vectorized storage of development experience and model iteration.

2. The method according to claim 1, characterized in that The requirements clarification and improvement through multi-round dialogue reinforcement learning mechanism includes: Locate demand ambiguity points through at least three rounds of dialogue path decision trees, where: The first round of dialogue extracts the core elements of the requirements, including the action subject, business objectives, and constraints; The second round of dialogue identifies the set of fuzzy points in the requirement description based on dependency syntax analysis; The dialogue after the second round of dialogue uses reinforcement learning strategy to dynamically generate follow-up questions until the requirement completeness coverage reaches the preset threshold.

3. The method according to claim 2, characterized in that The method further includes: Construct a three-dimensional demand knowledge graph, which includes: the user story map node association relationship in the functional dimension, which is used to describe the hierarchy and dependencies of the user's original demand; the demand and business process mapping matrix in the business dimension, which is used to mark the business links and execution logic corresponding to the original demand; the architecture model and technology selection association rules in the technical dimension, which are used to match the technical implementation plan corresponding to the original demand.

4. The method according to claim 1, wherein Based on the improved original requirements, user stories, application architecture models, executable code and test cases are generated simultaneously, including: Based on the INVEST principle verifier, the generated user stories are atomically verified and a standardized template of role-function-value triples is output; Automatically generate a 4+1 architecture document including logical view, deployment view, and process view through the domain-specific language DSL conversion engine; Maintain a context-aware code synthesis environment, implement code completion based on 500token context window memory, and integrate SonarQube rule sets for instant compliance checking; Analyze boundary conditions based on the control flow graph CFG and generate a path coverage test set in combination with the combination test algorithm.

5. The method according to claim 1, wherein The three-dimensional task scheduling model is constructed based on the generated development elements, including: Constructing the complexity evaluation module, which calculates the code entropy value based on the Halstead complexity index and performs regression calibration through historical similar task working time data; Construct a dependency mining module that uses a graph neural network (GNN) to construct a task topology graph and identify implicit dependencies and critical paths in the demand graph. A resource optimization module is constructed, which uses genetic algorithms to encode and optimize personnel skill matrices, task priorities, and equipment resources, and dynamically adjusts critical path resource allocation in combination with Monte Carlo simulation.

6. The method according to claim 1, characterized in that The static risk pattern detection includes: Built-in quantitative analysis model covering 21 risk patterns, including security vulnerabilities, architecture smells, and code smells; Perform pattern matching on code and architectural design, assign weighted scores based on risk frequency and severity, and generate static risk assessment reports; The dynamic progress risk prediction includes: A two-layer LSTM network is used to build a progress prediction model, with input features including task complexity, personnel load factor, and historical delay rate; The DS evidence theory is applied to integrate the static risk detection results and the dynamic progress prediction results to generate a three-dimensional risk radar chart including technical risk, progress risk and resource risk.

7. The method according to claim 1, characterized in that The knowledge distillation process includes: Extract key decision points from code submission records and meeting minutes to build a Bayesian causal reasoning network for technology selection, quality indicators, and project outcomes. Encode the solution into a 128-dimensional feature vector, store it in the knowledge graph, and establish the relationship between problem model, solution, and effect indicator; The large-scale pre-trained model is incrementally iterated through the parameter efficient fine-tuning PEFT technology, and the user correction behavior is combined as the reward signal optimization generation strategy.

8. An intelligent system development device based on a large model, characterized in that: include: The receiving unit is used to receive the original requirements input by the user and clarify and improve the requirements through a multi-round dialogue reinforcement learning mechanism; A generation unit, configured to simultaneously generate user stories, application architecture models, executable codes, and test cases based on the improved original requirements; As constructed, it is used to build a three-dimensional task scheduling model based on the generated development factors and dynamically optimize the retrograde development plan; Detection unit, used to run static risk pattern detection and dynamic progress risk prediction in parallel throughout the development cycle; The execution unit is used to automatically execute the knowledge distillation process at the end of the project, perform vectorized storage of development experience, and iterate the model.

9. An electronic device, characterized in that include: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores a computer program executable by the at least one processor, and the computer program is executed by the at least one processor so that the at least one processor can execute the large model-based intelligent system development method described in any one of claims 1-7.

10. A computer-readable medium, characterized in that The computer-readable storage medium stores computer instructions, and the computer instructions are used to enable a processor to implement the large model-based intelligent system development method according to any one of claims 1 to 4 when executed.

Images