Software research and development process management method and system based on deep learning

Abstract

The invention discloses a software research and development process management method and system based on deep learning, and the method comprises the steps: taking a development team member as a node through a GNN graph neural network, designing an edge weight based on historical cooperation frequency and knowledge similarity, constructing a space graph, adjusting an expansion rate through expansion causal convolution in a time convolution module, capturing long-period dependence, and carrying out the deep learning. A task coupling constraint item is added into the loss function, and an MST-GCN deep learning prediction model is established; and inputting the aligned feature vector into an MST-GCN deep learning prediction model for prediction, modeling a software research and development process into an MDP Markov decision process based on RL reinforcement learning according to a research and development progress deviation index, and generating a research and development resource allocation strategy. Resources are inclined to key tasks, the resource utilization efficiency is improved, meanwhile, it is guaranteed that software research and development projects are propelled according to plans, and the research and development efficiency is improved.

Description

Technical Field

[0001] This invention relates to the field of software development technology, and in particular to a method and system for managing the software development process based on deep learning. Background Technology

[0002] Research and development process management faces numerous challenges. Existing methods often rely on empirical estimations or simple statistical models, making it difficult to characterize the dynamic relationships within the research and development process. Traditional Gantt chart methods cannot reflect the impact of the intensity of collaboration and the complementarity of knowledge among team members on progress in real time, while time series models (ARIMA, LSTM) suffer from gradient vanishing or information dilution problems when dealing with long-term dependencies, and do not fully consider the coupling constraints between tasks, including module interface dependencies and resource competition, resulting in low prediction accuracy and difficulty in supporting effective process intervention. Summary of the Invention

[0003] The purpose of this invention is to solve the above problems by designing a software development process management method and system based on deep learning.

[0004] To achieve the above objectives, the technical solution of the present invention further includes the following steps in the above-mentioned deep learning-based software development process management method: Collect development behavior data, quality indicator data, and requirement parameter data, and use the time-series sliding window algorithm to eliminate the time difference of multi-source data to obtain aligned feature vectors; By using GNN graph neural networks with development team members as nodes, edge weights are designed based on historical collaboration frequency and knowledge similarity to construct a spatial graph. Dilated causal convolution in the temporal convolution module is used to adjust the dilation rate to capture long-term dependencies. Task coupling constraint terms are added to the loss function to establish the MST-GCN deep learning prediction model. The aligned feature vector is input into the MST-GCN deep learning prediction model for prediction, and the R&D progress deviation index is output. Based on the aforementioned R&D progress deviation index, the software R&D process is modeled as an MDP Markov decision process using RL reinforcement learning, generating an R&D resource allocation strategy.

[0005] Furthermore, in the aforementioned deep learning-based software development process management method, the collection of development behavior data, quality indicator data, and requirement parameter data, and the use of a time-series sliding window algorithm to eliminate time differences between multi-source data to obtain an aligned feature vector, includes: Collect development behavior data, quality indicator data, and requirement parameter data. Development behavior data should include at least code submission frequency, code modification volume, and code refactoring frequency. Quality indicator data should include at least code defect rate, technical debt index, test pass rate, and defect density. Requirement parameter data should include at least requirement change frequency, requirement change priority, and complexity. The window size for the time-series sliding window algorithm is determined based on the time granularity of the data and business requirements. For missing time point data within the window, linear interpolation or polynomial interpolation methods are used to supplement it; Data of different magnitudes are transformed to the same magnitude and normalized to the interval [0, 1] to obtain aligned feature vectors.

[0006] Furthermore, in the aforementioned deep learning-based software development process management method, the step of constructing a spatial graph using a GNN graph neural network with development team members as nodes, designing edge weights based on historical collaboration frequency and knowledge similarity, adjusting the dilation rate using dilated causal convolution in the temporal convolution module to capture long-term dependencies, and adding a task coupling constraint term to the loss function to establish an MST-GCN deep learning prediction model includes: Historical collaboration frequency is calculated by the number of projects and tasks that team members participate in together. Determine the skill tags of the members to be compared, represent each member's skills in the form of tags, calculate the overlap of skill tags between two members, and obtain the knowledge similarity. Using a graph neural network (GNN), a spatial graph is constructed with development team members as nodes and edge weights designed based on historical collaboration frequency and knowledge similarity.

[0007] Furthermore, in the aforementioned deep learning-based software development process management method, the step of constructing a spatial graph using a GNN graph neural network with development team members as nodes, designing edge weights based on historical collaboration frequency and knowledge similarity, adjusting the dilation rate using dilated causal convolution in the temporal convolution module to capture long-term dependencies, and adding a task coupling constraint term to the loss function to establish an MST-GCN deep learning prediction model further includes: The dependency in the R&D process is reflected in the use of a small inflation rate in the near term, so that the convolution covers a time range of 1-2 weeks; Long-cycle projects with dependencies spanning months and quarters employ a large inflation rate to enable convolution to cover a time range of 1-3 months, capturing the correlation patterns over long periods.

[0008] Furthermore, in the aforementioned deep learning-based software development process management method, the step of constructing a spatial graph using a GNN graph neural network with development team members as nodes, designing edge weights based on historical collaboration frequency and knowledge similarity, adjusting the dilation rate using dilated causal convolution in the temporal convolution module to capture long-term dependencies, and adding a task coupling constraint term to the loss function to establish an MST-GCN deep learning prediction model further includes: Determine the type of task coupling, including at least dependency coupling, resource coupling, and target coupling. Set the weight of the constraint terms according to the coupling strength, with high weight for strongly coupled tasks and low weight for weakly coupled tasks. The loss function considers prediction error and task coupling constraints, and the model parameters are optimized through backpropagation to establish the MST-GCN deep learning prediction model.

[0009] Furthermore, in the aforementioned deep learning-based software development process management method, the step of inputting the aligned feature vector into the MST-GCN deep learning prediction model for prediction and outputting a development progress deviation index includes: The alignment feature vector is input into the MST-GCN deep learning prediction model for prediction, and the impact of the collaborative relationship between members on the current R&D task is analyzed based on the constructed spatial graph. The temporal convolution module performs operations on the time-series data in the vector, captures long-term dependencies, and calculates the deviation index between the current R&D progress and the planned progress.

[0010] Furthermore, in the aforementioned deep learning-based software development process management method, the step of modeling the software development process as an MDP Markov decision process based on RL reinforcement learning, according to the development progress deviation index, and generating a development resource allocation strategy, includes: The state, action, and reward in the MDP Markov decision process are determined, and the optimal resource allocation strategy is learned through interaction with the R&D process based on RL reinforcement learning.

[0011] Furthermore, in a deep learning-based software development process management system, the software development process management system includes the following modules: The feature vector extraction module is used to collect development behavior data, quality indicator data, and requirement parameter data. It uses a time-series sliding window algorithm to eliminate the time difference of multi-source data and obtain aligned feature vectors. The prediction model building module is used to construct a spatial graph by designing edge weights based on historical collaboration frequency and knowledge similarity using a GNN graph neural network with development team members as nodes. It uses dilated causal convolution in the temporal convolution module to adjust the dilation rate to capture long-term dependencies and adds a task coupling constraint term to the loss function to build the MST-GCN deep learning prediction model. The deviation index prediction module is used to input the alignment feature vector into the MST-GCN deep learning prediction model for prediction and output the R&D progress deviation index. The R&D resource adjustment module is used to model the software R&D process as an MDP Markov decision process based on the R&D progress deviation index and RL reinforcement learning to generate an R&D resource allocation strategy.

[0012] Furthermore, in a deep learning-based software development process management system, the deviation index prediction module includes the following sub-modules: The task analysis submodule is used to input the alignment feature vector into the MST-GCN deep learning prediction model for prediction, and to analyze the impact of the collaborative relationship between members on the current R&D task based on the constructed spatial graph. The progress calculation submodule is used by the temporal convolution module to perform operations on the time-series data in the vector, capture long-term dependencies, and calculate the deviation index between the current R&D progress and the planned progress.

[0013] Furthermore, in a deep learning-based software development process management system, the development resource adjustment module includes the following sub-modules: The resource allocation submodule is used to determine the state, action, and reward in the MDP Markov decision process. Based on RL reinforcement learning, it learns the optimal resource allocation strategy through interaction with the R&D process.

[0014] Its beneficial effects are as follows: 1. It solves the problem of temporal inconsistency in traditional data integration, providing a high-quality and unified data foundation for subsequent model prediction. 2. Constructing a spatial graph with development team members as nodes effectively captures the spatial relationships of team collaboration; the dilated causal convolution in the temporal convolution module can adjust the dilation rate to accurately capture long-term dependencies; the addition of task coupling constraints to the loss function allows the model to take into account the relationships between tasks. These designs significantly improve the model's predictive ability, and the output R&D progress deviation index accurately reflects the difference between the actual progress and the plan, providing a reliable basis for timely problem detection. 3. Through continuous interaction with the R&D environment, reinforcement learning continuously optimizes strategies and can dynamically adjust resource allocation based on the R&D progress deviation index, tilting resources towards key tasks, improving resource utilization efficiency, effectively alleviating the R&D progress deviation problem, ensuring that software development projects proceed as planned, and improving R&D efficiency. Attached Figure Description

[0015] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention.

[0016] Figure 1This is a schematic diagram of the first embodiment of a deep learning-based software development process management method according to the present invention; Figure 2 This is a schematic diagram of a second embodiment of a deep learning-based software development process management method according to the present invention. Figure 3 This is a schematic diagram of the first embodiment of a deep learning-based software development process management system according to the present invention. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0018] Those skilled in the art will understand that, unless specifically stated otherwise, the singular forms "one," "an," and "this" used herein may also include the plural forms. It should be further understood that the terminology used in this specification includes the presence of features, integers, steps, operations, elements, and / or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0019] The present invention will now be described in detail with reference to the accompanying drawings. Figure 1 As shown, a deep learning-based software development process management method includes the following steps: Step 101: Collect development behavior data, quality indicator data, and requirement parameter data. Use the time-series sliding window algorithm to eliminate the time difference of multi-source data and obtain the aligned feature vector. Specifically, in this embodiment, development behavior data, quality indicator data, and requirement parameter data are collected. Development behavior data includes at least code submission frequency, code modification volume, and code refactoring frequency; quality indicator data includes at least code defect rate, technical debt index, test pass rate, and defect density; and requirement parameter data includes at least requirement change frequency, requirement change priority, and complexity. The window size for the time-series sliding window algorithm is determined based on the time granularity of the data and business requirements. For missing time point data within the window, linear interpolation or polynomial interpolation methods are used to supplement it; Data of different magnitudes are transformed to the same magnitude and normalized to the interval [0, 1] to obtain aligned feature vectors.

[0020] Specifically, (a) Data collection content and methods; During the data collection phase, it is necessary to comprehensively collect development behavior data, quality indicator data, and requirement parameter data. The specific content and collection methods are as follows: Development behavior data; Code commit frequency: refers to the number of times each developer commits code per unit of time, which can be automatically recorded and collected by version control tools (Git).

[0021] Code modification count: This refers to the number of lines of code modified in each commit, extracted from version control tools such as Git.

[0022] Team communication records: including meeting minutes, instant messaging messages, etc., can be collected from the communication module of project management tools (Jira) and enterprise instant messaging software (WeChat Work, DingTalk).

[0023] Quality indicator data; Defect rate: The ratio of defective lines of code to total lines of code. It is calculated by detecting defective code using a code review tool (SonarQube) and combining it with the total lines of code from the version control tool.

[0024] Test pass rate: The ratio of the number of functional modules that pass the test to the total number of functional modules. The test results are recorded by the testing tool (Selenium) and then statistically calculated.

[0025] Software operational stability: This is measured by the software's trouble-free operating time, which can be monitored and recorded in real time using a monitoring tool (Prometheus).

[0026] Demand parameter data; Number of requirement changes: The number of times requirements have changed during the project. This is calculated by extracting requirement change records from the requirement management tool (Confluence).

[0027] Requirement Priority: A level of importance assigned to requirements, determined by priority tags set in the requirement management tool.

[0028] Requirement complexity: The level of difficulty is assessed based on the functionalities and technical challenges involved in the requirement. This can be collected through a complexity assessment form filled out by the requirement analyst in the requirement management tool.

[0029] (ii) Timing-based sliding window algorithm to eliminate time difference; Algorithm principle: By setting a sliding window, development behavior data, quality indicator data, and requirement parameter data collected at different times are included in the window. After processing, these data are made consistent in time, thereby eliminating time difference.

[0030] Window size determination: Determined based on the time granularity of the data and business needs. For example, if the data is collected daily and the business requires analysis of data trends within a week, the window size can be set to 7 days.

[0031] Specific processing steps: Data interpolation: For missing time points within a window, linear or polynomial interpolation methods are used to supplement the data, making the data continuous in the time series.

[0032] Data normalization: Converting data of different magnitudes to the same magnitude, such as normalizing each data item to the [0, 1] interval, to avoid the impact of data magnitude differences on subsequent processing.

[0033] Feature alignment: After the above processing, the multi-source data in the window are aligned in time. The features of these data are extracted to form an aligned feature vector.

[0034] Step 102: Using the GNN graph neural network with development team members as nodes, design edge weights based on historical collaboration frequency and knowledge similarity to construct a spatial graph. Use dilated causal convolution in the temporal convolution module to adjust the dilation rate to capture long-term dependencies, and add a task coupling constraint term to the loss function to establish the MST-GCN deep learning prediction model. Specifically, in this embodiment, the historical collaboration frequency is calculated by the number of projects that team members jointly participate in and the number of tasks they jointly complete; Determine the skill tags of the members to be compared, represent each member's skills in the form of tags, calculate the overlap of skill tags between two members, and obtain the knowledge similarity. Using a graph neural network (GNN), a spatial graph is constructed with development team members as nodes and edge weights designed based on historical collaboration frequency and knowledge similarity.

[0035] The dependency in the R&D process is reflected in the use of a small inflation rate in the near term, so that the convolution covers a time range of 1-2 weeks; Long-cycle projects with dependencies spanning months and quarters employ a large inflation rate to enable convolution to cover a time range of 1-3 months, capturing the correlation patterns over long periods.

[0036] Determine the type of task coupling, including at least dependency coupling, resource coupling, and target coupling. Set the weight of the constraint terms according to the coupling strength, with high weight for strongly coupled tasks and low weight for weakly coupled tasks. The loss function considers prediction error and task coupling constraints, and the model parameters are optimized through backpropagation to establish the MST-GCN deep learning prediction model.

[0037] Specifically, I. Specific operations for constructing a spatial map; The spatial diagram uses development team members as core nodes. The construction process requires accurately capturing the collaborative relationships between members. The specific steps are as follows: First, determine the node information. Each node corresponds to a team member, and the node attributes include the member's skill tags (backend development, UI design, testing, etc.), historical project participation records, and the task modules currently being managed. This information is integrated and obtained from the project management system and human resources files.

[0038] Secondly, the calculation method for edge weights is designed. Edge weights are determined by both historical collaboration frequency and knowledge similarity: Historical collaboration frequency is calculated using interaction data among members, including the number of times they participated in tasks together (having jointly been responsible for 5 tasks in the past 3 projects), collaboration duration (a total of 120 hours of joint work), and code collaboration frequency (the number of times they jointly modified the same module of code). These data are combined to derive a value reflecting the degree of collaboration.

[0039] Knowledge similarity is determined by comparing members' skill tags. For example, if member A's skill tags are Python development and database optimization, and member B's skill tags are Python development and front-end frameworks, then the two overlap in Python development. Knowledge similarity is calculated based on the percentage of overlapping tags; the higher the overlap, the greater the similarity value.

[0040] Finally, the historical collaboration frequency and knowledge similarity are combined in a certain ratio (6:4) to obtain the edge weight. The higher the weight, the more solid the collaboration foundation of the two members and the stronger the knowledge complementarity or consistency. In this way, a spatial graph that can truly reflect the team collaboration network is constructed.

[0041] II. The operating mechanism of the temporal convolution module; The temporal convolution module employs dilated causal convolution to accurately capture long-cycle dependencies in the R&D process. Its operating mechanism is as follows: The core of causal convolution is to ensure that the model makes predictions based solely on past information, avoiding the use of future data to interfere with the results. For example, when predicting the R&D progress on the 10th day, only the data from the previous 9 days is used, without involving information after the 10th day, which conforms to the time logic of the R&D process.

[0042] The adjustment of the inflation rate needs to be combined with the cycle characteristics of the R&D project. For short-cycle projects (completed within 3 months), the dependencies in the R&D process are mostly reflected in the near future, so a smaller inflation rate (2-4) can be used to allow the convolution to cover a time range of about 1-2 weeks. For long-cycle projects (more than 1 year), there may be dependencies that span months or even quarters (the results of requirement review affect the development of the following 3 months), so a larger inflation rate (8-16) should be used to allow the convolution to cover a time range of 1-3 months, thereby capturing the correlation patterns of the long cycle.

[0043] In practice, we first statistically analyze typical periodic distributions based on historical project data, set an initial expansion rate, and then adjust it through validation set testing to ensure that the model can accurately identify dependencies in different periods.

[0044] III. Setting the task coupling constraint term in the loss function; The task coupling constraint is added to make the model pay attention to the relationships between tasks, and it is set as follows: First, clarify the types of task coupling, which mainly include: Dependency coupling: If task A is not completed, task B cannot start (front-end integration testing can only be carried out after the interface development is completed).

[0045] Resource coupling: If task C and task D share the same senior developer, their progress will affect each other.

[0046] Target coupling: For example, tasks E and F need to be completed synchronously to meet version release requirements; Then, the weights of the constraint terms are set according to the coupling strength. Strongly coupled tasks (critical path tasks in dependency coupling) have higher weights, while weakly coupled tasks (non-core tasks in target coupling) have lower weights.

[0047] When the model's prediction ignores these coupling relationships (predicting that task B is progressing normally but not considering the impact of task A's lag), the value of the loss function will increase significantly. This penalty mechanism encourages the model to learn the correlation patterns between tasks during training, thereby improving the accuracy of prediction.

[0048] IV. Overall Model Collaboration Process; The operation of the MST-GCN model follows the logic of space-time-constraint coordination: First, the aligned feature vectors are input into the spatial graph module, and the features of each member node are calculated through GNN to integrate the spatial information of team collaboration. The spatial features are then input into the temporal convolution module, which uses dilated causal convolution to process the temporal data and capture the dependencies between different periods.

[0049] During model training, the loss function considers both prediction error and task coupling constraints. The model parameters are continuously optimized through backpropagation, ultimately resulting in a model that can accurately predict the deviation of the R&D progress from the index.

[0050] Step 103: Input the aligned feature vector into the MST-GCN deep learning prediction model for prediction, and output the R&D progress deviation index; Specifically, in this embodiment, the aligned feature vector is input into the MST-GCN deep learning prediction model for prediction, and the impact of the collaborative relationship between members on the current R&D task is analyzed based on the constructed spatial graph. The temporal convolution module performs operations on the time-series data in the vector, captures long-term dependencies, and calculates the deviation index between the current R&D progress and the planned progress.

[0051] Specifically, (a) Alignment feature vector input process; Before inputting the aligned feature vectors into the MST-GCN deep learning prediction model, data preprocessing and validation are required. Check the vectors for outliers (code defect rates that significantly exceed the normal range) and missing values ​​(test pass rates for a certain period that are not recorded). If any are found, handle them appropriately, such as filling missing values ​​with the historical average of the metric or truncating or smoothing outliers.

[0052] After confirming the data is correct, it is organized according to the model's required format, arranging the feature values ​​corresponding to the development behavior data, quality indicator data, and requirement parameter data in an ordered manner to form a fixed-dimensional vector. Subsequently, the aligned feature vector is input through the model's data interface. During the input process, the integrity of data transmission is monitored in real time to ensure that every data item in the vector is accurately transmitted to the model.

[0053] (ii) Internal predictive operation of the model; After receiving the aligned feature vectors, the MST-GCN model first processes the team member collaboration-related data in the vectors using the spatial graph module. Based on the constructed spatial graph, it analyzes the impact of the collaboration relationships between members on the current R&D task. For example, it determines whether the cooperation between two members with high collaboration weights in a certain task will speed up the task progress, or whether the pairing of members with low knowledge similarity may lead to increased communication costs and slow down the progress.

[0054] Next, the temporal convolution module performs operations on the temporal data in the vector to capture long-term dependencies. For example, by combining the trend of code commit frequency changes over the past few months, it analyzes whether the current development pace conforms to historical patterns and the potential impact of previous requirement changes on the current development progress.

[0055] Finally, by combining the processing results of the spatial graph module and the temporal convolution module, and the experience of task coupling relationships learned during the training of the loss function, the deviation between the current R&D progress and the planned progress is calculated.

[0056] (III) Interpretation of the R&D progress deviation index; The output R&D progress deviation index is a comprehensive quantitative indicator, typically set between 0 and 1. When the index is 0, it indicates that the actual R&D progress is completely consistent with the planned progress, and all tasks are proceeding as planned without any delays or overruns.

[0057] When the index is between 0 and 0.3, it is considered a slight deviation, indicating that there are some minor fluctuations in the R&D process, such as the completion time of individual tasks being 1-2 days later than planned. However, the overall progress is not seriously affected, and it can be brought back to normal by fine-tuning resources.

[0058] When the index is between 0.3 and 0.7, it is considered a moderate deviation, which means that some key tasks are significantly behind schedule. For example, the development progress of core modules is more than a week behind schedule, which may have a certain impact on the subsequent testing and release process. It is necessary to pay close attention and take targeted measures.

[0059] When the index exceeds 0.7, it is considered a serious deviation, indicating a significant gap between the R&D progress and the plan. This may result in issues such as multiple tasks being stalled or numerous changes in requirements. If adjustments are not made in time, it could lead to project delays.

[0060] Step 104: Based on the R&D progress deviation index, model the software R&D process as an MDP Markov decision process using RL reinforcement learning to generate an R&D resource allocation strategy. Specifically, in this embodiment, the states, actions, and rewards in the MDP Markov decision-making process are determined, and the optimal resource allocation strategy is learned through interaction with the R&D process based on RL reinforcement learning.

[0061] Specifically, (a) Modeling of Markov Decision Processes (MDPs); When modeling the software development process as an MDP (Markov Decision Process), the following key elements should be identified: Status: Includes the current R&D progress deviation index, available R&D resources (remaining number of developers, number of devices, time period, etc.), a list of ongoing tasks and the current status of each task (in progress, pending start, paused).

[0062] Actions: These cover various ways of allocating and adjusting R&D resources, such as increasing the number of developers for a delayed task (from 2 to 4), allocating idle equipment to support bottleneck tasks, lowering the priority of non-core tasks to concentrate resources on tackling key tasks, and extending the R&D time for a certain stage.

[0063] Rewards: These are determined based on the change in the R&D progress deviation index after an action is taken. If the index decreases (from 0.5 to 0.3) after an action is taken, it indicates that resource allocation is effective, and a positive reward is given; if the index increases (from 0.4 to 0.6), a negative reward is given, and the size of the reward is proportional to the magnitude of the index change.

[0064] (ii) The process of generating policies through reinforcement learning in RL; Reinforcement learning (RL) learns optimal resource allocation strategies by continuously interacting with the development process environment. In the initial stage, the AI ​​randomly tries various resource allocation actions, such as randomly adding one developer to a task, and then observes the impact of this action on the deviation index of the development progress, recording the corresponding reward.

[0065] (III) Application of R&D resource allocation strategies; The generated R&D resource allocation strategy will be presented in the form of specific operational suggestions, such as increasing the number of developers for task A from 3 to 5, allocating equipment B to support task C, and reducing the priority of task D from high to medium.

[0066] Project managers evaluate and implement these strategies based on the actual situation. During implementation, changes in the deviation index of the R&D progress are monitored in real time. If the index continues to decrease, it indicates that the strategy is effective; if the index does not change as expected, the new status is fed back to the RL reinforcement learning model, allowing the model to further optimize the strategy.

[0067] Its beneficial effects are as follows: 1. It solves the problem of temporal inconsistency in traditional data integration, providing a high-quality and unified data foundation for subsequent model prediction. 2. Constructing a spatial graph with development team members as nodes effectively captures the spatial relationships of team collaboration; the dilated causal convolution in the temporal convolution module can adjust the dilation rate to accurately capture long-term dependencies; the addition of task coupling constraints to the loss function allows the model to take into account the relationships between tasks. These designs significantly improve the model's predictive ability, and the output R&D progress deviation index accurately reflects the difference between the actual progress and the plan, providing a reliable basis for timely problem detection. 3. Through continuous interaction with the R&D environment, reinforcement learning continuously optimizes strategies and can dynamically adjust resource allocation based on the R&D progress deviation index, tilting resources towards key tasks, improving resource utilization efficiency, effectively alleviating the R&D progress deviation problem, ensuring that software development projects proceed as planned, and improving R&D efficiency.

[0068] Please see Figure 2In a deep learning-based software development process management method, a spatial graph is constructed using a graph neural network (GNN) with development team members as nodes. Edge weights are designed based on historical collaboration frequency and knowledge similarity. Dilated causal convolution in the temporal convolution module is used to adjust the dilation rate and capture long-term dependencies. A task coupling constraint term is added to the loss function. The MST-GCN deep learning prediction model is established through the following steps: Step 201: Calculate the historical collaboration frequency by the number of projects team members jointly participated in and the number of tasks they jointly completed; Step 202: Determine the skill tags of the members to be compared. Represent each member's skills in the form of tags, calculate the overlap of skill tags between two members, and obtain the knowledge similarity. Step 203: Using a GNN graph neural network, with development team members as nodes, design edge weights based on historical collaboration frequency and knowledge similarity to construct a spatial graph.

[0069] Specifically, (a) Spatial map construction; Using a graph neural network (GNN), a spatial graph is constructed with development team members as nodes and edge weights designed based on historical collaboration frequency and knowledge similarity.

[0070] Historical collaboration frequency calculation: It is calculated by the number of projects that team members jointly participate in and the number of tasks that they jointly complete. The formula is: Historical collaboration frequency = (Number of projects jointly participated in × Project weight + Number of tasks jointly completed × Task weight) / (Total number of projects participated in + Total number of tasks completed). The project weight and task weight are set according to their importance, such as a project weight of 0.6 and a task weight of 0.4.

[0071] Knowledge similarity measurement: This is determined by comparing members' skill tags. Each member's skills are represented by tags, such as Java programming and database design. The overlap of skill tags between two members is calculated. The higher the overlap, the greater the knowledge similarity. The formula is: Knowledge similarity = Number of overlapping skill tags / Total number of skill tags.

[0072] Edge weight determination: The edge weight is obtained by weighting the historical collaboration frequency and knowledge similarity, such as edge weight = historical collaboration frequency × 0.5 + knowledge similarity × 0.5.

[0073] (II) Design of the temporal convolution module; The temporal convolution module employs dilated causal convolution, adjusting the dilation rate based on the time span and periodic characteristics of the data to capture long-period dependencies.

[0074] Inflation rate adjustment criteria: If the data spans a large time period and exhibits obvious periodic characteristics, such as monthly data with a quarterly cycle, the inflation rate can be appropriately increased; conversely, if the time span is small and the periodic characteristics are not obvious, the inflation rate can be decreased. For example, for annual periodic data, the inflation rate can be set to 12 (assuming a monthly time granularity).

[0075] Causal convolution characteristics: ensures that convolution operations only depend on past information and do not involve future information, conforming to the causal relationship of time series and avoiding information leakage.

[0076] (III) Loss Function Design; Add a task coupling constraint term to the loss function to improve the model's prediction accuracy; The meaning of task coupling constraint: Consider the relationship between different tasks, such as the sequential dependency relationship of tasks (if task A is not completed, task B cannot start) and the resource sharing relationship (task A and task B share a certain development tool).

[0077] Constraint calculation: Weights are set based on the degree of dependency and resource sharing between tasks. If the two tasks are highly dependent or share resources, the weight of the constraint is larger, and its impact on the model's penalty or reward in the loss function is more significant.

[0078] The above describes an embodiment of a deep learning-based software development process management method of the present invention. Please refer to [link / reference]. Figure 3 In a deep learning-based software development process management system, the system includes the following modules: The feature vector extraction module is used to collect development behavior data, quality indicator data, and requirement parameter data. It uses a time-series sliding window algorithm to eliminate the time difference of multi-source data and obtain aligned feature vectors. The prediction model building module is used to construct a spatial graph by designing edge weights based on historical collaboration frequency and knowledge similarity using a GNN graph neural network with development team members as nodes. It uses dilated causal convolution in the temporal convolution module to adjust the dilation rate to capture long-term dependencies and adds a task coupling constraint term to the loss function to build the MST-GCN deep learning prediction model. The deviation index prediction module is used to input the aligned feature vector into the MST-GCN deep learning prediction model for prediction and output the R&D progress deviation index. The R&D resource adjustment module is used to model the software development process as an MDP Markov decision process based on the R&D progress deviation index and RL reinforcement learning to generate R&D resource allocation strategies.

[0079] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely preferred examples and are not intended to limit the invention. Various changes and modifications can be made to the invention without departing from its spirit and scope, and all such changes and modifications fall within the scope of the present invention as claimed. The scope of protection of the present invention is defined by the appended claims and their equivalents.

Claims

1. A software development process management method based on deep learning, characterized in that, The software development process management method includes the following steps: Collect development behavior data, quality indicator data, and requirement parameter data, and use the time-series sliding window algorithm to eliminate the time difference of multi-source data to obtain aligned feature vectors; By using GNN graph neural networks with development team members as nodes, edge weights are designed based on historical collaboration frequency and knowledge similarity to construct a spatial graph. Dilated causal convolution in the temporal convolution module is used to adjust the dilation rate to capture long-term dependencies. Task coupling constraint terms are added to the loss function to establish the MST-GCN deep learning prediction model. The aligned feature vector is input into the MST-GCN deep learning prediction model for prediction, and the R&D progress deviation index is output. Based on the aforementioned R&D progress deviation index, the software R&D process is modeled as an MDP Markov decision process using RL reinforcement learning, generating an R&D resource allocation strategy.

2. The software development process management method based on deep learning as described in claim 1, characterized in that, The collected development behavior data, quality indicator data, and requirement parameter data are processed using a time-series sliding window algorithm to eliminate time differences between multi-source data, resulting in an aligned feature vector, including: Collect development behavior data, quality indicator data, and requirement parameter data. Development behavior data should include at least code submission frequency, code modification volume, and code refactoring frequency. Quality indicator data should include at least code defect rate, technical debt index, test pass rate, and defect density. Requirement parameter data should include at least requirement change frequency, requirement change priority, and complexity. The window size for the time-series sliding window algorithm is determined based on the time granularity of the data and business requirements. For missing time point data within the window, linear interpolation or polynomial interpolation methods are used to supplement it; Data of different magnitudes are transformed to the same magnitude and normalized to the interval [0, 1] to obtain aligned feature vectors.

3. The software development process management method based on deep learning as described in claim 1, characterized in that, The method involves constructing a spatial graph using a GNN (Graph Neural Network) with development team members as nodes, designing edge weights based on historical collaboration frequency and knowledge similarity, adjusting the dilation rate using dilated causal convolution in the temporal convolution module to capture long-term dependencies, and adding a task coupling constraint term to the loss function to establish the MST-GCN deep learning prediction model, including: Historical collaboration frequency is calculated by the number of projects and tasks that team members participate in together. Determine the skill tags of the members to be compared, represent each member's skills in the form of tags, calculate the overlap of skill tags between two members, and obtain the knowledge similarity. Using a graph neural network (GNN), a spatial graph is constructed with development team members as nodes and edge weights designed based on historical collaboration frequency and knowledge similarity.

4. The software development process management method based on deep learning as described in claim 1, characterized in that, The method involves constructing a spatial graph using a GNN graph neural network with development team members as nodes, designing edge weights based on historical collaboration frequency and knowledge similarity, adjusting the dilation rate using dilated causal convolution in the temporal convolution module to capture long-term dependencies, and adding a task coupling constraint term to the loss function to establish the MST-GCN deep learning prediction model. The method also includes: The dependency in the R&D process is reflected in the use of a small inflation rate in the near term, so that the convolution covers a time range of 1-2 weeks; Long-cycle projects with dependencies spanning months and quarters employ a large inflation rate to enable convolution to cover a time range of 1-3 months, capturing the correlation patterns over long periods.

5. The software development process management method based on deep learning as described in claim 1, characterized in that, The method involves constructing a spatial graph using a GNN graph neural network with development team members as nodes, designing edge weights based on historical collaboration frequency and knowledge similarity, adjusting the dilation rate using dilated causal convolution in the temporal convolution module to capture long-term dependencies, and adding a task coupling constraint term to the loss function to establish the MST-GCN deep learning prediction model. The method also includes: Determine the type of task coupling, including at least dependency coupling, resource coupling, and target coupling. Set the weight of the constraint terms according to the coupling strength, with high weight for strongly coupled tasks and low weight for weakly coupled tasks. The loss function considers prediction error and task coupling constraints, and the model parameters are optimized through backpropagation to establish the MST-GCN deep learning prediction model.

6. The software development process management method based on deep learning as described in claim 1, characterized in that, The step of inputting the aligned feature vector into the MST-GCN deep learning prediction model for prediction and outputting the R&D progress deviation index includes: The alignment feature vector is input into the MST-GCN deep learning prediction model for prediction, and the impact of the collaborative relationship between members on the current R&D task is analyzed based on the constructed spatial graph. The temporal convolution module performs operations on the time-series data in the vector, captures long-term dependencies, and calculates the deviation index between the current R&D progress and the planned progress.

7. The software development process management method based on deep learning as described in claim 1, characterized in that, The step of modeling the software development process as an MDP Markov decision process based on the R&D progress deviation index and using RL reinforcement learning to generate an R&D resource allocation strategy includes: The state, action, and reward in the MDP Markov decision process are determined, and the optimal resource allocation strategy is learned through interaction with the R&D process based on RL reinforcement learning.

8. A software development process management system based on deep learning, characterized in that, The software development process management system includes the following modules: The feature vector extraction module is used to collect development behavior data, quality indicator data, and requirement parameter data. It uses a time-series sliding window algorithm to eliminate the time difference of multi-source data and obtain aligned feature vectors. The prediction model building module is used to construct a spatial graph by designing edge weights based on historical collaboration frequency and knowledge similarity using a GNN graph neural network with development team members as nodes. It uses dilated causal convolution in the temporal convolution module to adjust the dilation rate to capture long-term dependencies and adds a task coupling constraint term to the loss function to build the MST-GCN deep learning prediction model. The deviation index prediction module is used to input the alignment feature vector into the MST-GCN deep learning prediction model for prediction and output the R&D progress deviation index. The R&D resource adjustment module is used to model the software R&D process as an MDP Markov decision process based on the R&D progress deviation index and RL reinforcement learning to generate an R&D resource allocation strategy.

9. The software development process management system based on deep learning as described in claim 8, characterized in that, The deviation index prediction module includes the following sub-modules: The task analysis submodule is used to input the alignment feature vector into the MST-GCN deep learning prediction model for prediction, and to analyze the impact of the collaborative relationship between members on the current R&D task based on the constructed spatial graph. The progress calculation submodule is used by the temporal convolution module to perform operations on the time-series data in the vector, capture long-term dependencies, and calculate the deviation index between the current R&D progress and the planned progress.

10. The software development process management system based on deep learning as described in claim 8, characterized in that, The R&D resource adjustment module includes the following sub-modules: The resource allocation submodule is used to determine the state, action, and reward in the MDP Markov decision process. Based on RL reinforcement learning, it learns the optimal resource allocation strategy through interaction with the R&D process.

Images