A software development project progress forecasting management method based on artificial intelligence

Abstract

The present application provides an artificial intelligence-based software development project progress forecasting and management method, comprising: obtaining a project module dependency graph, analyzing the dependency strength and impact range between modules, and determining the weights of key modules and their dependent modules; assigning task priorities based on developer skill levels, and calculating the development time estimate for each module in combination with technical complexity to generate an initial progress plan; monitoring the development progress of key modules in real time, and if a lag is found, triggering a resource allocation mechanism, re-evaluating task priorities, and adjusting developer allocation; and triggering a model self-learning mechanism if the deviation between the progress forecast model output and the actual situation exceeds a preset threshold, retraining the progress forecast model, and updating the Bayesian network and adaptive filtering parameters.

Description

Technical Field

[0001] The present invention relates to the field of information technology, and in particular to a software development project progress prediction and management method based on artificial intelligence. Background Art

[0002] In software development projects, the complex dependencies between modules pose a significant challenge to project schedule prediction. As the project progresses, the development progress of certain key modules may lag, hindering the development of other dependent modules. In this situation, real-time resource allocation to balance the development progress of each module becomes crucial for project management. However, this resource allocation involves trade-offs across multiple dimensions, including explicit factors such as developer skill level, task priorities, and technical complexity, as well as implicit factors such as team collaboration efficiency, accumulated technical debt, and unexpected technical difficulties. The impact of these factors on project schedule is difficult to quantify and predict, posing a significant challenge for AI-based schedule prediction models. Accurately capturing these implicit factors based on limited historical data and incorporating them into schedule prediction models is an urgent technical challenge. Traditional schedule prediction models often rely on extensive historical data and prior knowledge, but in software development projects, this data and knowledge is often incomplete and even dynamically changing. Therefore, designing an adaptive schedule prediction model that can dynamically optimize its prediction strategy based on real-time feedback from project progress has become a key technical challenge. This requires that the schedule prediction model possess the ability to continuously learn and self-optimize, autonomously extract key features from limited data, and adjust prediction strategies in real time based on changes in the project environment. Furthermore, the schedule prediction model must be able to handle uncertainty and noisy data to improve the robustness of the prediction. Summary of the Invention

[0003] The present invention provides a software development project progress forecasting and management method based on artificial intelligence, which mainly includes:

[0004] Obtain the project module dependency diagram, analyze the dependency strength and impact range between modules, and determine the weights of key modules and their dependent modules;

[0005] Assign task priorities based on developer skill levels, combine technical complexity, calculate development time estimates for each module, and generate an initial schedule;

[0006] Monitor the development progress of key modules in real time. If any lag is detected, the resource allocation mechanism will be triggered to re-evaluate task priorities and adjust developer allocation.

[0007] Build a Bayesian network model, using hidden factors such as team collaboration efficiency, technical debt accumulation, and sudden technical difficulties as nodes, construct a probability relationship graph, and quantify the impact of hidden factors on progress;

[0008] Based on real-time progress data and Bayesian network output, the module development time estimate is dynamically updated to generate an adjusted schedule, which is then fed back to the resource allocation mechanism.

[0009] If the deviation between the output of the progress prediction model and the actual situation exceeds a preset threshold, the model self-learning mechanism is triggered to retrain the progress prediction model and update the Bayesian network and adaptive filtering parameters.

[0010] The technical solution provided by the embodiment of the present invention may have the following beneficial effects:

[0011] The present invention discloses a software development project progress prediction and management method based on artificial intelligence. By constructing a module dependency graph and a Bayesian network model, accurate prediction and dynamic adjustment of the project progress are achieved. The present invention first analyzes the dependency strength between modules, determines the weights of key modules, and assigns tasks according to the skill level of developers. During the project execution process, the present invention monitors the progress of key modules in real time and triggers the resource allocation mechanism when a lag is found. Innovatively, implicit factors such as team collaboration efficiency and technical debt accumulation are incorporated into the Bayesian network to quantify their impact on the progress. Based on real-time data and model output, the present invention dynamically updates the development time estimate and generates an adjusted schedule. When the prediction deviation exceeds the threshold, the model self-learning mechanism is triggered to ensure the accuracy of the prediction. Finally, the present invention optimizes resource allocation and task priority based on the prediction results, effectively ensuring that the project proceeds as planned, and significantly improving the intelligence level and efficiency of project management. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] Figure 1 This is a flowchart of an artificial intelligence-based software development project progress prediction and management method of the present invention. DETAILED DESCRIPTION

[0013] The technical solutions of the present invention will be clearly and completely described below in conjunction with the embodiments. Obviously, the embodiments described are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0014] like Figure 1 As shown, in this embodiment, an artificial intelligence-based software development project progress forecasting and management method may specifically include:

[0015] S101. Obtain the project module dependency diagram, analyze the dependency strength and impact range between modules, and determine the weights of key modules and their dependent modules.

[0016] Obtain dependency data of all modules in the project, pre-process and clean the dependency data, and construct a module dependency graph; use the NetworkX library to calculate the strength coefficient of the dependencies between modules in the module dependency graph. The strength coefficient is determined by the number and weight of the dependencies and is used to indicate the importance of the module; sort the modules according to the strength coefficient, and take the top 20% of the modules as the key modules of the project; for each key module, use the depth-first search algorithm in the NetworkX library to identify its directly and indirectly dependent upstream modules, and obtain the dependent module set of the key module; perform K-means clustering analysis on the dependent module set of the key module, and The similarities between modules divide them into different dependent module groups; for each dependent module group, the hierarchical analysis method is used to construct a judgment matrix to calculate the dependency contribution weight of each module in the group to the key module; the strength coefficient of the key module is multiplied by the contribution weight of its dependent module group to obtain the comprehensive importance index of the key module; based on the Matplotlib library, a global weight distribution diagram of the project module dependency is drawn, the size of the node in the weight distribution diagram represents the comprehensive importance of the module, and the thickness of the edge represents the weight of the dependency; through the Dijkstra shortest path algorithm, the critical paths and dependency chains whose overall impact on the project is greater than the preset threshold are identified in the weight distribution diagram.

[0017] For example, first, you need to obtain dependency data for all modules in the project. This can be achieved using static code analysis tools or version control system logs. For example, in an e-commerce system, you might find that the order module depends on the user module, the product module, and the payment module. During the data preprocessing phase, you need to clean the raw dependency data to remove duplicates and invalid dependencies. Then, use the NetworkX library to construct a module dependency graph, where nodes represent modules and edges represent dependency relationships. This graph visually shows the connections between the order module and other modules. Next, calculate the strength coefficient of the inter-module dependency relationships. This is achieved by considering the number and weight of dependencies. For example, if the order module frequently calls multiple functions in the payment module, the strength of the dependency between them is high. Sorting by the dependency strength coefficient can identify the key modules of the project. Suppose that in an e-commerce system, the order module and the user module are identified as key modules. For each key module, use a depth-first search algorithm to identify its direct and indirect upstream modules. This creates a set of dependent modules for the key module. For example, the order module's dependency set might include the user, product, payment, and inventory modules. Then, perform K-means clustering analysis on these dependent module sets. This helps to divide modules into different dependency module groups based on their similarities. In an e-commerce system, user-related modules may form one group, while product-related modules form another. For each dependency module group, a judgment matrix is ​​constructed based on the analytic hierarchy process. The elements in the judgment matrix represent the relative importance of each module within the group. By calculating the eigenvectors of the judgment matrix, the initial weight vectors of the dependency contributions of each module within the group to the key module are obtained. A consistency check method is used to determine whether the consistency of the initial dependency contribution weight vectors meets the requirements. If not, the judgment matrix is ​​adjusted and recalculated until the consistency requirement is met. For dependency contribution weight vectors that meet the consistency requirement, they are normalized to convert them into the final dependency contribution weights of each module. For example, in the order processing process, the payment module may have a higher contribution weight than the inventory module. By multiplying the dependency strength coefficient of the key module by the contribution weight of its dependent module group, a comprehensive importance index for the key module is obtained. This index can help more comprehensively assess the importance of modules in the entire system. Finally, the Matplotlib library is used to plot the global weight distribution of the project module dependencies. In this visualization, the size of the nodes represents the overall importance of the modules, and the thickness of the edges represents the weight of the dependencies. This allows for a clear overview of the system's most critical modules and most important dependencies. Using the Dijkstra shortest path algorithm, we can identify the critical paths and dependency chains that have the greatest impact on the project as a whole. In an e-commerce system, this might be a series of module links from user login to order placement and payment.This comprehensive dependency analysis approach not only helps understand the system architecture, but also guides refactoring decisions, resource allocation, and testing strategy development. By focusing on key modules and important dependencies, development teams can more effectively conduct code reviews, performance optimization, and risk management.

[0018] S102. Assign task priorities based on developer skill levels, combine technical complexity, calculate the development time estimate for each module, and generate an initial schedule.

[0019] Obtain the technical requirements of all project modules and conduct a detailed analysis of each module's functionality, performance, and user experience. Module complexity is assessed based on technical complexity and innovation factors, and the assessment results are quantified into complexity levels or weights to create a module complexity matrix. Obtain developer skill levels and experience data, including programming languages, frameworks, development tools, and relevant project experience. Each developer's skills are assessed to create a developer skill matrix. Based on the module complexity matrix and developer skill matrix, the Hungarian algorithm is used to optimally match modules with developers. The goal is to match developer skills with module complexity while meeting the module's technical requirements. Based on module complexity and developer skill levels, the COCOMO model is used to estimate the development effort and time for each module. The basic formula of the COCOMO model is: PM = a(KLOC)^bEAF, where PM is man-months, KLOC is thousands of lines of code, a and b are empirical parameters, and EAF is an adjustment factor. Parameter values ​​are selected based on the project's scale, complexity, and personnel quality, and substituted into the formula to estimate the estimated development effort and time for each module. Using the analytic hierarchy process, combined with business value, technical risk and dependency factors, the module priority is evaluated to obtain the priority weight of each module; based on the module priority and estimated development time, the critical path method (CPM) is used to generate the initial version of the project schedule. Modules are regarded as activities in the AON network diagram, and the dependencies between modules are regarded as the order of activities. Forward recursion and reverse recursion are used to calculate the earliest start time, latest start time, earliest end time and latest end time of each activity to find the critical path and determine the key activities and milestone nodes of the project. Based on the estimated workload of each module and the available time of the developers, determine whether there is a resource conflict. If there is a resource conflict, eliminate the resource conflict by delaying the start time of non-critical activities and adjusting task allocation measures to obtain an executable project schedule.

[0020] For example, accurately assessing module complexity and developer skills is crucial in software project management. For example, an e-commerce platform can be divided into modules such as user management, product management, order processing, and payment systems. For each module, detailed analysis is required regarding its functional requirements, performance metrics, and user experience requirements. For example, the payment system module must not only handle multiple payment methods but also ensure transaction security and high concurrency. By considering technical complexity and innovation, the payment system can be given a higher complexity score, such as 8 out of 10. At the same time, the skill levels of development team members must be assessed. Consider a developer named Xiao Z, who is proficient in Java, familiar with the Spring framework, and has three years of experience developing payment systems. His skill level in the payment system area can be rated 9. By constructing a module complexity matrix and a developer skills matrix, the Hungarian algorithm can be used to optimize the matching, ensuring that the most appropriate personnel are assigned to each module. The COCOMO model provides a reliable method for estimating development effort. For the payment system module, assuming an estimated code size of 5,000 lines, select the semi-independent project parameters a=3.0 and b=1.12. Considering the project's high reliability requirements, the EAF may be adjusted to 1.15. This calculation provides an estimate of the module's development effort. Next, the priority of each module needs to be assessed. Using the Analytic Hierarchy Process (AHP), factors such as business value, technical risk, and dependencies can be considered to prioritize modules and determine their respective priority weights. Using the AHP, factors such as business value, technical risk, and dependencies can be constructed into a hierarchy. By comparing the importance of these factors pairwise, a judgment matrix can be generated, which can then be used to calculate the priority weight of each module. For example, in an e-commerce platform, the payment system often has higher business value and technical risk, so it may be assigned a higher priority weight. Based on the module priorities and estimated development time, the critical path method can be used to generate an initial project schedule. Based on the dependencies between modules, an AON network diagram is constructed, treating modules as activities and dependencies as sequential relationships, forming a directed acyclic graph. Starting with the starting activity, use forward recursion to calculate the earliest start time and earliest end time of each activity. During the calculation process, if activity A is a predecessor of activity B, then the earliest start time of activity B is equal to the earliest end time of activity A. Starting with the terminating activity, use backward recursion to calculate the latest start time and latest end time of each activity. During the calculation process, if activity B is a successor of activity A, then the latest end time of activity A is equal to the latest start time of activity B. For each activity, determine whether its earliest start time is equal to its latest start time and whether its earliest end time is equal to its latest end time. If they are equal, the activity is critical; otherwise, it is non-critical. Find the path consisting of critical activities, which is the critical path.Activities along the critical path are key activities and determine the total project duration. Milestones—important activities or time points along the critical path—are identified. Milestones typically mark significant progress or milestones in the project and require focused attention and management. Based on the critical path and milestones, resource allocation and scheduling can be optimized to ensure on-time project completion. For non-critical activities, their start and end times can be adjusted appropriately to improve resource utilization and project flexibility. In an e-commerce platform development project, the user management module may be a prerequisite for other modules and therefore likely represents a node on the critical path. Identifying the critical path allows you to identify key activities and milestones, providing important guidance for project management. Finally, potential resource conflicts need to be resolved. For example, suppose that in addition to being responsible for the payment system, Xiao Z is also assigned some work on the user management module. This may lead to a time conflict. By appropriately delaying the start times of non-critical activities or adjusting task assignments, the project can proceed smoothly. This comprehensive project planning approach not only improves development efficiency, but also reduces project risk and ensures optimal resource allocation. By precisely matching developer skills with module complexity, team members' expertise can be fully utilized while providing them with appropriate challenges and growth opportunities. Priority-based scheduling ensures that the most critical features are developed and tested in a timely manner, thereby better meeting market needs and user expectations.

[0021] S103. Monitor the development progress of key modules in real time. If any delay is found, trigger the resource allocation mechanism, re-evaluate task priorities, and adjust developer allocation.

[0022] A1. Obtain the preset development progress threshold and actual development progress data of key modules, and compare the preset development progress threshold with the actual development progress data; A2. If the actual development progress data is lower than the preset development progress threshold, trigger the resource allocation mechanism; A3. Obtain the task feature data and developer skill data of historical projects, and establish a support vector machine model based on the task feature data and developer skill data; A4. Obtain the task features of the current project, input the task features of the current project into the support vector machine model, and predict the priority of each task through the support vector machine model; A5. Obtain the developer skill data and work saturation A6. Write the personnel deployment plan into the project management system database, triggering the project management system to automatically generate an adjustment notification and update the project schedule. A7. Continuously monitor the development progress of key modules, regularly obtain actual progress data from the project management system, and determine whether the actual progress data is still below the preset development progress threshold. A8. If the actual progress data is still below the preset development progress threshold, return to step A2 and re-trigger resource deployment until the actual progress data is synchronized with the preset development progress threshold.

[0023] For example, for the order processing module of an e-commerce platform, a minimum requirement for the number of function points completed per week can be set. Assuming a target of 10 function points per week, the threshold can be set to 8. Any progress below this threshold triggers an alert. Actual development progress data can be automatically collected through project management tools. For example, developers update task status daily, and the system automatically calculates the number of function points completed. When actual progress falls below the threshold, the system automatically marks the module as "behind" and initiates resource allocation. To achieve intelligent resource allocation, machine learning techniques can be utilized. Features such as task complexity, estimated duration, and dependencies can be extracted from historical projects, along with corresponding priority labels, for use in training a support vector machine model. Task feature data from historical projects, including task type, complexity, and duration, is obtained and used as input features for the support vector machine model. Developer skill data from historical projects, including technical level, years of experience, and areas of expertise, is also obtained and used as output labels for the support vector machine model. A support vector machine model is constructed based on the obtained task feature data and developer skill data, and then trained using the historical data to obtain a trained support vector machine model. In practice, the task characteristics of the current project are input into a trained support vector machine model. For example, for the user authentication module, the input features might be "medium complexity, estimated work time 40 hours, and dependency on the database module." The model will output a priority prediction, such as "high priority." With the task priority prediction, the next step is staffing. The Hungarian algorithm can be used here, which finds the optimal solution to many-to-many matching problems. This requires considering the developer's skill data and current workload. Specifically, the developer's skill data and workload data are pre-processed and converted into the input format required by the Hungarian algorithm. Skill data is represented as a person-skill matrix, and workload data is represented as a person-task matrix. The Hungarian algorithm, using task priority values ​​as weights, optimizes the matching between the person-skill matrix and the person-task matrix to generate a staffing plan. For example, an engineer proficient in back-end development may be more suited to database-related tasks. The staffing plan is stored in the project management system database, and the system automatically generates a staffing adjustment notification. For example, "Engineer Z: Please shift your focus to the user authentication module, which is expected to require 40 hours." At the same time, the system updates the project schedule, potentially pushing back certain tasks on the non-critical path to ensure timely completion of key components. This process is continuous and iterative. The system regularly checks actual progress to see if any lags remain. If progress issues persist, further adjustments may be necessary, such as increasing human resources or reassessing the project scope. This dynamic adjustment mechanism enables timely response to project changes and challenges, improving the flexibility and efficiency of project management.This approach not only enables timely identification and resolution of progress issues, but also maximizes the efficiency of team resource utilization. The introduction of machine learning technology makes task prioritization more objective and accurate, while automated resource allocation and notification systems significantly reduce manual operations for project managers, allowing them to focus more on strategic decision-making and team management.

[0024] S104. Build a Bayesian network model, using hidden factors such as team collaboration efficiency, technical debt accumulation, and sudden technical difficulties as nodes, construct a probability relationship diagram, and quantify the impact of hidden factors on progress.

[0025] Obtain historical project data, use the maximum likelihood estimation method to estimate the conditional probability distribution parameters of each node in the Bayesian network model, and obtain the probability distribution of hidden factors such as team collaboration efficiency, technical debt accumulation, and sudden technical difficulties; use the Monte Carlo simulation method to randomly generate multiple combinations of hidden factors, input them into the Bayesian network model, calculate the conditional probability distribution of project progress under each combination, and quantify the distribution of the impact of hidden factors on project progress; based on the information gain principle, calculate the information entropy of the conditional probability distribution of project progress, and by comparing the change in information entropy after introducing each hidden factor node, judge the significance of the impact of each hidden factor on the project progress, and identify the key factors that have the greatest impact on the progress; for key hidden factors, evaluate the impact of their current status on the project progress, and compare the probability of progress delay under the current status with the preset delay risk threshold. The value is compared with the expected value. If it exceeds the threshold, an early warning is triggered, prompting project managers to take countermeasures. During the project implementation process, project progress, manpower input, and demand change tracking data are continuously collected, and data preprocessing technology is used to convert the data into the input of the Bayesian network model. Through the maximum a posteriori probability estimation method, combined with the prior distribution and newly collected data, the probability distribution of the implicit factor nodes is dynamically updated, and the Bayesian network model is continuously optimized to improve the accuracy of project progress prediction. If the impact of a certain implicit factor on the project progress continues to exceed expectations, the progress delay caused by the factor is diagnosed and quantified, and the proportion of the delayed time to the planned progress is evaluated. If it exceeds the preset threshold, the project manager is prompted to evaluate the necessity of adjusting the project plan, weigh the progress goals, risk tolerance, and resource input factors, and adjust the project plan in a timely manner to control progress risks.

[0026] For example, the Bayesian network model is a powerful probabilistic graphical model that effectively captures complex dependencies between variables. In project management, Bayesian networks can be used to model the impact of implicit factors such as team collaboration efficiency, technical debt accumulation, and unexpected technical difficulties on project progress. First, historical project data must be collected. This data may include past project completion times, team size, code quality metrics, and the frequency of technical difficulties. Using maximum likelihood estimation, the conditional probability distribution parameters of each node in the Bayesian network can be estimated. For example, it may be found that when team collaboration efficiency is high, the probability of project completion time is shortened is 70%, while when technical debt accumulation is severe, the probability of project delay may be as high as 80%. Next, Monte Carlo simulation is used to quantify the impact of implicit factors on project progress. Suppose 1,000 sets of implicit factor value combinations are randomly generated, each containing a different combination of team collaboration efficiency (high / medium / low), technical debt accumulation (severe / average / minor), and unexpected technical difficulties (frequent / occasional / rare). By inputting these combinations into the Bayesian network model, we can obtain the probability distribution of project completion on time, minor delays, or major delays in each scenario. Based on the information gain principle, we can calculate the information entropy of the conditional probability distribution of project progress and compare the changes in entropy after introducing each implicit factor. Suppose that introducing the team collaboration efficiency node reduces the information entropy by 0.5, while introducing the technical debt accumulation node reduces it by 0.8. This indicates that technical debt accumulation may have a more significant impact on project progress and is a key factor requiring special attention. For each identified key factor, its current status needs to be evaluated to assess its impact on project progress. If the probability of project delay under the current technical debt accumulation status exceeds a preset risk threshold (e.g., 30%), the system will trigger an alert, prompting project managers to take measures such as increasing code refactoring time or adjusting development strategies. During project implementation, continuous data collection and model updates are necessary. For example, weekly collection of team member work logs, code commit records, and requirement change documents can be performed. Through data preprocessing, this raw data can be converted into input for the Bayesian network model. Using the maximum a posteriori probability estimation method, the probability distribution of the implicit factor nodes can be dynamically updated by combining the prior distribution with new data. In this way, as the project progresses, the forecasting model will become increasingly accurate. If the impact of a hidden factor continues to exceed expectations, in-depth diagnosis is required. For example, if the duration of schedule delays caused by unexpected technical difficulties has reached 25% of the planned schedule, exceeding the preset 20% threshold, the system will prompt project managers to reassess the project plan. At this point, managers need to balance schedule goals, risk tolerance, and resource commitments. They may consider measures such as increasing human resources, adjusting the project scope, or extending the delivery deadline to control schedule risks. This approach not only enables timely identification and response to hidden risks in the project, but also continuously optimizes the forecasting model, improving the scientific nature and effectiveness of project management.This data- and probabilistic model-based approach can help project managers make more informed and objective decisions, thereby increasing the probability of timely project delivery.

[0027] S105. Dynamically update the module development time estimate based on the real-time progress data and the Bayesian network output, generate an adjusted progress plan, and feed the adjusted progress plan back to the resource allocation mechanism.

[0028] Real-time project progress data is obtained and converted into the input format of a pre-built Bayesian network model through data preprocessing. The processed data is input into the Bayesian network model, and development time estimates for each module are obtained through inference analysis. The module development time estimates output by the Bayesian network model are compared with the time estimates in the original schedule to calculate the estimate deviation. If the estimate deviation exceeds a preset threshold, the schedule adjustment process is triggered. Based on the module development time estimates, the milestone time nodes and planned times of key tasks in the original schedule are modified to generate an adjusted schedule. The impact of the adjusted schedule on the overall project progress is analyzed using the critical path method to determine the adjustment range and impact. The adjusted schedule is used as input and the resource allocation plan is optimized using a genetic algorithm. With the total project duration and resource utilization as optimization targets, the genetic algorithm uses selection, crossover, and mutation operations to obtain a resource allocation plan that meets the schedule constraints and has a resource utilization rate above the preset threshold. The optimized resource allocation plan is applied to project management, and resource allocation is dynamically adjusted through the project management system to ensure that the project is executed according to the adjusted schedule.

[0029] For example, taking a large e-commerce platform development project as an example, a project management system can collect data such as code submission frequency, bug fix time, and team communication records for each module. This raw data needs to be cleaned and converted to fit the pre-built Bayesian network model. For example, the daily number of code submissions can be converted into a percentage of development progress, and the bug fix time can be converted into a technical difficulty index. After inputting this processed data into the Bayesian network model, development time estimates for each module can be obtained. For example, for the payment module, the original development time was planned to be 10 days, but the model estimates it to be 12 days. This two-day discrepancy may be due to the model taking into account the influence of implicit factors such as team collaboration efficiency and technical debt. If this deviation exceeds the preset 15% threshold, the schedule adjustment process is triggered. Based on the magnitude of the deviation exceeding the threshold, a weighted average algorithm is used to calculate adjustments to milestone time nodes and key task schedules. Based on the calculated adjustments, the milestone time nodes and the planned start and finish times of key tasks for the corresponding modules in the original schedule are modified to generate an adjusted module schedule. The adjusted schedules for each module are then aggregated and the critical path method is used to determine the overall critical path for the project. This is used to align milestone time nodes across modules to form an adjusted overall project schedule. When adjusting the schedule, inter-module dependencies must be considered. The impact of the delay on other related modules must be considered during the adjustment process. For example, the order processing module, which is related to the payment module, may also need to be delayed. Using the critical path method, the impact of this adjustment on the overall project schedule can be analyzed. Assuming the payment module is on the critical path, a two-day delay will directly affect the project's final delivery date. It is then necessary to evaluate whether the delay can be offset by adjusting other tasks not on the critical path. After the schedule adjustment, the impact on resource requirements must also be analyzed. For example, an extended payment module development period may require developers to continue working beyond the originally scheduled end date. This may conflict with resource demands from other modules. To address this issue, a genetic algorithm can be used to optimize resource allocation. Specifically, a genetic algorithm encodes resource allocation plans, representing each possible allocation plan as an individual, and constructs an initial population. Based on two metrics, total project duration and resource utilization, a fitness function is constructed to evaluate the performance of each resource allocation plan. The fitness of individuals in the current population is evaluated, and a fitness value is calculated based on the fitness function. Higher fitness values ​​indicate better time and resource utilization performance for the resource allocation plan. Based on these fitness values, a roulette wheel selection operator is used to select a group of high-fitness individuals from the current population to serve as sires for the next generation. A crossover operation is performed on these selected sires, randomly selecting crossover points to swap portions of the coding segments of the two sires, generating new offspring individuals that inherit the high-quality genes of their sires.Mutation operations are performed on offspring individuals with a certain probability, randomly changing certain genes in their coding, introducing new gene combinations, increasing population diversity, and preventing the algorithm from prematurely converging to a local optimum. The resulting offspring individuals are added to the new generation population, and iterative optimization continues for multiple generations until a termination condition is met (such as reaching a preset number of iterations or fitness convergence). The optimal resource allocation solution corresponding to the individual with the highest fitness in the current population is output as the optimal allocation result. For example, the algorithm might recommend moving forward a user interface optimization task originally scheduled to begin after the payment module to take advantage of front-end developers temporarily idled due to payment module delays. This dynamic adjustment not only improves resource utilization but also partially offsets overall schedule delays caused by core module delays. In this way, dynamic optimization of project schedule and resource allocation is achieved. The advantage of this approach is that it can promptly respond to project changes and adjust management strategies based on real-time data, thereby improving project management flexibility and precision. This analysis helps project managers assess the impact of adjustments and develop appropriate mitigation strategies. This dynamic adjustment can better address project uncertainties and increase the probability of on-time completion. This data-driven project management approach not only improves the accuracy of estimates, but also helps project managers make more scientific decisions.

[0030] S106. If the deviation between the output of the progress prediction model and the actual situation exceeds a preset threshold, the model self-learning mechanism is triggered to retrain the progress prediction model and update the Bayesian network and adaptive filtering parameters.

[0031] The output result of the software development progress prediction model and the actual situation data within the corresponding time period are obtained, and the deviation value between the output result and the actual situation data is calculated; it is determined whether the deviation value exceeds a preset threshold value, and if so, the model self-learning mechanism is triggered; the actual situation data is used as training data, and the parameters of the progress prediction model are optimized and updated using the naive Bayes classification algorithm to obtain optimized model parameters; wherein, the parameters of the progress prediction model are optimized and updated using the naive Bayes classification algorithm, including: calculating the posterior probability under different parameter values, and selecting the parameter value with the largest posterior probability as the optimized model parameter; the input data of the progress prediction model are preprocessed using the Kalman filter algorithm to obtain preprocessed input data; wherein, the input data of the progress prediction model are preprocessed using the Kalman filter algorithm, including: establishing a state equation and an observation equation, estimating the true value of the input data, and removing noise and interference in the input data; the optimized model parameters and the preprocessed input data are applied to the progress prediction model to obtain an optimized progress prediction model; the optimized progress prediction model is used to predict new input data and output a prediction result.

[0032] For example, first, the output of the progress prediction model and actual data from the corresponding time period are required. For example, in a six-month e-commerce platform development project, the progress prediction model might estimate that the core payment module will take four weeks to complete, while it actually takes five weeks. In this case, a deviation of 25% is calculated. This deviation is compared with a preset threshold (such as 20%). If it exceeds the threshold, the model's self-learning mechanism is triggered. The core of this mechanism is to retrain the progress prediction model using actual data as new training data. The Naive Bayesian classification algorithm plays a key role in this process. Based on Bayes' theorem, the Naive Bayesian classification algorithm assumes independence between features. In the self-learning scenario, various project characteristics (such as team size, technical complexity, and frequency of requirement changes) are used as input, and the actual completion time is used as output. By calculating the posterior probabilities under different parameter values, the parameter values ​​with the highest probability are selected as the optimized model parameters. For example, if the probability of project delay is highest when the team size is 10, the technical complexity is high, and the frequency of requirement changes is weekly, the model will adjust the weights of these parameters accordingly. Furthermore, to improve data quality, the Kalman filter algorithm is introduced to preprocess the model's input data. The Kalman filter is a recursive estimation algorithm that effectively removes noise and interference from the data. In software development progress forecasting, noise can come from factors such as temporary overtime and unexpected technical issues. By establishing a state equation (e.g., an equation describing project progress changes) and an observation equation (e.g., describing actual observed progress data), the Kalman filter can estimate data that is closer to the actual situation. For example, suppose that in a certain week, due to temporary overtime, the project progress suddenly increases by 20%. The Kalman filter considers historical data and current observations to produce a more reasonable estimate, perhaps a 10% progress improvement. This prevents the model from being overly sensitive to short-term fluctuations and provides more stable predictions. Applying the updated naive Bayes classification model parameters and the Kalman filter parameters to the progress forecasting model yields an optimized model. The optimized model will significantly improve its prediction accuracy when faced with similar projects. For example, for the next similar payment module development task, the optimized model might predict completion time in 4.5 weeks, closer to the actual situation than the original 4 weeks. Through this continuous self-learning mechanism, the progress prediction model can adapt to dynamic changes in the project environment. For example, if the team introduces new development tools or methodologies, resulting in improved development efficiency, the model can capture this change through continuous learning and reflect it in future forecasts. This not only improves the management efficiency of individual projects but also provides a foundation for continuous improvement of the project management capabilities of the entire organization. Kalman filtering can remove noise from the data, improving the robustness of the optimized model.

[0033] The preferred embodiments of the present invention disclosed above are intended only to help illustrate the present invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the present invention to specific embodiments. Obviously, many modifications and variations are possible based on the contents of this specification. These embodiments are selected and described in detail in this specification to better explain the principles and practical applications of the present invention, thereby enabling those skilled in the art to better understand and utilize the present invention. The present invention is limited only by the claims and their full scope and equivalents.

Claims

1. A software development project progress forecasting and management method based on artificial intelligence, characterized in that: The method comprises: Obtain the project module dependency diagram, analyze the dependency strength and impact range between modules, and determine the weights of key modules and their dependent modules; Assign task priorities based on developer skill levels, combine technical complexity, build a progress prediction model, calculate the development time estimate for each module, and generate an initial progress plan; Monitor the development progress of key modules in real time. If any lag is detected, the resource allocation mechanism will be triggered to reassess task priorities and adjust developer allocation. Build a Bayesian network model, using hidden factors such as team collaboration efficiency, technical debt accumulation, and sudden technical difficulties as nodes, construct a probability relationship graph, and quantify the impact of hidden factors on progress; Based on real-time progress data and Bayesian network output, the module development time estimate is dynamically updated to generate an adjusted schedule, which is then fed back to the resource allocation mechanism. If the deviation between the progress prediction model output and the actual situation exceeds the preset threshold, the model self-learning mechanism is triggered to retrain the progress prediction model and update the Bayesian network and adaptive filtering parameters; The process of obtaining a project module dependency graph, analyzing the dependency strength and impact range between modules, and determining the weights of key modules and their dependent modules includes: The NetworkX library is used to calculate the strength coefficient of the dependencies between modules in the module dependency graph. The strength coefficient is determined by the number and weight of the dependencies. Sort the modules according to their strength coefficients and select the top 20% of the modules as the key modules of the project; For each key module, the depth-first search algorithm in the NetworkX library is used to identify its directly and indirectly dependent upstream modules, and the set of dependent modules of the key module is obtained; Perform K-means clustering analysis on the dependent module sets of key modules and divide them into different dependent module groups based on the similarity between modules; The analytic hierarchy process is used to construct a judgment matrix to calculate the dependency contribution weight of each module in the group to the key module; Multiply the strength coefficient of the key module by the contribution weight of its dependent module group to obtain the comprehensive importance index of the key module; The Bayesian network model uses hidden factors such as team collaboration efficiency, technical debt accumulation, and sudden technical difficulties as nodes to construct a probability relationship graph and quantify the impact of hidden factors on progress, including: Obtain historical project data and use the maximum likelihood estimation method to estimate the conditional probability distribution parameters of each node in the Bayesian network model, thereby obtaining the probability distribution of team collaboration efficiency, technical debt accumulation, and hidden factors of sudden technical problems. Using the Monte Carlo simulation method, we randomly generate multiple combinations of implicit factors, input them into the Bayesian network model, calculate the conditional probability distribution of project progress under each combination, and quantify the distribution of the impact of implicit factors on project progress. Based on the information gain principle, the information entropy of the conditional probability distribution of the project progress is calculated. By comparing the changes in information entropy after introducing each implicit factor node, the significance of the impact of each implicit factor on the project progress is judged, and the key factors with the greatest impact on the progress are identified.

2. The method according to claim 1, characterized in that The step of obtaining a project module dependency graph, analyzing the dependency strength and impact range between modules, and determining the weights of key modules and their dependent modules includes: Obtain dependency data of all modules in the project, preprocess and clean the dependency data, and build a module dependency graph; Based on the Matplotlib library, a global weight distribution diagram of the project module dependencies is drawn. The size of the node in the weight distribution diagram represents the comprehensive importance of the module, and the thickness of the edge represents the weight of the dependency. Through the Dijkstra shortest path algorithm, the critical paths and dependency chains whose overall impact on the project is greater than the preset threshold are identified in the weight distribution graph.

3. The method according to claim 1, characterized in that The aforementioned method assigns task priorities based on developer skill levels, combines technical complexity, calculates the development time estimate for each module, and generates an initial schedule, including: Obtain the technical requirements of all modules of the project, conduct complexity assessment on the modules, quantify the assessment results into complexity levels or weights, and obtain the module complexity matrix; Obtain developer skill level and experience data, evaluate each developer's skills, and obtain a developer skill matrix; Based on the module complexity matrix and developer skill matrix, the Hungarian algorithm is used to optimally match modules with developers. The goal of matching is to match the developer's skills with the module's complexity while meeting the module's technical requirements. Use the COCOMO model to build a progress prediction model to estimate the development workload and time of each module; The basic formula of the COCOMO model is: PM = a(KLOC)^bEAF, where PM is man-months, KLOC is thousands of lines of code, a and b are empirical parameters, and EAF is an adjustment factor; Select parameter values ​​based on the project's scale, complexity, and personnel quality, and substitute them into the formula for estimation to obtain the estimated development workload and time for each module; Using the analytic hierarchy process, combined with business value, technical risk, and dependency factors, the module priorities are evaluated to obtain the priority weight of each module; Generate the initial version of the project schedule using the critical path method based on module priorities and estimated development time; Treat modules as activities in the AON network diagram, and the dependencies between modules as the order of activities. Use forward recursion and reverse recursion to calculate the earliest start time, latest start time, earliest end time, and latest end time of each activity to find the critical path and determine the key activities and milestone nodes of the project. Determine whether there is a resource conflict based on the estimated workload of each module and the developer's available time; If there is a resource conflict, it can be eliminated by delaying the start time of non-critical activities and adjusting task allocation measures to obtain an executable project schedule.

4. The method according to claim 1, characterized in that The real-time monitoring of the development progress of key modules will trigger the resource allocation mechanism if any lag is found, re-evaluate task priorities, and adjust developer allocation, including: A1. Obtain the preset development progress threshold and actual development progress data of the key modules, and compare the preset development progress threshold with the actual development progress data; A2. If the actual development progress data is lower than the preset development progress threshold, the resource allocation mechanism is triggered; A3. Obtain task feature data and developer skill data from historical projects, and build a support vector machine model based on the task feature data and developer skill data. A4. Obtain the task features of the current project, input the task features of the current project into the support vector machine model, and use the support vector machine model to predict the priority of each task; A5. Obtain developer skill data and work saturation data. Based on the task priority prediction results, developer skill data, and work saturation data, use the Hungarian algorithm to calculate a staffing plan. A6. Write the personnel deployment plan into the project management system database, triggering the project management system to automatically generate an adjustment notice and update the project schedule. A7. Continuously monitor the development progress of key modules, regularly obtain actual progress data from the project management system, and determine whether the actual progress data is still below the preset development progress threshold; A8. If the actual progress data is still lower than the preset development progress threshold, return to step A2 and re-trigger resource allocation until the actual progress data is synchronized with the preset development progress threshold.

5. The method according to claim 1, characterized in that The Bayesian network model uses hidden factors such as team collaboration efficiency, technical debt accumulation, and sudden technical difficulties as nodes to construct a probability relationship diagram and quantify the impact of hidden factors on progress, including: For key hidden factors, the impact of their current status on the project progress is assessed, and the probability of progress delay under the current status is compared with the preset delay risk threshold. If the threshold is exceeded, an early warning is triggered, prompting project managers to take countermeasures; During project implementation, we continuously collect data on project progress, human resources input, and demand change tracking. We use data preprocessing techniques to convert this data into input for the Bayesian network model. Using the maximum a posteriori probability estimation method, combined with the prior distribution and newly collected data, we dynamically update the probability distribution of latent factor nodes, continuously optimize the Bayesian network model, and improve the accuracy of project progress predictions. If the impact of a hidden factor on the project progress continues to exceed expectations, the duration of the progress delay caused by the factor will be diagnosed and quantified, and the proportion of the delayed time to the planned progress will be evaluated. If it exceeds the preset threshold, the project manager will be prompted to evaluate the necessity of adjusting the project plan, weigh the progress goals, risk tolerance and resource input factors, and adjust the project plan in a timely manner to control progress risks.

6. The method according to claim 1, characterized in that The method of dynamically updating module development time estimates based on real-time progress data and Bayesian network output, generating an adjusted schedule, and feeding the adjusted schedule back to the resource allocation mechanism includes: Obtain real-time project progress data and convert it into the input format of the pre-built Bayesian network model through data preprocessing; The processed data is input into the Bayesian network model, and the development time estimation results of each module are obtained through reasoning analysis; Compare the module development time estimate output by the Bayesian network model with the time estimate in the original schedule and calculate the estimate deviation; If the estimation deviation exceeds the preset threshold, the schedule adjustment process is triggered. Based on the module development time estimation results, the milestone time nodes and the planned time of key tasks in the original schedule are modified to generate an adjusted schedule. Analyze the impact of the adjusted schedule on the overall project progress through the critical path method to determine the adjustment range and impact scope of the schedule; The adjusted schedule is used as input to optimize the resource allocation plan through genetic algorithms. The total project duration and resource utilization are used as optimization targets. Through the selection, crossover and mutation operations of the genetic algorithm, a resource allocation plan that meets the schedule constraints and has a resource utilization rate higher than the preset threshold is obtained. Apply the optimized resource allocation plan to project management, dynamically adjust resource allocation through the project management system, and ensure that the project is executed according to the adjusted schedule.

7. The method according to claim 1, characterized in that If the deviation between the progress prediction model output and the actual situation exceeds a preset threshold, the model self-learning mechanism is triggered to retrain the progress prediction model and update the Bayesian network and adaptive filtering parameters, including: Obtain the output results of the software development progress prediction model and the actual data within the corresponding time period, and calculate the deviation value between the output results and the actual data; Determine whether the deviation value exceeds the preset threshold. If so, trigger the model self-learning mechanism; Using actual data as training data, the Naive Bayesian classification algorithm is used to optimize and update the parameters of the progress prediction model to obtain the optimized model parameters; The naive Bayesian classification algorithm is used to optimize and update the parameters of the progress prediction model, including: calculating the posterior probability under different parameter values, and selecting the parameter value with the largest posterior probability as the optimized model parameter; Preprocessing the input data of the progress prediction model through the Kalman filter algorithm to obtain preprocessed input data; The Kalman filter algorithm is used to pre-process the input data of the progress prediction model, including: establishing state equations and observation equations, estimating the true value of the input data, and removing noise and interference in the input data; Applying the optimized model parameters and the preprocessed input data to the progress prediction model to obtain an optimized progress prediction model; Use the optimized progress prediction model to predict new input data and output the prediction results.

Images