Software development system based on artificial intelligence

Abstract

The invention relates to the field of software engineering, and discloses an artificial intelligence-based software development system, which comprises the following steps of: acquiring multi-dimensional data such as project milestone, task dependence, team cooperation mode and code change range to establish a workflow data model; calculating a construction request priority based on the multi-dimensional data; an affected identification module for performing fine analysis on code change; dynamically adjusting a resource allocation strategy according to the workflow state; and predicting a development progress trajectory based on historical data to realize predictive construction. According to the method, the technical problems of unreasonable resource allocation and low construction efficiency in a complex software project continuous integration environment are solved, and the construction efficiency and the resource utilization rate in a software development process are improved.

Description

Technical Field

[0001] The present invention relates to the field of software engineering, and more specifically, it relates to a software development system based on artificial intelligence. Background Art

[0002] With the continuous increase in the scale and complexity of software development, continuous integration and continuous deployment (CI / CD) have become an indispensable part of modern software development. In the continuous integration environment of complex software projects, the development team needs to frequently submit code and perform automated builds and tests before the code is merged into the main branch to ensure code quality and functional stability.

[0003] Currently, most continuous integration systems use resource scheduling strategies based on simple rules to handle build requests. These systems usually adopt a first-in, first-out (FIFO) or static priority-based queue management method to queue and process concurrent build requests. At the same time, for the analysis of code changes, the existing technologies mainly rely on coarse-grained tracking at the file level or incremental build methods based on predefined dependency graphs.

[0004] However, in the context of large-scale team collaboration and complex project structures, the existing build scheduling technologies cannot effectively perceive and adapt to the overall progress of the development workflow. Especially when a large number of concurrent build requests flood in simultaneously, the system cannot dynamically adjust the resource allocation strategy based on high-level information such as the team's development rhythm, task criticality, and milestone plan, resulting in delays in critical tasks, low resource utilization efficiency, and ultimately affecting the collaboration efficiency of the entire development team and the product delivery schedule. Summary of the Invention

[0005] The present invention discloses a software development method and system based on artificial intelligence, which solves the technical problems of unreasonable resource allocation and low build efficiency in the continuous integration environment of complex software projects.

[0006] The software development method based on artificial intelligence of the present invention includes the following steps:

[0007] Step 1: Multi-dimensional workflow data collection and modeling;

[0008] Collect multi-dimensional data such as project milestones, task dependencies, team collaboration patterns, code change scope, module importance, committer roles, and historical build performance, and establish a complete workflow data model.

[0009] 1.1 Set up a data collector to automatically collect milestone information and task dependency relationship data in the project management system, including information such as planned start time, end time, and critical path task identifiers;

[0010] 1.2 Collect the code change records in the code repository, including information such as the list of changed files, the number of changed lines, and the change type (new, modified, deleted).

[0011] 1.3 Collect team collaboration data, including developer roles (such as core developers, functional developers, testers), submission frequency, and working time distribution, etc.

[0012] 1.4 Establish a workflow status data model, represented by a directed acyclic graph G=(V, E), where the vertex set V represents development tasks, and the edge set E represents the dependency relationships between tasks. Each vertex v i ∈V is associated with an attribute vector A(v i ), which contains attributes such as priority, completion status, and resource requirements.

[0013] Step 2: Construct an intelligent evaluation of request priorities;

[0014] Based on the collected multi-dimensional data, calculate the priority score of each build request to form a priority ranking of build tasks.

[0015] 2.1 Calculate the criticality score C i of each build request, and the formula is:

[0016] C i = α·P i + β·D i + γ·B i

[0017] where P i represents the task priority coefficient, D i represents the deadline urgency coefficient, B i represents the blocking impact coefficient, and α, β, γ are weight coefficients and satisfy α + β + γ = 1;

[0018] 2.2 Calculate the impact scope score S i of the build request, and the formula is:

[0019]

[0020] where w j represents the importance weight of the j-th module, and I ij represents whether the build request i affects the module j. If it affects, it is 1; if it does not affect, it is 0;

[0021] 2.3 Calculate the historical build performance score H i , considering factors such as build success rate and average build time; 2.4 Calculate the final priority score F i comprehensively:

[0022] F i = λ1·Ci + λ2·S i + λ3·H i

[0023] Among them, λ1, λ2, and λ3 are weight coefficients and satisfy λ1 + λ2 + λ3 = 1.

[0024] Step 3: Fine-grained dependency analysis and incremental construction;

[0025] Conduct fine-grained analysis on the code changes, accurately identify the affected modules and components, and achieve an accurate mapping between the code changes and the build tasks.

[0026] 3.1 Construct a code dependency graph D = (M, R), where M represents the set of code modules and R represents the dependency relationships between modules:

[0027] 3.1.1 Through static code analysis, extract information such as import declarations, function calls, and class inheritances in the source code;

[0028] 3.1.2 For each module m i ∈ M, identify the set of modules Dep(m i ) = {m j | m i depends on m j};

[0029] 3.1.3 Construct a bipartite graph representation D = (M, R), where R = {(m i , m j ) | m j ∈ Dep(m i )};

[0030] 3.1.4 Calculate the transitive closure to obtain the complete dependency relationships;

[0031] 3.2 For each code submission, analyze the set of changed files F:

[0032] 3.2.1 Parse the difference information in the code repository to obtain a list of changed files F = {f1, f2,..., f k};

[0033] 3.2.2 For each changed file f i , determine the module m(f i ) to which it belongs;

[0034] 3.2.3 Construct an initial set of changed modules M0 = {m(f i ) | f i ∈ F};

[0035] 3.3 Through the depth-first search algorithm, calculate the change propagation paths and determine the set of affected modules M′:

[0036] 3.3.1 Initialize the queue Q to be visited, and enqueue all modules in M0;

[0037] 3.3.2 Initialize the set of affected modules M' = M0;

[0038] 3.3.3 When Q is not empty, dequeue a module m from Q;

[0039] 3.3.4 For each module m' that depends on m, if m' is not in M', add m' to M' and enqueue it to Q;

[0040] 3.3.5 Repeat steps 3.3.3 and 3.3.4 until Q is empty;

[0041] 3.4 Generate the set of minimum building units B to ensure that the building units in B can cover all affected modules M':

[0042] 3.4.1 Represent the building units in the project as a set U = {u1, u2,..., u p}, and each building unit u i contains multiple modules;

[0043] 3.4.2 For each building unit u i , calculate the set of modules Mod(u i ) it contains;

[0044] 3.4.3 Construct a bipartite graph G = (M' ∪ U, E), where E = {(m, u)|m ∈ Mod(u), m ∈ M', u ∈ U};

[0045] 3.4.4 Use the greedy algorithm to solve the minimum covering set problem and find the smallest subset of building units such that ∪ u∈B

[0046] 3.5 Create an incremental build plan based on the set of minimum building units B:

[0047] 3.5.1 According to the dependency relationship between building units, perform a topological sort on the elements in B;

[0048] 3.5.2 Assign build parameters to each building unit and specify the incremental build range;

[0049] 3.5.3 Generate a build script that includes build commands and parameters.

[0050] Step 4: Dynamic resource allocation and scheduling;

[0051] Dynamically adjust the build resource allocation strategy according to the workflow stage, critical path, and system load status.

[0052] 4.1 Monitor the status of system resources, including metrics such as CPU utilization, memory usage, disk I / O, etc.;

[0053] 4.2 Build a resource allocation model, representing the available computing resources as a resource vector R = (r1, r2,..., r k ), where r j represents the available amount of the j-th type of resource;

[0054] 4.3 For the build request queue Q sorted by priority, calculate the resource allocation ratio according to the following formula:

[0055]

[0056] where, A i represents the resource vector allocated to build request i, and F i represents its priority score;

[0057] 4.4 For tasks on the critical path, ensure that the resource allocation is not less than the preset threshold T min ;

[0058] 4.5 Implement a task splitting and parallel execution strategy, decomposing large build tasks into parallel subtasks to maximize the utilization of multi-core processing capabilities.

[0059] Step 5: Predictive build execution;

[0060] Based on historical data and the current state, predict the progress trajectories of each development line to achieve predictive builds.

[0061] 5.1 Build a time series model M t , to predict the distribution of build requests in the future time period:

[0062] 5.1.1 Collect the timestamp data of historical build requests to form a time series T = {t1, t2,..., t n}, where t i represents the submission time of the i-th build request;

[0063] 5.1.2 Apply the Seasonal Autoregressive Integrated Moving Average model (SARIMA) to model the time series, and the model is represented as SARIMA(p, d, q)(P, D, Q) m , where p is the number of autoregressive terms, d is the number of differencing times, q is the number of moving average terms, P, D, Q are the corresponding seasonal parameters, and m is the seasonal period;

[0064] 5.1.3 Use the maximum likelihood estimation method to determine the model parameters and minimize the sum of squared residuals;

[0065] 5.1.4 Predict the distribution of the number of build requests within the future time window [t now , t now +Δt];

[0066] 5.2 Analyze in combination with the developers' working patterns to identify possible peak periods of code submission:

[0067] 5.2.1 For each developer d i , construct the probability density function of their working time distribution

[0068] 5.2.2 Combine the distributions of all developers to obtain the overall submission probability distribution of the team where w i is the weight of developer d i , which is proportional to their average submission frequency;

[0069] 5.2.3 Find the local maximum points of F(t) and mark them as potential peak periods;

[0070] 5.3 During relatively idle periods of system resources, pre-execute the build tasks that may block the development process;

[0071] 5.4 For the build tasks predicted to be of high priority, allocate and preheat computing resources in advance;

[0072] 5.5 Continuously evaluate the prediction accuracy and optimize the prediction model parameters through a feedback mechanism:

[0073] 5.5.1 Calculate the root mean square error (RMSE) between the predicted value and the actual value: where y i is the actual observed value, is the predicted value of the model;

[0074] 5.5.2 Based on the RMSE value, dynamically adjust the model parameters and use the gradient descent method to minimize the prediction error;

[0075] 5.5.3 Retrain the model regularly (such as weekly), incorporate newly generated data, and keep the model up-to-date.

[0076] The present invention also discloses an artificial intelligence-based software development system, including:

[0077] A data acquisition module for collecting multi-dimensional data and establishing a workflow data model;

[0078] A priority evaluation module for calculating the priority score of each build request based on the multi-dimensional data and forming a priority ranking of the build tasks;

[0079] A dependency analysis module, which is used to perform refined analysis on code changes, accurately identify affected modules and components, and achieve an accurate mapping between code changes and build tasks;

[0080] A resource scheduling module, which is used to dynamically adjust the build resource allocation strategy according to the workflow stage, critical path, and system load status, give priority to ensuring critical tasks in case of resource conflicts, and maximize the utilization of multi-core processing capabilities through task splitting and parallel execution;

[0081] A predictive execution module, which is used to predict the progress trajectories of each development line based on historical data and the current state, achieve predictive builds, and proactively handle build tasks that may block the development process.

[0082] By constructing a collaborative resource scheduling system that perceives the overall development workflow, the present invention significantly improves the build efficiency and resource utilization rate in the software development process. Specifically, the present invention has the following beneficial effects:

[0083] Through multi-dimensional data collection and workflow modeling, the system can comprehensively perceive the development process and key nodes, achieve an accurate matching of resource allocation and development rhythm, thereby reducing the waiting time of the development team and improving development efficiency.

[0084] Based on the incremental build strategy of refined dependency analysis, the system can accurately identify the scope of influence of code changes, avoid unnecessary full builds, greatly reduce the consumption of computing resources, and improve the build speed.

[0085] The intelligent priority evaluation and dynamic resource allocation mechanism ensure that critical tasks are given priority, effectively solve the resource competition problem, reduce task blocking on the critical path, and improve the smoothness of the overall development process.

[0086] The predictive build execution strategy anticipates possible build bottlenecks by predicting the patterns of development activities, reduces development interruptions, lowers context switching costs, and optimizes the development experience.

[0087] The present invention is applicable to software development teams of various scales. Especially in large and complex projects, it can significantly improve the team collaboration efficiency and product delivery quality, and has broad application value. BRIEF DESCRIPTION OF THE DRAWINGS

[0088] Figure 1 is the overall flowchart of the software development method based on artificial intelligence of the present invention;

[0089] Figure 2 is the detailed flowchart of the predictive build execution steps of the present invention;

[0090] Figure 3 is the schematic diagram of the predictive build execution of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0091] To make the objectives, technical solutions and advantages of the present invention clearer, the following will further describe the embodiments of the present invention in detail with reference to the accompanying drawings. The described embodiments are only part of the embodiments of the present invention, rather than all of the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the scope of protection of the present invention.

[0092] In the description of the present invention, it should be noted that the orientation or positional relationship indicated by the terms "center", "upper", "lower", "left", "right", "vertical", "horizontal", "inner", "outer", etc. is based on the orientation or positional relationship shown in the accompanying drawings. It is only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore should not be construed as a limitation to the present invention.

[0093] The present invention relates to the field of software engineering, and particularly to a software development system based on artificial intelligence. In modern software development, continuous integration is a key practice for improving code quality and accelerating delivery. With the growth of project scale and team size, continuous integration systems face challenges such as a surge in build requests, uneven resource allocation, and difficult priority management. These problems are particularly prominent in large and complex software projects.

[0094] In the present invention, it is necessary to understand the specific meanings of the following terms:

[0095] "Workflow" refers to the organization and execution sequence of tasks in the software development process, including links such as code writing, building, testing, and deployment;

[0096] "Build request" refers to a request for verification processes such as code compilation and unit testing triggered after a developer submits code;

[0097] "Critical path" refers to the sequence of critical tasks that affect the overall progress during project development;

[0098] "Incremental build" refers to building only the changed parts and their related dependencies, rather than performing a complete build on the entire codebase;

[0099] "Build unit" refers to a collection of code modules or components that can be independently built.

[0100] Existing build scheduling techniques mainly allocate resources based on simple priority queues or static rules, and are unable to perceive the actual working status of development teams and the progress of projects. Especially in large projects, when multiple teams are developing in parallel, these systems usually lead to the following problems: unreasonable resource allocation, where build requests on critical development lines are not processed in a timely manner; unnecessary full builds waste computing resources and extend build times; inability to dynamically adjust resource strategies according to the development rhythm, resulting in resource overload during certain periods and resource idleness during other periods; and lack of precise dependency analysis leading to overly large or inaccurate build scopes.

[0101] The solution provided by the present invention is an artificial intelligence-based software development method that achieves efficient allocation of build resources through multi-dimensional data collection, intelligent priority evaluation, refined dependency analysis, dynamic resource scheduling, and predictive build execution. Its core idea is to use the overall state of the development workflow as the key basis for resource scheduling, enabling the build system to "perceive" the rhythm and progress of the development team and make intelligent decisions accordingly.

[0102] The present invention is applicable to software development projects of various scales, especially suitable for large-scale and complex multi-team collaboration environments. Typical application scenarios include: enterprise application development, where multiple functional teams develop different modules simultaneously; open-source projects, with numerous contributors submitting code in parallel; microservices architecture development, involving a large number of independent service components that need to be built collaboratively; and mobile application development, where versions need to be built for multiple platforms and devices.

[0103] The following will describe the specific implementation manners of the present invention in detail with reference to the accompanying drawings.

[0104] Refer to Figure 1 , the overall process of the artificial intelligence-based software development method provided by the present invention includes the following steps:

[0105] Step S1: Multi-dimensional workflow data collection and modeling;

[0106] This step first establishes a data collector that connects to various relevant system interfaces, including project management systems, code repository systems, build systems, and team collaboration tools, etc. In specific implementation, the collector can obtain data through APIs, event hooks, or log analysis, etc.

[0107] In a specific embodiment, the data collector regularly (for example, every 5 minutes) obtains project milestone and task information from project management systems such as JIRA, code commit history and change records from code repository systems such as Git, historical build performance data from build systems such as Jenkins, and team activity data from collaboration tools such as Slack.

[0108] The data collected mainly includes the following categories:

[0109] Project milestone data: including milestone name, target date, percentage of completed tasks, etc.;

[0110] Task dependency data: the precedence and post-dependency relationships between tasks, forming a directed acyclic graph;

[0111] Team collaboration data: including developer role classification, active time distribution, code submission frequency, etc.;

[0112] Code change data: including list of changed files, number of changed lines, change type (new / modified / deleted), etc.;

[0113] Module importance data: the module importance weight obtained based on expert evaluation or historical defect statistics;

[0114] Historical build data: including metrics such as build time, success rate, resource consumption, etc.

[0115] Based on the collected data, this step constructs a workflow status data model, represented by a directed acyclic graph (DAG), formally defined as G = (V, E), where:

[0116] The vertex set V represents development tasks, and each vertex v i ∈ V corresponds to a task;

[0117] The edge set E represents the task dependency relationship. If task v i depends on task v j , then there is a directed edge (v j , v i ) ∈ E;

[0118] Each vertex v i is associated with an attribute vector A(v i ), which contains attributes such as priority, completion status, resource requirements, etc.

[0119] This representation method can comprehensively capture the structure and status of the development workflow, providing a basis for subsequent priority evaluation and resource scheduling.

[0120] Step S2: Construct intelligent evaluation of request priority;

[0121] This step implements a multi-factor priority evaluation model to calculate the priority score for each build request. This model comprehensively considers factors in multiple dimensions, mainly including:

[0122] Task criticality: Evaluate the importance of the task corresponding to the build request in the entire workflow. Calculate the criticality score C through the following formula i :

[0123] Ci = α·P i + β·D i + γ·B i

[0124] Wherein, P i represents the basic priority coefficient of the task, usually obtained from the project management system; D i represents the deadline urgency coefficient, which increases as the task deadline approaches; B i represents the blocking impact coefficient, which quantifies the degree to which this task blocks other tasks; α, β, and γ are weight coefficients and satisfy α + β + γ = 1. In actual implementation, these weight coefficients can be automatically adjusted by machine learning algorithms based on historical data.

[0125] Change impact scope: Evaluate the impact degree of code changes on the system. Calculate the impact scope score S through the following formula i :

[0126]

[0127] Wherein, w j represents the importance weight of the j-th module, and these weights can be determined based on the complexity of the module, historical defect rate, or business importance; I ij represents whether the build request i affects the module j, with an impact of 1 and no impact of 0.

[0128] Historical build performance: Consider factors such as the historical build success rate and average build time of this developer or module, and calculate the historical performance score H i .

[0129] Finally, based on the scores of these three dimensions, calculate the total priority score F of the build request i :

[0130] F i = λ1·C i + λ2·S i + λ3·H i

[0131] Wherein, λ1, λ2, and λ3 are weight coefficients and satisfy λ1 + λ2 + λ3 = 1.

[0132] Based on the calculated priority scores, the system sorts all pending build requests to form a priority queue. This sorting method ensures that the build requests that are most critical to the overall workflow can obtain resources first.

[0133] Step S3: Fine-grained dependency analysis and incremental build;

[0134] Refer to Figure 2, this step implements a refined code dependency analysis and incremental build mechanism to accurately identify the scope of impact of code changes and avoid unnecessary full builds. The specific implementation includes the following sub-steps:

[0135] 3.1 Build a code dependency graph: Through static code analysis, build a dependency graph D = (M, R) between code modules, where M represents the set of code modules and R represents the dependency relationships between modules. In a specific embodiment, this step uses an AST (Abstract Syntax Tree) analysis tool to extract information such as import declarations, function calls, and class inheritances in the source code to identify the dependency relationships between modules.

[0136] 3.2 Code change analysis: For each code commit, the system parses the difference information in the code repository to obtain the list of changed files F = {f1, f2,..., f k}, and determines the module to which each file belongs, and constructs the initial changed module set M0 = {m(f i ) | f i ∈ F}.

[0137] 3.3 Change propagation analysis: Use the depth-first search algorithm to calculate the propagation paths of the changed modules in the dependency graph and determine the set of affected modules M'. The specific algorithm is as follows:

[0138] Initialize the queue Q to be visited, and enqueue all modules in M0;

[0139] Initialize the set of affected modules M' = M0;

[0140] When Q is not empty, dequeue a module m from Q;

[0141] For each module m' that depends on m, if m' is not in M', then add m' to M' and enqueue it to Q;

[0142] Repeat the above process until Q is empty.

[0143] 3.4 Determine the minimum build unit: The build units in a project are usually predefined and represented as a set U = {u1, u2,..., u p}. Each build unit u i contains multiple modules, and the set of modules it contains is represented as Mod(u i ). This step finds the smallest subset of build units such that In practice, a greedy algorithm can be used to solve this problem:

[0144] Initialize the result set The remaining set of modules to be covered M remain = M';

[0145] When , select the building block u that can cover the most modules in M remain and add u i to B, and remove the modules covered by u i from M remain ; i Covered module;

[0146] Repeat the above process until

[0147] 3.5 Incremental build plan generation: Based on the determined set of minimum building blocks B, the system generates an incremental build plan. First, according to the dependency relationship between building blocks, perform a topological sort on the elements in B to determine the build order; then assign build parameters to each building block to specify the incremental build range; finally, generate a build script, including build commands and parameters.

[0148] Step S4: Dynamic resource allocation and scheduling;

[0149] This step implements a dynamic resource allocation and scheduling mechanism, which dynamically adjusts the build resource allocation strategy according to the workflow stage, critical path, and system load status. The specific implementation includes:

[0150] 4.1 System resource monitoring: Establish a resource monitoring module to monitor the system resource status in real time, including indicators such as CPU utilization, memory usage, and disk I / O. The granularity of resource monitoring can be the entire build server cluster or refined to individual build nodes.

[0151] 4.2 Resource allocation model construction: Represent the available computing resources as a resource vector R = (r1, r2,..., r k ), where r j represents the available amount of the jth type of resource (such as the number of CPU cores, memory capacity, etc.). Resource allocation follows the proportional allocation principle, that is, the higher the priority of the build request, the greater the proportion of resources obtained.

[0152] 4.3 Resource allocation calculation: For the build request queue Q sorted by priority, calculate the resource allocation ratio according to the following formula:

[0153]

[0154] where A i represents the resource vector allocated to build request i, and F i represents its priority score. This allocation method ensures that the resource allocation is proportional to the task priority.

[0155] 4.4 Key task resource guarantee: For tasks on the critical path, the system has an additional resource guarantee mechanism to ensure that the resource allocation is not lower than the preset threshold T. min When the calculated resource allocation is lower than the threshold, the system will adjust the resource allocation of other non-critical tasks to ensure the resource requirements of critical tasks.

[0156] 4.5 Task splitting and parallel execution: For large-scale construction tasks, the system implements a task splitting mechanism to decompose them into parallel subtasks and make full use of the multi-core processing ability. The splitting strategy is based on the dependency relationship of code modules to ensure that modules without dependencies can be built in parallel.

[0157] In the actual implementation, the resource allocation decision is calculated and executed in real time by a central scheduler. When the system load status changes or a new construction request arrives, the scheduler will recalculate the resource allocation plan and dynamically adjust the resources of the tasks being executed.

[0158] Step S5: Predictive build execution;

[0159] Refer to Figure 3 , this step implements a predictive build execution mechanism to predict the progress trajectories of each development line based on historical data and the current state, and to preprocess the build tasks that may block the development process. The specific implementation includes:

[0160] 5.1 Time series model construction: Collect the timestamp data of historical build requests to form a time series T = {t1, t2,..., t n}, and apply the Seasonal Autoregressive Integrated Moving Average model (SARIMA) for modeling. The model is expressed as SARIMA(p, d, q)(P, D, Q) m , where p is the number of autoregressive terms, d is the number of differences, q is the number of moving average terms, P, D, Q are the corresponding seasonal parameters, and m is the season period. The model parameters are determined by the maximum likelihood estimation method to minimize the sum of squared residuals.

[0161] 5.2 Analysis of developer work patterns: For each developer d i , based on their historical commit records, construct the probability density function of the work time distribution Then merge the distributions of all developers to obtain the overall commit probability distribution of the team where w i is the weight of developer d i , which is proportional to their average commit frequency. By analyzing the local maximum points of F(t), the possible code commit peak periods can be identified.

[0162] 5.3 Pre - constructed Execution: During the predicted trough period of build requests (usually corresponding to relatively idle periods of system resources), the system proactively executes those build tasks that are predicted to be upcoming and may block the development process. The selection of these tasks is based on the following factors: being on the critical path of the workflow; approaching the deadline; having complex dependencies; having a long historical build time; and affecting the work of multiple developers.

[0163] 5.4 Resource Pre - heating: For build tasks predicted to be of high priority, the system will allocate and pre - heat computing resources in advance, such as starting the container environment, pre - loading dependency libraries, etc., to reduce the time overhead for task startup.

[0164] 5.5 Prediction Accuracy Evaluation and Optimization: The system continuously evaluates the accuracy of the prediction model, calculates the root mean square error (RMSE) between the predicted value and the actual value. Based on the evaluation results, the system uses the gradient descent method to dynamically adjust the model parameters to minimize the prediction error. At the same time, the system retrains the model regularly (e.g., weekly), incorporating newly generated data to maintain the timeliness of the model.

[0165] In one embodiment, the prediction model also incorporates specific characteristics of the software project, such as the version release cycle, development iteration rhythm, etc., further improving the accuracy and practicality of the prediction.

[0166] The present invention also provides an artificial - intelligence - based software development system, including the following functional modules:

[0167] Data Acquisition Module: Used to collect multi - dimensional data such as project milestones, task dependencies, team collaboration patterns, code change scope, module importance, committer roles, and historical build performance, and establish a workflow data model. This module is integrated with external systems such as project management systems, code repository systems, build systems, and team collaboration tools, and obtains data through API interfaces, event hooks, or log analysis.

[0168] Priority Evaluation Module: Used to calculate the priority score of each build request based on multi - dimensional data, forming a priority ranking of build tasks. This module implements a multi - factor evaluation algorithm, comprehensively considering factors such as task criticality, change impact scope, and historical build performance, and assigns a priority score to each build request.

[0169] Dependency Analysis Module: Used to perform refined analysis on code changes, accurately identify affected modules and components, and achieve an accurate mapping between code changes and build tasks. This module includes functional components such as code dependency graph construction, change analysis, propagation analysis, and determination of the minimum build unit.

[0170] Resource Scheduling Module: It is used to dynamically adjust the build resource allocation strategy according to the workflow stage, critical path, and system load status, and prioritize critical tasks in case of resource conflicts. This module monitors the system resource status, calculates the resource allocation plan based on priorities, and ensures the resource requirements of critical tasks.

[0171] Predictive Execution Module: It is used to predict the progress trajectories of each development line based on historical data and the current status, implement predictive builds, and preprocess build tasks that may block the development process in advance. This module constructs a time series prediction model and a developer work pattern analysis model, and pre-executes critical tasks during relatively idle periods of system resources.

[0172] Each module collaborates with each other through data flow and control flow to form a complete workflow-aware build system. The system also includes a configuration management component that allows administrators to adjust the parameters and policies of each module to adapt to the specific needs of different projects.

[0173] In a specific embodiment, the method of the present invention can be implemented on a computer device, which includes:

[0174] Processor: It is used to execute computer program instructions to implement data processing and logical control functions;

[0175] Memory: It is used to store computer programs and data, including operating systems, application programs, and various data files;

[0176] Storage: It is used to persistently store data and programs, such as hard disk drives or solid state drives;

[0177] Communication Interface: It is used to communicate with external systems (such as project management systems, code repository systems, etc.) to obtain data and send instructions;

[0178] Data Bus: It connects each hardware component to achieve data transmission.

[0179] The processor executes the collaborative build resource scheduling program stored in the memory to implement the various functions of the present invention. This program can be modularly designed, corresponding to the foregoing functional modules, including a data acquisition module, a priority evaluation module, a dependency analysis module, a resource scheduling module, and a predictive execution module.

[0180] It should be understood that the above embodiments are only examples clearly illustrating the present invention and are not limitations on the implementation manners. For those of ordinary skill in the art, other different forms of changes or modifications can be made based on the above description. It is not necessary and impossible to enumerate all implementation manners here. Any modifications, equivalent replacements, and improvements made within the spirit and principle of the present invention shall be included within the protection scope of the claims of the present invention.

Claims

1. A software development method based on artificial intelligence, characterized in that, It includes the following steps: Collect project milestones, task dependencies, team collaboration patterns, and code change scopes, and establish a workflow data model; Based on the multi-dimensional data, calculate the priority scores of each build request to form a priority ranking of build tasks; Conduct a refined analysis of code changes, accurately identify affected modules and components, and achieve an accurate mapping between code changes and build tasks; According to the workflow stage, critical path, and system load status, dynamically adjust the build resource allocation strategy, prioritize critical tasks in case of resource conflicts, and maximize the utilization of multi-core processing capabilities through task splitting and parallel execution; Based on historical data and the current status, predict the progress trajectories of each development line, achieve predictive builds, and proactively handle build tasks that may block the development process.

2. The method according to claim 1, wherein The steps of establishing the workflow data model include: Use a directed acyclic graph G = (V, E) to represent the workflow state data model, where the vertex set V represents development tasks, the edge set E represents the dependency relationships between tasks, and each vertex v i ∈ V is associated with an attribute vector A(v i ), which includes priority, completion status, and resource requirements.

3. The method according to claim 1, wherein The steps of calculating the priority scores of each build request include: Calculate the criticality score C for each build request i , denoted as C i = α·P i + β·D i + γ·B i , where P i represents the task priority coefficient, D i represents the deadline urgency coefficient, B i represents the blocking impact coefficient, and α, β, γ are weight coefficients and satisfy α + β + γ = 1; Calculate the influence scope score S of the build request i , expressed as where w j represents the importance weight of the j-th module, and I ij represents whether the build request i affects the module j; Comprehensively calculate the final priority score F i = λ1·C i + λ2·S i + λ3·H i , where H i is the historical construction performance score, and λ1, λ2, and λ3 are weight coefficients and satisfy λ1 + λ2 + λ3 = 1.

4. The method according to claim 1, wherein The steps of conducting a refined analysis of code changes include: Construct a code dependency graph D = (M, R), where M represents the set of code modules and R represents the dependency relationships between modules; For each code submission, analyze the set of changed files F; Calculate the change propagation path through the depth-first search algorithm to determine the set of affected modules M'; Generate a set of minimum build units B to ensure that the build units in B can cover all affected modules M'; Create an incremental build plan based on the set of minimum build units B.

5. The method according to claim 4, wherein The steps of determining the set of affected modules M' include: Initialize the queue Q to be visited, and enqueue all modules in the initial set of changed modules M0; Initialize the set of affected modules M' = M0; When Q is not empty, dequeue a module m from Q; For each module m' that depends on m, if m' is not in M', then add m' to M' and enqueue it to Q; Repeat the above process until Q is empty.

6. The method according to claim 1, wherein The steps of dynamically adjusting the build resource allocation strategy include: Monitor the system resource status, including CPU utilization, memory usage, and disk I / O; Construct a resource allocation model, and represent the available computing resources as a resource vector R = (r1, r2,..., r k ), where r j represents the available amount of the j-th type of resource; For the constructed request queue Q after priority sorting, calculate the resource allocation ratio where A i represents the resource vector allocated to the construction request i, and F i represents its priority score; For tasks on the critical path, ensure that the resource allocation is not less than the preset threshold T min .

7. The method according to claim 1, wherein The steps of achieving predictive builds include: Construct a time series model M t , and predict the distribution of build requests within a future time period; Combined with the analysis of developers' working patterns, identify possible peak periods of code submissions; During relatively idle periods of system resources, proactively execute build tasks that may block the development process; Continuously evaluate the prediction accuracy and optimize the prediction model parameters through a feedback mechanism.

8. The method according to claim 7, wherein The steps of constructing the time series model M t include: Collect the timestamp data of historical build requests to form a time series T = {t1, t2,..., t n}, where t i represents the submission time of the i-th build request; The seasonal autoregressive integrated moving average model (SARIMA) is used to model the time series, and the model is expressed as SARIMA(p,d,q)(P,D,Q) m , where p is the number of autoregressive terms, d is the number of differencing times, q is the number of moving average terms, P, D, Q are the corresponding seasonal parameters, and m is the seasonal period; Use the maximum likelihood estimation method to determine the model parameters and minimize the sum of squared residuals.

9. The method according to claim 7, wherein The steps of continuously evaluating the prediction accuracy include: Calculate the root mean square error (RMSE) between the predicted value and the actual value: where y i is the actual observed value, is the predicted value of the model; Based on the RMSE value, dynamically adjust the model parameters and use the gradient descent method to minimize the prediction error; Regularly retrain the model, incorporate newly generated data, and maintain the timeliness of the model.

10. An artificial intelligence-based software development system, characterized in that, It includes: A data collection module for collecting multi-dimensional data and establishing a workflow data model; A priority evaluation module for calculating the priority scores of each build request based on the multi-dimensional data to form a priority ranking of build tasks; A dependency analysis module for conducting a refined analysis of code changes, accurately identifying affected modules and components, and achieving an accurate mapping between code changes and build tasks; A resource scheduling module, which is used to dynamically adjust the build resource allocation strategy according to the workflow stage, critical path, and system load status, prioritize critical tasks in case of resource conflicts, and maximize the utilization of multi-core processing capabilities through task splitting and parallel execution; A predictive execution module, which is used to predict the progress trajectories of each development line based on historical data and the current status, achieve predictive builds, and proactively handle build tasks that may block the development process.

Images