Artificial intelligence-based software development upstream and downstream task parameter transmission and optimization method

Abstract

The application provides an artificial intelligence-based software development upstream and downstream task parameter transmission and optimization method, relates to the technical field of artificial intelligence, and comprises the following steps: constructing a parameter knowledge graph, generating a parameter dependency relationship graph by using a graph neural network to process parameter transmission data, monitoring parameter changes in real time and analyzing an influence range, and constructing a parameter optimization decision model based on hierarchical reinforcement learning to generate an optimization scheme, which can effectively reduce parameter conflicts, improve software development efficiency, enhance system stability, and realize intelligent management and optimization of parameter transmission in the software development process.

Description

TECHNICAL FIELD

[0001] The present application relates to artificial intelligence technology, and in particular to a method for parameter transmission and optimization of upstream and downstream tasks in software development based on artificial intelligence. BACKGROUND

[0002] In modern software development, with the increasing size and complexity of projects, development tasks are divided into multiple interdependent upstream and downstream links, and frequent parameter transmission is required between these links. As a key information carrier in software development, parameters run through various stages such as requirement analysis, system design, code implementation, and test verification. Effective management and optimization of the parameter transmission process are of great significance to improving software development efficiency and ensuring software quality. In traditional software development, parameter transmission mainly relies on manual management and document recording. With the development of artificial intelligence technology, especially the maturity of knowledge graph and graph neural network technologies, new technical means are provided for parameter transmission and optimization in software development.

[0003] However, the existing methods for parameter transmission and optimization in software development have some obvious defects and shortcomings. First, the existing methods lack systematic modeling of parameter transmission paths, making it difficult to accurately reflect the dependency relationships and influence degrees of parameters between different development stages, resulting in the inability to effectively evaluate the influence range of parameter changes, and often the problem of chain reaction after parameter change is not handled in time. Second, the existing parameter optimization methods rely heavily on the experience of developers and lack data-driven intelligent decision support, making it difficult to automatically generate the optimal parameter adjustment scheme according to historical optimization experience and current project characteristics, and making it difficult to cope with complex and variable development scenarios. In addition, the existing technology does not establish a closed-loop feedback mechanism for parameter optimization, and optimization experience is difficult to be systematically accumulated and utilized, resulting in the repeated occurrence of similar problems and the inability to effectively inherit and apply parameter optimization knowledge. SUMMARY

[0004] The embodiments of the present application provide a method for parameter transmission and optimization of upstream and downstream tasks in software development based on artificial intelligence, which can solve the problems in the prior art.

[0005] In a first aspect, the embodiments of the present application provide a method for parameter transmission and optimization of upstream and downstream tasks in software development based on artificial intelligence, comprising:

[0006] Constructing a parameter knowledge graph for software development, the parameter knowledge graph comprising a parameter mapping knowledge base, a task dependency relationship library, and an optimization experience library;

[0007] The parameter passing data in the software development process is received, the parameter passing data is processed by using a graph neural network, the parameter passing data is matched and analyzed with information in the parameter mapping knowledge base and the task dependency relationship library, and a parameter dependency relationship graph is generated, which is used to represent the transmission path and influence strength between parameters.

[0008] The parameter passing in the software development process is monitored in real time, and when parameter changes are detected, the influence range of the parameter changes is analyzed based on the parameter dependency relationship graph, and a set of affected parameter nodes is obtained.

[0009] A parameter optimization decision model is constructed, which takes the set of affected parameter nodes as state input, retrieves optimization schemes of similar scenarios from the optimization experience library as prior knowledge, and generates a parameter optimization scheme using a hierarchical reinforcement learning strategy, which includes a parameter selection layer and a parameter adjustment layer. The parameter selection layer determines the target parameters that need to be optimized, and the parameter adjustment layer generates specific parameter values.

[0010] The parameter optimization scheme is executed, the optimization effect is recorded, and the new experience data is stored in the optimization experience library.

[0011] In an optional implementation,

[0012] The steps of constructing a parameter knowledge graph of software development include:

[0013] Multi-source parameter data in the software development process is collected, including parameter definition data in the code repository, parameter specification data in the development document, and parameter passing data in the running log. Based on the multi-source parameter data, the basic structure of the parameter knowledge graph is constructed, and parameters, tasks, and optimization schemes are taken as graph entities, and the mapping relationship between parameters, the dependency relationship between tasks, the association relationship between parameters and tasks, and the action relationship between optimization schemes and parameters are taken as edges in the graph, forming a multi-element heterogeneous knowledge network structure.

[0014] The parameter naming is standardized by morphological reduction, the semantic similarity between parameters is calculated, the parameter mapping relationship is determined according to the preset similarity threshold, and the parameter mapping knowledge base is generated. Parameter format conversion rules are established and stored in the parameter mapping knowledge base.

[0015] The calling relationship between tasks and the parameter flow path are extracted to obtain the static task dependency relationship, the dynamic task association information is obtained by tracking the parameter passing at runtime, and the coupling degree between tasks is calculated by using a weighted fusion method, which considers the parameter sharing degree and the transmission frequency, to generate the task dependency relationship library.

[0016] formalize the historical optimization schemes, extract optimization rules, calculate the similarity between optimization schemes, and generate an optimization experience library;

[0017] The parameter knowledge graph is subjected to consistency inspection and integrity verification, and an incremental knowledge updating mechanism is established.

[0018] In an alternative embodiment,

[0019] The parameter passing data in the software development process is received, the parameter passing data is processed using a graph neural network, the parameter passing data is matched and analyzed with the information in the parameter mapping knowledge base and the task dependency relationship library, and a parameter dependency relationship graph is generated. The step of using the parameter dependency relationship graph to represent the transmission path and influence strength between parameters includes:

[0020] The parameter type code, parameter name semantic code, parameter value range code, and parameter context feature code in the parameter passing data are extracted to generate a parameter feature vector. The transmission type, transmission frequency, and time sequence features in the parameter passing data are extracted to generate a parameter transmission relationship feature.

[0021] The parameter feature vector is matched with the information in the parameter mapping knowledge base to calculate the parameter semantic similarity, and the mapping relationship between parameters is determined according to the parameter semantic similarity. The parameter transmission relationship feature is matched with the information in the task dependency relationship library to calculate the task dependency strength.

[0022] A graph structure is constructed, parameters with a mapping relationship are used as nodes in the graph, the parameter transmission relationship feature is used as the attribute of the edge in the graph, and the parameter feature vector is used as the initial feature of the node.

[0023] The graph structure constructed is processed using a graph neural network, node messages are generated based on the parameter feature vector of the node and the parameter transmission relationship feature of the edge, the generated node messages are aggregated to obtain the updated feature of the node, and the connection strength between nodes is calculated according to the updated feature.

[0024] A parameter dependency relationship graph is generated based on the connection strength, the parameter dependency relationship graph represents the transmission path and influence strength between parameters, and the influence strength is determined by the parameter semantic similarity, the task dependency strength, and the connection strength.

[0025] In an alternative embodiment,

[0026] The node messages are generated based on the parameter feature vector of the node and the parameter transmission relationship feature of the edge, the generated node messages are aggregated to obtain the updated feature of the node, and the connection strength between nodes is calculated according to the updated feature.

[0027] generate a node message based on the parameter feature vector and the parameter transmission relationship feature of the edge, calculate attention weights of different dimension features, multiply the attention weights with a feature conversion matrix to enhance the node message;

[0028] perform hierarchical aggregation on the enhanced node message, perform local message aggregation in a local neighbor range, and combine node messages of local neighbor nodes based on local aggregation weights to obtain local aggregation features; perform global message aggregation in a global range, combine local aggregation features of global neighbor nodes based on global aggregation weights, and balance the local aggregation features and the global aggregation features through a gating parameter to obtain an updated feature of the node;

[0029] calculate connection strengths between nodes based on the updated feature, wherein the connection strengths are obtained by weighted combination of direct connection strengths, indirect connection strengths, and task association strengths, the direct connection strengths are calculated based on node feature similarity, the indirect connection strengths are calculated based on importance of a transmission path between nodes, and the task association strengths are calculated based on a dependency relationship of a task to which a node belongs.

[0030] In an optional implementation,

[0031] monitor parameter transmission in a real-time software development process, and when detecting parameter change, analyze an influence range of the parameter change based on the parameter dependency graph, and the step of obtaining a set of affected parameter nodes includes:

[0032] deploy a parameter change listener to realize real-time capture of parameter change through a code commit hook, configuration file monitoring, and runtime parameter tracking; when detecting parameter change, record an identifier, a change type, and a change value range of the changed parameter; and locate a node corresponding to the changed parameter in the parameter dependency graph, and mark the node as a change source node;

[0033] start traversing the parameter dependency graph from the change source node, calculate a node influence coefficient based on connection strengths between nodes, the node influence coefficient is a weighted product of all connection strengths on a path between the change source node and the node, for each traversed node, calculate a sensitivity coefficient based on a parameter feature vector of the node, multiply the node influence coefficient by the sensitivity coefficient to obtain an influence value of the node, and when the influence value is greater than a preset influence threshold, add the node to an affected node set.

[0034] In an optional implementation,

[0035] construct a parameter optimization decision model, the parameter optimization decision model takes the set of affected parameter nodes as state input, retrieves the optimization scheme of a similar scenario from the optimization experience library as prior knowledge, generates a parameter optimization scheme using a hierarchical reinforcement learning strategy, the hierarchical reinforcement learning strategy includes a parameter selection layer and a parameter adjustment layer; the parameter selection layer determines the target parameters that need to be optimized, and the parameter adjustment layer generates the specific parameter value steps include:

[0036] The parameter optimization decision model includes a hierarchical reinforcement learning architecture composed of a parameter selection layer in the upper layer and a parameter adjustment layer in the lower layer sharing a state space and independent action space, and the action output of the parameter selection layer is used as a constraint condition for the parameter adjustment layer;

[0037] The set of affected parameter nodes is converted into a state vector, which is used as input for the hierarchical reinforcement learning architecture, a historical optimization scheme corresponding to a similar state is retrieved from the optimization experience library, and the decision results in the historical optimization scheme are extracted as prior knowledge for the current decision;

[0038] The parameter selection layer evaluates the optimization importance of each affected parameter, calculates the optimization priority based on parameter importance, change sensitivity and influence range, and selects the parameter subset with the highest priority as the target parameters that need to be optimized;

[0039] The parameter adjustment layer generates adjustment values for each target parameter, and the generation process of the adjustment values considers the dependency relationship between parameters, performance constraints and risk control factors;

[0040] A hierarchical reward mechanism is used to update the parameter optimization decision model, the reward of the parameter selection layer is calculated based on the coverage and precision of the selected parameter set, the reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment, and the rewards of the parameter selection layer and the parameter adjustment layer are combined through weighting to form the overall optimization target.

[0041] In an optional implementation,

[0042] The reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment, and the reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment.

[0043] A dynamic influence coefficient between parameters is calculated, the dynamic influence coefficient is calculated based on the product of the partial derivative of the parameter value with respect to the performance index and the ratio of the parameter value to the performance index, and the dynamic influence coefficient forms a parameter influence matrix; the performance improvement reward is calculated according to the parameter influence matrix, and the performance improvement reward is calculated based on the weighted performance change of the dynamic influence coefficient before and after parameter adjustment;

[0044] The time sequence influence characteristics of parameter adjustment are described by amplitude, attenuation coefficient, oscillation frequency and phase shift, a time sequence contribution degree matrix is calculated based on the time sequence influence characteristics, the calculation process of the time sequence contribution degree matrix combines the parameter adjustment amount and the values of the time sequence influence characteristics at different time steps, a stability reward is calculated according to the time sequence contribution degree matrix, and the stability reward is calculated based on the change rate of parameter performance in a sliding time window;

[0045] The time sequence contribution degree matrix is used for time sequence distribution of performance improvement rewards and stability rewards, the reward distribution results at different time steps are combined with historical optimization experience through weighted combination, and a final parameter optimization reward is generated;

[0046] The parameter optimization strategy is updated based on the final parameter optimization reward, a constraint term of parameter correlation degree is introduced in the updating process of the parameter optimization strategy, and the constraint term is calculated based on the dynamic influence coefficient in the parameter influence matrix.

[0047] The second aspect of the embodiment of the application provides an electronic device, comprising:

[0048] A processor;

[0049] A memory for storing processor-executable instructions;

[0050] The processor is configured to call the instructions stored in the memory to execute the method described above.

[0051] The third aspect of the embodiment of the application provides a computer-readable storage medium having computer program instructions stored thereon, and the computer program instructions are executed by a processor to implement the method described above.

[0052] The application realizes accurate modeling of parameter dependency relationship in the software development process by constructing a parameter knowledge graph and processing parameter transmission data using a graph neural network, can quickly identify the influence range of parameter changes, and reduces the manual analysis time and error rate in the traditional method.

[0053] The application adopts a hierarchical reinforcement learning strategy to construct a parameter optimization decision model, processes parameter selection and parameter adjustment in layers, improves the optimization efficiency, and adaptively generates an optimal parameter scheme according to historical experience and the current state, thereby significantly improving the quality and stability of software development.

[0054] The application establishes a complete parameter transmission and optimization closed-loop mechanism, realizes automation and intelligentization of parameter management in the software development process through real-time monitoring, intelligent analysis and automatic optimization, reduces the communication cost of the development team, speeds up the software iteration speed, and improves the overall research and development efficiency. BRIEF DESCRIPTION OF DRAWINGS

[0055] Figure 1 This is a flow chart of a method for transferring and optimizing parameters of upstream and downstream tasks in software development based on artificial intelligence according to an embodiment of the present invention;

[0056] Figure 2 Flowchart of node feature update and connection strength calculation of the present invention;

[0057] Figure 3 Performance comparison chart for different parameter optimization methods;

[0058] Figure 4 Compare the performance improvements of different methods. DETAILED DESCRIPTION

[0059] To make the objectives, technical solutions, and advantages of the embodiments of the present invention more clear, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts shall fall within the scope of protection of the present invention.

[0060] The following specific embodiments are used to describe the technical solution of the present invention in detail. The following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described in detail in some embodiments.

[0061] Figure 1 Schematic diagram of the process of transferring and optimizing parameters of upstream and downstream tasks in software development based on artificial intelligence according to an embodiment of the present invention. Figure 1 As shown, the method includes:

[0062] Constructing a parameter knowledge graph for software development, which includes a parameter mapping knowledge base, a task dependency library, and an optimization experience library;

[0063] Receive parameter transfer data during the software development process, process the parameter transfer data using a graph neural network, match and analyze the parameter transfer data with information in the parameter mapping knowledge base and the task dependency library, and generate a parameter dependency graph, wherein the parameter dependency graph is used to characterize the transfer path and influence intensity between parameters;

[0064] Real-time monitoring of parameter transfer during software development. When a parameter change is detected, the impact range of the parameter change is analyzed based on the parameter dependency graph to obtain a set of affected parameter nodes.

[0065] A parameter optimization decision model is constructed, the parameter optimization decision model takes the set of affected parameter nodes as state input, retrieves optimization schemes of similar scenarios from the optimization experience library as priori knowledge, and generates a parameter optimization scheme by using a hierarchical reinforcement learning strategy, the hierarchical reinforcement learning strategy includes a parameter selection layer and a parameter adjustment layer; the parameter selection layer determines target parameters that need to be optimized, and the parameter adjustment layer generates specific parameter values;

[0066] The parameter optimization scheme is executed, and an optimization effect is recorded as new experience data stored in the optimization experience library.

[0067] In an optional implementation, the step of constructing a parameter knowledge graph for software development includes:

[0068] Multi-source parameter data in the software development process is collected, the multi-source parameter data includes parameter definition data in a code repository, parameter specification data in a development document, and parameter transmission data in a running log; a basic structure of the parameter knowledge graph is constructed based on the multi-source parameter data, parameters, tasks, and optimization schemes are taken as graph entities, mapping relationships between parameters, dependency relationships between tasks, association relationships between parameters and tasks, and action relationships between optimization schemes and parameters are taken as edges in the graph, and a multi-element heterogeneous knowledge network structure is formed;

[0069] Parameter naming is standardized by morphological reduction, semantic similarity between parameters is calculated, parameter mapping relationships are determined according to a preset similarity threshold, and a parameter mapping knowledge base is generated; parameter format conversion rules are established and stored in the parameter mapping knowledge base;

[0070] Static task dependency relationships are obtained by extracting calling relationships between tasks and parameter flow paths, dynamic task association information is obtained by tracking parameter transmission at runtime, a coupling degree between tasks is calculated by using a weighted fusion method, the weighted fusion method comprehensively considers parameter sharing degree and transmission frequency, and a task dependency relationship library is generated;

[0071] Historical optimization schemes are formally represented, optimization rules are extracted, similarity between optimization schemes is calculated, and an optimization experience library is generated;

[0072] The parameter knowledge graph is subjected to consistency checking and integrity verification, and an incremental knowledge updating mechanism is established.

[0073] Exemplarily, in the initial stage of implementing the parameter knowledge graph construction, the source code files are obtained through API calls or direct access to code repositories (such as Git repositories), and parameter definition data such as variable definitions and function parameter definitions are extracted through regular expression matching. For example, for the Java code "public void processData(String inputPath, int maxSize)", "inputPath" and "maxSize" are extracted as parameters. At the same time, parameter specification data is extracted from development documents (such as API documents and design specifications) through text parsing techniques, including parameter name, type, value range, default value, and other information. Running logs are also parsed to capture parameter passing in actual running, such as the parameter values and passing paths in "2023-05-20 14:30:22 INFO: Function call: processData(filePath=' / data / input.txt', maxSize=1024)".

[0074] In the parameter knowledge graph, parameter entities contain attributes such as name, data type, default value, and value range; task entities contain task ID, name, and function description; and optimization scheme entities contain scheme ID, target parameter set, and optimization rules. The edge relationships in the graph include: mapping relationships between parameters (such as inputPath mapping to filePath), dependency relationships between tasks (such as task A calling task B), association relationships between parameters and tasks (such as parameter maxSize being used by task processData), and action relationships between optimization schemes and parameters (such as the memory optimization scheme acting on the heap size parameter).

[0075] To construct the parameter mapping knowledge base, standardize the parameter naming. Use morphological reduction techniques to convert parameter names to basic forms, such as converting "files" to "file" and "processing" to "process". For parameters in camel case, they will be decomposed into word sequences, such as "maxFileSize" decomposed into "max", "file", and "size". After processing, calculate the semantic similarity between parameters using a combination of word vectors and edit distance. For example, the similarity between "inputPath" and "filePath" is 0.85, which is higher than the preset threshold of 0.7, so they are identified as mapping relationships. In addition, according to parameter types and usage scenarios, establish format conversion rules, such as the conversion rule for string path format between different operations "C:\\data\\file.txt" ⟷ " / data / file.txt", and store these rules in the parameter mapping knowledge base.

[0076] In constructing the task dependency relationship library, the calling relationship between tasks is extracted through static code analysis. The function call statements in the code are scanned, such as "result = taskB(param1, param2)", which indicates that the current task calls taskB. At the same time, the parameter transfer path between tasks is tracked, and a parameter flow chart is constructed. At runtime, the actual parameter transfer situation is captured through burying points or log analysis, and the transfer frequency and timestamp are recorded. Based on static analysis and dynamic monitoring data, a weighted fusion method is used to calculate the coupling degree between tasks. This method considers the parameter sharing degree (the proportion of the number of parameters shared by two tasks to the total parameters) and the transfer frequency (the number of parameter transfers per unit time). For example, tasks A and B share 5 parameters, accounting for 40% of the total parameters, and there are an average of 3 parameter transfers per minute, and the calculated coupling degree is 0.65. These calculation results are stored in the task dependency relationship library.

[0077] To construct the optimization experience library, the historical optimization schemes are formally represented. Each optimization scheme is represented as a triple: <target parameter set, optimization operation, expected effect>. For example, a memory optimization scheme can be represented as <{heapSize, cacheSize}, "increase heap size and reduce cache size", "improve large data processing performance">. Optimization rules are extracted from these representations, such as "when processing large files, increasing the heap size parameter value can improve performance". The similarity between optimization schemes is also calculated based on the overlap of target parameter sets and the similarity of optimization operations. Optimization schemes with high similarity are classified and form optimization patterns. These optimization rules and patterns constitute the optimization experience library.

[0078] At the same time, the constructed parameter knowledge graph is subjected to consistency checking and integrity verification. Consistency checking includes checking the transitivity (if A maps to B and B maps to C, then A should map to C) and symmetry of the mapping relationship. Integrity verification assesses the coverage of the graph by checking isolated nodes, dangling edges, etc. An incremental knowledge updating mechanism is also established, which automatically extracts new information and updates the knowledge graph when new code is submitted, documents are updated, or runtime logs are generated, ensuring the timeliness and accuracy of the graph.

[0079] The present application realizes the centralized management of parameter mapping relationship, task dependency relationship and optimization experience through the collection of multi-source parameter data and the construction of knowledge graph, establishes an incremental knowledge updating mechanism, enables the parameter knowledge graph to be continuously accumulated and optimized, provides a comprehensive and reliable knowledge base for subsequent parameter optimization, and improves the efficiency of knowledge utilization.

[0080] In an alternative embodiment, the parameter passing data in the software development process is received, the parameter passing data is processed using a graph neural network, the parameter passing data is matched and analyzed with information in the parameter mapping knowledge base and the task dependency relationship library, a parameter dependency relationship graph is generated, and the step of representing the transmission path and influence strength between parameters includes:

[0081] The parameter type code, parameter name semantic code, parameter value range code and parameter context feature code in the parameter passing data are extracted to generate a parameter feature vector; the transmission type, transmission frequency and timing characteristics in the parameter passing data are extracted to generate a parameter transmission relationship feature;

[0082] The parameter feature vector is matched with the information in the parameter mapping knowledge base to calculate the parameter semantic similarity, and the mapping relationship between parameters is determined according to the parameter semantic similarity; the parameter transmission relationship feature is matched with the information in the task dependency relationship library to calculate the task dependency strength;

[0083] A graph structure is constructed, parameters with mapping relationships are taken as nodes in the graph, the parameter transmission relationship feature is taken as the attribute of the edge in the graph, and the parameter feature vector is taken as the initial feature of the node;

[0084] The graph structure constructed is processed using a graph neural network, node messages are generated based on the parameter feature vector of the node and the parameter transmission relationship feature of the edge, and the update feature of the node is obtained by aggregating the generated node messages; the connection strength between nodes is calculated according to the update feature;

[0085] A parameter dependency relationship graph is generated based on the connection strength, the parameter dependency relationship graph represents the transmission path and influence strength between parameters, and the influence strength is determined by the parameter semantic similarity, the task dependency strength and the connection strength.

[0086] For example, the parameter passing data can be obtained by deploying a data collection module in a software development environment, including parameter passing information in the function call process, parameter interaction information between service interfaces, etc. For example, for an e-commerce, the data of the order service passing order ID, commodity ID, quantity, etc. to the inventory service is collected.

[0087] From the received parameter transfer data, extract parameter type encoding, such as encoding "int" as "001" and "string" as "010"; extract parameter name semantic encoding, such as mapping "productId" to a 128-dimensional vector through a word vector model; extract parameter value range encoding, such as encoding "positive integer" as "101"; extract parameter context feature encoding, including information such as the module to which the parameter belongs and the function position. Taking the goods ID parameter as an example, its feature vector can be represented as a 256-dimensional vector containing the above information. At the same time, extract parameter transfer relationship features. Transfer types include value transfer and reference transfer, which are encoded as different identifiers; transfer frequency records the number of parameter transfers, such as "called 5 times per hour"; timing features record the time pattern of parameter transfer, such as "timed trigger" or "event-driven". For example, the transfer relationship features of the order ID from the order service to the inventory service can be represented as: value transfer, an average of 3 times per minute, and event-driven.

[0088] Calculate the parameter semantic similarity between the parameter feature vector and the information in the parameter mapping knowledge base. When calculating, compare the parameter feature vector with the recorded similarity in the knowledge base through methods such as vector cosine similarity. When the similarity exceeds a pre-set threshold (such as 0.85), it is confirmed that there is a mapping relationship between the two parameters. For example, "productId" and "goodsId" may have different names, but through semantic similarity calculation (score 0.92) it is confirmed that they refer to the same parameter. The task dependency relationship library records the dependency relationships and importance levels between functional modules. By comparing the module path of parameter transfer with the records in the task dependency relationship library, the task dependency strength is calculated.

[0089] When constructing the graph structure of parameter dependency relationships, create a node set for the graph, with each node representing a parameter such as "orderId", "productId", etc., and each node assigned a globally unique identifier. Assign the parameter feature vectors generated in the previous step (including parameter type, name semantic, value range, and context feature encoding) to the corresponding nodes as initial features. After node initialization, establish the edges of the graph based on the mapping relationships and transfer behaviors between parameters. The attributes of the edges include the parameter transfer relationship features extracted earlier, including: transfer type (value transfer = 1, reference transfer = 2, etc.), transfer frequency (number / time unit), and timing features (synchronous = 10, asynchronous = 20, etc.). For example, in the order processing process, a edge is established between the "orderId" parameter nodes from the order service to the payment service, with attributes {transfer type: 1, frequency: 10 times / hour, timing feature: 10}, indicating a high-frequency synchronous value transfer relationship.

[0090] Using a graph convolution network (GCN) or a graph attention network (GAT), for each node, a node message is generated based on its feature vector and the features of adjacent nodes (nodes connected by edges). For example, for a "productId" node, a new node message is generated by combining its own features and the message from the "orderId". After the node message is generated, the messages are aggregated by weighted summation or the like to obtain the updated features of the nodes. The updated features reflect the importance and influence range of the parameters in the entire propagation network. The connection strength between nodes is calculated based on the updated features.

[0091] Based on the calculated connection strength, a parameter dependency graph is constructed, a directed graph structure is created, and all parameter nodes are added to the graph; based on the connection strength, the weights of the edges are set, and edges with a connection strength higher than a threshold (such as 0.5) are retained in the graph. The influence strength calculation uses a weighted fusion method: influence strength = a x parameter semantic similarity + β x task dependency strength + γ x connection strength, where a, β, and γ are weight coefficients, and a + β + γ = 1. The weight coefficients can be dynamically adjusted according to different characteristics, for example, the weight a of parameter semantic similarity can be increased for data-intensive applications.

[0092] In the e-commerce instance, the influence strength calculation of the product ID parameter (productId) to the inventory service (inventory) is: 0.76 = 0.3 x 0.92 (parameter semantic similarity) + 0.4 x 0.65 (task dependency strength) + 0.3 x 0.75 (connection strength), indicating that the product ID parameter change will have a large impact on the inventory service. The dependency graph can be displayed through a graphical interface, with node size representing parameter importance, edge thickness representing influence strength, and color depth representing change sensitivity. Through this graph, developers can identify core parameters (such as order ID with multiple high-strength outgoing edges) and key transmission paths (such as the parameter transmission chain from order processing to payment process), providing a basis for parameter optimization and reconstruction.

[0093] The present application uses a graph neural network to process parameter propagation data, accurately identifies the mapping relationship and transmission characteristics between parameters through feature encoding and multi-dimensional matching analysis, and generates a parameter dependency graph that comprehensively reflects the transmission path and influence strength between parameters, providing a reliable basis for subsequent impact analysis and optimization decisions.

[0094] In an optional implementation, node messages are generated based on the parameter feature vectors of the nodes and the parameter propagation relationship features of the edges, and the generated node messages are aggregated to obtain updated features of the nodes; the step of calculating the connection strength between nodes based on the updated features comprises:

[0095] The graph neural network is used for processing the constructed graph structure, a node message is generated based on the parameter feature vector and the parameter transmission relationship feature of the edge, an attention weight of different dimension features is calculated, the attention weight is multiplied by a feature conversion matrix to enhance the node message;

[0096] The enhanced node message is hierarchically aggregated, local message aggregation is performed in a local neighbor range, and a local aggregation feature is obtained by weighting and combining the node messages of the local neighbor nodes based on a local aggregation weight; global message aggregation is performed in a global range, the local aggregation features of the global neighbor nodes are weighted and combined based on a global aggregation weight, and the local aggregation feature and the global aggregation feature are balanced through a gating parameter to obtain an updated feature of the node;

[0097] The connection strength between nodes is calculated according to the updated feature, and the connection strength is obtained by weighted combination based on a direct connection strength, an indirect connection strength and a task association strength, wherein the direct connection strength is calculated based on a node feature similarity, the indirect connection strength is calculated based on the importance of a transmission path between nodes, and the task association strength is calculated based on a dependency relationship of a task to which the node belongs.

[0098] For example, in combination with Figure 2 The node feature update and connection strength calculation flowchart of the application is described. In the node message generation stage, the node message is generated in combination with the parameter feature vector of the node and the transmission relationship feature of the edge. For node i, the initial feature is hi, and the edge feature of neighbor node j is eij. The message of node i can be generated through a feature combination function. The feature splicing method can be used to splice hi and eij, and then the message mij is obtained through the transformation matrix W. For example, if the initial feature of the parameter node "temperature threshold" is [0.8, 0.5, 0.3, 0.9], and the edge feature of the parameter "alarm" is [1.0, 0.75, 0.5], the spliced feature is [0.8, 0.5, 0.3, 0.9, 1.0, 0.75, 0.5], and the node message [0.65, 0.78, 0.42] can be obtained after processing by the transformation matrix.

[0099] In the feature enhancement stage, the attention mechanism is introduced to calculate the importance weight of different dimension features. The node message is divided into multiple dimension features, for example, [0.65, 0.78, 0.42] is divided into three dimensions, and the attention score of each dimension is calculated. Through normalization processing, the attention weight of each dimension can be obtained, such as [0.35, 0.42, 0.23]. The attention weight is multiplied by the pre-defined feature conversion matrix to enhance the node message and improve the influence of important dimensions. In practical applications, the enhanced node message becomes [0.72, 0.82, 0.38].

[0100] The hierarchical aggregation process is divided into two stages: local aggregation and global aggregation. Local aggregation is performed within the direct neighbors of a node. For each local neighbor node j, its influence weight aij is calculated, which is based on the node feature similarity and the edge transmission strength. For example, for a node with three direct neighbors, the local aggregation weights are [0.5, 0.3, 0.2]. These weights are combined with the messages of the corresponding neighbor nodes to obtain the local aggregation features. Assuming that the messages of the three neighbor nodes are [0.7, 0.8, 0.4], [0.6, 0.7, 0.5], and [0.5, 0.6, 0.7], respectively, the local aggregation features are [0.5x0.7+0.3x0.6+0.2x0.5, 0.5x0.8+0.3x0.7+0.2x0.6, 0.5x0.4+0.3x0.5+0.2x0.7], i.e., [0.64, 0.74, 0.47].

[0101] Global aggregation is performed in a wider range, considering the influence of indirectly connected nodes. Global aggregation weights bik are calculated based on path importance and global structure information, which are used to weight combine the local aggregation features of non-directly connected nodes. For example, for three global influence nodes, the global aggregation weights are [0.4, 0.35, 0.25]. Assuming that the local aggregation features of these nodes are [0.65, 0.75, 0.45], [0.62, 0.72, 0.48], and [0.60, 0.70, 0.50], respectively, the global aggregation features are [0.4x0.65+0.35x0.62+0.25x0.60, 0.4x0.75+0.35x0.72+0.25x0.70, 0.4x0.45+0.35x0.48+0.25x0.50], i.e., [0.628, 0.728, 0.471].

[0102] To balance the influence of local information and global information, a gating parameter γ is introduced, which dynamically adjusts according to the position and importance of the node in the graph. For example, for an important node in the center of the graph, set γ = 0.6, indicating that local information accounts for 60% and global information accounts for 40%. The updated features of the final node i are γ times the local aggregation features plus (1-γ) times the global aggregation features, i.e., [0.6x0.64+0.4x0.628, 0.6x0.74+0.4x0.728, 0.6x0.47+0.4x0.471], resulting in [0.6352, 0.7352, 0.4704].

[0103] In the connection strength calculation stage, the direct connection strength, the indirect connection strength and the task association strength are comprehensively considered. The direct connection strength is calculated based on the node feature similarity, such as the inner product of the feature vectors of nodes i and j divided by the product of the vector lengths, and the result ranges from 0 to 1. The indirect connection strength is based on the importance score of all paths between nodes, and the shorter the path is and the higher the importance of the intermediate nodes is, the greater the indirect connection strength is. The task association strength considers the dependency relationship between tasks to which the nodes belong, and the nodes between the same tasks or tasks with strong dependency relationship have higher task association strength. The final connection strength is calculated by weighted combination of the three strengths through coefficients w1, w2 and w3. Different weights can be set according to specific scenes, for example, w1=0.5, w2=0.3 and w3=0.2.

[0104] The application enhances node messages through the attention mechanism, effectively captures the complex dependency relationship between parameters in the local and global ranges by adopting the hierarchical message aggregation strategy, and comprehensively considers multiple dimensions such as direct connection, indirect transmission and task association in the calculation of the connection strength, thereby improving the accuracy of dependency relationship analysis.

[0105] In an optional implementation, the parameter transmission in the software development process is monitored in real time. When the parameter change is detected, the step of analyzing the influence range of the parameter change based on the parameter dependency graph includes:

[0106] A parameter change listener is deployed to realize real-time capture of parameter changes through code commit hooks, configuration file monitoring and runtime parameter tracking. When the parameter change is detected, the identification, change type and change value range of the changed parameter are recorded. The node corresponding to the changed parameter in the parameter dependency graph is located and marked as a change source node.

[0107] The parameter dependency graph is traversed from the change source node, the node influence coefficient is calculated based on the connection strength between nodes, the node influence coefficient is the weighted product of all connection strengths on the path between the change source node, for each traversed node, the sensitivity coefficient is calculated according to the parameter feature vector of the node, the node influence value is obtained by multiplying the node influence coefficient and the sensitivity coefficient, and when the influence value is greater than a preset influence threshold, the node is added to the affected node set.

[0108] To achieve real-time monitoring of parameter changes, a parameter change listener is deployed. The listener captures parameter changes through three approaches: code commit hook, configuration file monitoring, and runtime parameter tracking. The code commit hook triggers when a developer commits code, automatically scans the code for parameter definitions and usage, and identifies parameter changes. For example, when a developer modifies the configuration parameter "CONNECTION_TIMEOUT" from 30 seconds to 60 seconds and commits the code, the code commit hook captures the change. The configuration file monitoring continuously observes changes in configuration files through file monitoring mechanisms and triggers notifications immediately when a configuration file is modified. The runtime parameter tracking monitors the actual usage of parameters during runtime through instrumentation or proxying, recording changes in parameter values.

[0109] When the listener detects a parameter change, the identity of the changed parameter, the change type, and the change value range are recorded. The change type includes adding a parameter, deleting a parameter, modifying a parameter's default value, and modifying a parameter's value range. For example, for the performance tuning parameter "MAX_THREAD_POOL_SIZE", if it is changed from "50" to "100", its identity is recorded as "MAX_THREAD_POOL_SIZE", the change type is "modify parameter default value", and the change value range is "from 50 to 100".

[0110] In the parameter dependency graph, locate the node corresponding to the changed parameter and mark it as the change source node. For example, in the parameter dependency graph, find the node corresponding to "MAX_THREAD_POOL_SIZE" and mark it as the change source node for this analysis.

[0111] Starting from the change source node, traverse the parameter dependency graph using breadth-first or depth-first algorithm. For each traversal path, calculate the node influence coefficient based on the connection strength between nodes. The node influence coefficient is the weighted product of all connection strengths on the path between the change source node. For example, if there are two edges on the path from the change source node "MAX_THREAD_POOL_SIZE" to the node "REQUEST_PROCESSING_TIME", with connection strengths of 0.8 and 0.7 respectively, the influence coefficient of node "REQUEST_PROCESSING_TIME" is 0.8 multiplied by 0.7, which equals 0.56.

[0112] For each traversed node, calculate the sensitivity coefficient based on the parameter feature vector of the node. The parameter feature vector contains multiple features, and the sensitivity coefficient is calculated by the weighted sum of these feature values.

[0113] The node influence coefficient is multiplied by the sensitivity coefficient to obtain the influence value of the node. When the influence value is greater than the preset influence threshold, the node is added to the set of affected nodes. Assuming that the influence coefficient of the node "REQUEST_PROCESSING_TIME" is 0.56, and the sensitivity coefficient is 0.67, the influence value is 0.56 multiplied by 0.67, which is equal to 0.3752. If the preset influence threshold is 0.3, the node will be added to the set of affected nodes.

[0114] In practical applications, different preset influence thresholds are set for different types of software projects. For example, for critical business, a lower influence threshold such as 0.2 is set to ensure that more potential impacts are captured; and for non-critical, a higher influence threshold such as 0.4 is set to reduce the analysis workload.

[0115] The present application realizes real-time monitoring of parameter changes and accurate analysis of influence range, accurately identifies the affected parameter nodes through the calculation of node influence coefficient and sensitivity coefficient, avoids the omission and redundancy of impact analysis, and improves the pertinence and efficiency of parameter optimization.

[0116] The present application realizes real-time monitoring of parameter changes and accurate analysis of influence range, accurately identifies the affected parameter nodes through the calculation of node influence coefficient and sensitivity coefficient, avoids the omission and redundancy of impact analysis, and improves the pertinence and efficiency of parameter optimization. This helps developers to understand the influence range in advance when adjusting parameters, and reduces the abnormality caused by parameter changes.

[0117] In an optional embodiment, a parameter optimization decision model is constructed, the parameter optimization decision model takes the set of affected parameter nodes as state input, retrieves the optimization scheme of a similar scenario from the optimization experience library as prior knowledge, and generates a parameter optimization scheme using a hierarchical reinforcement learning strategy, the hierarchical reinforcement learning strategy includes a parameter selection layer and a parameter adjustment layer; the parameter selection layer determines the target parameter that needs to be optimized, and the parameter adjustment layer generates a specific parameter value, and the steps include:

[0118] The parameter optimization decision model includes a hierarchical reinforcement learning architecture, the hierarchical reinforcement learning architecture is composed of a parameter selection layer in an upper layer and a parameter adjustment layer in a lower layer sharing a state space and having independent action spaces, and the action output of the parameter selection layer is used as a constraint condition of the parameter adjustment layer;

[0119] The set of affected parameter nodes is converted into a state vector, the state vector is used as the input of the hierarchical reinforcement learning architecture, a historical optimization scheme corresponding to a similar state is retrieved from the optimization experience library, and the decision result in the historical optimization scheme is extracted as prior knowledge for the current decision;

[0120] The parameter selection layer evaluates the optimization importance of each affected parameter, calculates an optimization priority based on parameter importance, change sensitivity, and influence range, and selects a parameter subset with the highest priority as target parameters that need to be optimized.

[0121] The parameter adjustment layer generates an adjustment value for each target parameter, and the generation process takes into account the dependency between parameters, performance constraints, and risk control factors.

[0122] The parameter optimization decision model is updated using a hierarchical reward mechanism. The reward of the parameter selection layer is calculated based on the coverage and accuracy of the selected parameter set, and the reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment. The rewards of the parameter selection layer and the parameter adjustment layer are combined by weighting to form the overall optimization goal.

[0123] For example, the parameter optimization decision model can be implemented using a deep neural network, where the parameter selection layer uses a Transformer network with a multi-head attention mechanism to capture long-range dependencies between parameters. The network input is a parameter state vector, and the output is the selection probability of each parameter. The parameter adjustment layer uses an Actor-Critic architecture, where the Actor network generates parameter adjustment actions, and the Critic network evaluates the value of the actions. The two layers share an encoder to extract state representations, but have independent policy heads and value heads. Model training is done in stages, first using historical optimization experience for supervised pre-training to establish a basic policy, and then updating through reinforcement learning using new data collected through online interaction. The parameter selection layer is responsible for determining the target parameters that need to be optimized, and its action space is a binary selection space for all affected parameters, i.e., selecting or not selecting each parameter. The parameter adjustment layer is responsible for generating specific adjustment values for the selected target parameters, and its action space is a continuous or discrete space of parameter values.

[0124] When converting the set of affected parameter nodes into a state vector, the features of each parameter node are extracted, including parameter type, name semantics, current value, value range, influence coefficient, and sensitivity coefficient. For categorical parameters, one-hot encoding is used; for numerical parameters, normalization is performed; for text parameters, word embedding technology is used to convert them into vectors. All parameter features are concatenated into a high-dimensional vector, which is input into the reinforcement learning model as a state vector. For example, a state vector containing 5 affected parameters is a 256-dimensional vector, with the first 50 dimensions representing the features of the first parameter, the next 50 dimensions representing the features of the second parameter, and so on.

[0125] When retrieving the historical optimization scheme corresponding to the similar state from the optimized experience library, the vector similarity calculation method is adopted. The cosine similarity of the current state vector and all historical state vectors in the experience library is calculated, and the top K historical states and their corresponding optimization schemes with the highest similarity are selected. For example, there is a memory overflow scenario at present, and the similarity between the state vector and a certain historical state in the experience library is 0.92, which exceeds the preset threshold 0.85, so the optimization scheme corresponding to the historical state is extracted as priori knowledge. The priori knowledge includes the parameter subset selected by the parameter selection layer and the parameter value generated by the parameter adjustment layer in the historical scenario. The priori knowledge is integrated into the current decision-making process by adjusting the initial strategy network parameters of the model or adding a bias term.

[0126] When the parameter selection layer evaluates the optimization importance of each affected parameter, three factors are considered: parameter importance, change sensitivity and influence range. The parameter importance is evaluated according to the core degree of the parameter in the system, for example, the importance of the database connection pool size parameter is 0.9, and the importance of the log level parameter is 0.6; the change sensitivity reflects the influence degree of parameter change on behavior, for example, the sensitivity of the thread timeout parameter is 0.8, and the sensitivity of the retry count parameter is 0.5; the influence range considers the number of components affected by the parameter, for example, the influence range score of a parameter affecting 5 components is 0.85, and the score of a parameter affecting 2 components is 0.4. The final optimization priority is calculated by weighting these three factors, for example, the weights are 0.4, 0.3 and 0.3 respectively, then the optimization priority of a certain parameter is 0.4*0.9+0.3*0.8+0.3*0.85=0.865. The parameter selection layer selects the parameter subset with the highest priority as the target parameter to be optimized according to the optimization priority, which can be realized by a greedy algorithm or by taking the top N parameters after sorting.

[0127] The parameter adjustment layer generates specific adjustment values for each target parameter. The adjustment process distinguishes between parameter types: for discrete parameters such as log level (DEBUG / INFO / WARN / ERROR), a lookup table method is used to select the optimal value from the preset available values; for continuous parameters such as buffer size, new values are generated by incrementing or decrementing, for example, from the original value of 8MB to 10MB with an increment of 25%. Three factors are considered when generating adjustment values: first, the dependency between parameters is considered, related parameters are processed through pre-defined rules, for example, when increasing the thread pool size, the corresponding queue capacity is also increased; second, performance constraints are applied to ensure that parameters are within a reasonable range, such as thread pool size not exceeding twice the core number; finally, risk control checks are performed to limit adjustments with large change magnitudes, for example, the memory parameter is adjusted within 30% of the original value. The adjustment process adopts a gradual strategy, first making small adjustments and observing the effects, such as improving response time by 10%, then deciding whether to continue adjusting.

[0128] The reward of the parameter selection layer is calculated based on the coverage and precision of the selected parameter set. Coverage measures whether the selected parameters cover the key impact parameters, and precision measures the proportion of truly needed adjustments among the selected parameters. For example, among 10 impacted parameters, 5 are truly needed to adjust, and if the selection layer selects 4 parameters, 3 of which are truly needed to adjust, then the coverage is 3 / 5 = 0.6, and the precision is 3 / 4 = 0.75. The reward of the parameter selection layer can be represented as the weighted sum of coverage and precision, for example, 0.5 x 0.6 + 0.5 x 0.75 = 0.675. The reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment. Performance improvement is obtained by comparing performance indicators before and after parameter adjustment, such as response time reduced from 200 ms to 150 ms, with an improvement rate of 25%; stability is evaluated by volatility indicators, such as standard deviation reduced from 50 to 30, with an improvement rate of 40%. The reward of the parameter adjustment layer can be represented as the weighted sum of performance improvement and stability improvement, for example, 0.7 x 25% + 0.3 x 40% = 29.5%. Finally, the reward of the parameter selection layer and the reward of the parameter adjustment layer are combined by weighting to form the overall optimization target, for example, the total reward is 0.4 x 0.675 + 0.6 x 0.295 = 0.447. The model updates parameters by maximizing the total reward to achieve continuous optimization of the strategy.

[0129] Figure 3 For performance comparison of different parameter optimization methods, the figure compares the optimization efficiency of traditional rule-based parameter tuning, single-layer reinforcement learning, and the hierarchical reinforcement learning method proposed in this paper in memory optimization, response time optimization, and throughput optimization scenarios. From the data, it can be seen that in all test scenarios, the hierarchical reinforcement learning method proposed in this paper shows obvious advantages. In the memory optimization scenario, the optimization efficiency of traditional rule-based parameter tuning, single-layer reinforcement learning, and hierarchical reinforcement learning is 36.0%, 48.0%, and 64.0%, respectively; in the response time optimization scenario, the optimization efficiency of the three methods is 40.0%, 52.0%, and 68.0%, respectively; in the throughput optimization scenario, the optimization efficiency of the three methods is 32.0%, 44.0%, and 60.0%, respectively. The hierarchical reinforcement learning method improves by an average of about 28 percentage points compared to traditional rule-based parameter tuning, and by an average of about 16 percentage points compared to single-layer reinforcement learning. This result verifies the effectiveness of the hierarchical reinforcement learning architecture in dealing with complex software parameter optimization problems, which can generate higher quality parameter optimization schemes by separating the parameter selection and parameter adjustment tasks and combining historical optimization experience as prior knowledge.

[0130] The layered reinforcement learning architecture of the present application enables the parameter optimization decision model to effectively deal with complex software parameter optimization problems. By separating the parameter selection and parameter adjustment two decision tasks, the problem complexity is reduced; by using historical optimization experience as prior knowledge, the learning process is accelerated; by using a hierarchical reward mechanism, the comprehensiveness of parameter selection and the accuracy of parameter adjustment are balanced. The method can generate high-quality parameter optimization schemes for parameter passing problems in software development, improve performance and ensure stability, and provide intelligent parameter optimization support for developers.

[0131] In an optional embodiment, the step of calculating the reward of the parameter adjustment layer based on the performance improvement and stability of the adjustment includes:

[0132] A dynamic influence coefficient between parameters is calculated, the dynamic influence coefficient is calculated based on the product of the partial derivative of the parameter value to the performance index and the ratio of the parameter value to the performance index, the dynamic influence coefficient forms a parameter influence matrix, and the performance improvement reward is calculated according to the parameter influence matrix, the performance improvement reward is based on the dynamic influence coefficient to calculate the performance change before and after the parameter adjustment;

[0133] The time sequence influence characteristics of parameter adjustment are described by amplitude, attenuation coefficient, oscillation frequency and phase shift, a time sequence contribution degree matrix is calculated based on the time sequence influence characteristics, the calculation process of the time sequence contribution degree matrix combines the parameter adjustment amount with the values of the time sequence influence characteristics at different time steps, and the stability reward is calculated according to the time sequence contribution degree matrix, the stability reward is calculated based on the change rate of parameter performance in a sliding time window;

[0134] The time sequence contribution degree matrix is used to allocate the performance improvement reward and the stability reward in time, the reward allocation results at different time steps are combined with the historical optimization experience in a weighted manner to generate a final parameter optimization reward;

[0135] The parameter optimization strategy is updated based on the final parameter optimization reward, a constraint term of parameter correlation degree is introduced in the updating process of the parameter optimization strategy, and the constraint term is calculated based on the dynamic influence coefficient in the parameter influence matrix.

[0136] For example, the dynamic influence coefficient between the parameters reflects the sensitivity of the performance index to the change of the parameter value, which is calculated by the product of the partial derivative of the performance index with respect to the parameter value and the ratio of the parameter value to the performance index. In actual implementation, the difference approximation method can be used to calculate the partial derivative, that is, a small change in the parameter value is given, and the change in the performance index is measured, and the ratio of the two is approximately the partial derivative. For example, the thread pool size is increased from 50 to 55, and the response time is reduced from 200 milliseconds to 190 milliseconds, and the partial derivative is about -2 milliseconds / thread. The parameter value is 50, and the performance index is 200 milliseconds, and the ratio of the two is 0.25. The dynamic influence coefficient is calculated as the product of the partial derivative and the ratio, that is, -2*0.25=-0.5, indicating that the thread pool size has a moderate negative correlation with the response time. The dynamic influence coefficients of all parameters are calculated to form a parameter influence matrix. In the e-commerce system case, part of the parameter influence matrix is as follows: the influence coefficient of the thread pool size on the response time is -0.5, and the influence coefficient of the thread pool size on the throughput is 0.65; the influence coefficient of the connection timeout threshold on the response time is 0.3, and the influence coefficient of the connection timeout threshold on the throughput is -0.2. The matrix comprehensively describes the mutual influence relationship between the parameters, and provides a basis for calculating the performance improvement reward.

[0137] The performance improvement reward is calculated based on the dynamic influence coefficient and the performance change before and after the parameter adjustment. First, the performance index change before and after the parameter adjustment is measured, such as the response time being reduced from 200 milliseconds to 160 milliseconds, with an improvement rate of 20%; the throughput being increased from 1000 TPS to 1200 TPS, with an increase rate of 20%. Then, according to the importance of different performance indexes, weights are allocated, such as the weight of the response time being 0.6 and the weight of the throughput being 0.4. Combined with the influence coefficients in the parameter influence matrix, the contribution of each parameter to the performance improvement is calculated. For example, the contribution of the thread pool size parameter is 0.6*20%*0.5+0.4*20%*0.65=13.2%, indicating that the adjustment of the parameter contributes 13.2% to the overall performance improvement. The contribution rates of all parameters are accumulated to obtain the final performance improvement reward.

[0138] The timing influence characteristics of parameter adjustment are described by four key indicators: amplitude, decay coefficient, oscillation frequency, and phase offset. Amplitude represents the strength of the impact of parameter adjustment, such as the amplitude of the thread pool size parameter being 0.8, indicating a significant impact. The decay coefficient represents the rate at which the impact weakens over time, such as the decay coefficient of the connection pool parameter being 0.3, indicating a rapid weakening of the impact. The oscillation frequency describes the periodicity of the impact fluctuations, such as the oscillation frequency of the cache size parameter being 0.05, indicating a fluctuation period of every 20 time units. The phase offset represents the delay in the appearance of the impact, such as the phase offset of the log level parameter being 5, indicating that the impact will not appear until 5 time units after the adjustment. Each element of the timing contribution matrix represents the contribution of a specific parameter at a specific time step. For example, for the thread pool size parameter, its contribution at the 1st time step is 0.2, at the 5th time step is 0.8, at the 10th time step is 0.4, and at the 20th time step is 0.1. When calculating the timing contribution, the parameter adjustment amount is combined with the values of the timing influence characteristics at different time steps. For example, the thread pool size is increased from 50 to 80, with an increase of 60%, and the impact amplitude is 0.8, so the actual contribution at the peak of the impact (5th time step) is 60% x 0.8 = 48%.

[0139] The stability reward is calculated based on the rate of change of parameter performance within a sliding time window. An appropriate time window size is selected, such as 10 time units, and statistical quantities such as the standard deviation, range, etc. of the performance indicators are calculated within the window. For example, the response time values at 10 consecutive time points are [190, 185, 195, 180, 200, 190, 185, 190, 195, 185] milliseconds, with a standard deviation of about 5.8 milliseconds. Compare the standard deviations before and after the parameter adjustment, such as the standard deviation before adjustment is 10 milliseconds and the standard deviation after adjustment is 5.8 milliseconds, with an improvement rate of 42%. Calculate the stability reward based on the improvement rate, such as the stability reward is 42% x 0.5 = 21%, where 0.5 is the weight coefficient of the stability reward.

[0140] The performance improvement reward is concentrated in the early adjustment period, while the stability reward is realized after the system stabilizes. Through the timing contribution matrix, different types of rewards are allocated to different time steps. For example, the performance improvement reward is 25%, and the timing contribution at the 5th time step is 0.8, so the performance reward allocated at this time step is 25% x 0.8 = 20%; the stability reward is 21%, and the timing contribution at the 15th time step is 0.6, so the stability reward allocated at this time step is 21% x 0.6 = 12.6%.

[0141] Retrieving the historical reward distribution of similar scenarios from the optimized experience library, for example, the reward of the 5th time step in a certain historical scenario is 15%, and the current calculated reward is 20%, then a weighted average can be used, such as 0.7*20%+0.3*15%=18.5%, as the final reward value of this time step. Perform similar operations on all time steps, and sum the rewards of each time step after discounting to obtain the final parameter optimization reward.

[0142] Updating the parameter optimization strategy based on the final parameter optimization reward. Using the policy gradient method, adjust the policy network parameters according to the reward signal. In the update process, a constraint term based on the parameter correlation degree is introduced, which is calculated based on the dynamic influence coefficient in the parameter influence matrix. For highly correlated parameter pairs, such as thread pool size and queue capacity (correlation degree is 0.85), the constraint term encourages the coordinated adjustment of these parameters to avoid performance fluctuations caused by individual adjustments. For example, increase the thread pool size and appropriately increase the queue capacity, rather than just increase one of the parameters. The strength of the constraint term can be dynamically adjusted according to the parameter correlation degree, the higher the correlation degree, the stronger the constraint. By introducing the constraint term, the parameter optimization strategy can learn the interdependence between parameters and generate more coordinated parameter adjustment schemes.

[0143] Figure 4 A performance improvement comparison chart is calculated for different methods. The horizontal axis represents the time step after parameter adjustment (in minutes), and the vertical axis represents the performance improvement percentage. The method of the present invention (dynamic influence coefficient + time contribution degree matrix) shows obvious advantages at each time step, especially in the initial optimization effect, which improves rapidly and maintains stable high performance in long-term operation. The advantage of the present invention is mainly due to the dynamic influence coefficient which accurately quantifies the mutual influence between parameters, and the time contribution degree matrix which effectively captures the long-term effect of parameter adjustment.

[0144] The parameter adjustment layer reward calculation method of the present invention accurately quantifies the influence degree of parameters on performance through dynamic influence coefficients, comprehensively captures the time sequence effect of parameter adjustment through time contribution degree matrices, and integrates performance improvement and system stability into a unified reward framework; not only considering the immediate effect of parameter adjustment, but also focusing on long-term impact, and improving the accuracy of reward estimation through the integration of historical experience. The introduction of parameter correlation degree constraint enables the optimization strategy to generate a coordinated and consistent parameter adjustment scheme, significantly improving the performance optimization effect and running stability of the software system, providing efficient and reliable technical support for automatic parameter tuning of complex software systems.

[0145] In a second aspect of the embodiment of the present invention, an electronic device is provided, comprising:

[0146] a processor;

[0147] a memory for storing processor-executable instructions;

[0148] The processor is configured to invoke instructions stored in the memory to perform the method described above.

[0149] The third aspect of the embodiment of the present application provides a computer readable storage medium, which stores computer program instructions, and the computer program instructions are executed by a processor to implement the method described above.

[0150] The present application can be a method, apparatus, system and / or computer program product. The computer program product can include a computer readable storage medium having computer readable program instructions stored therein for implementing various aspects of the present application.

[0151] Finally, it should be noted that: the above embodiments are only used to illustrate the technical solutions of the present application, and not to limit them; although the present application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand: it can still modify the technical solutions recorded in the foregoing embodiments, or make equivalent replacement for part or all of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the scope of the technical solutions of the embodiments of the present application.

Claims

1. An artificial intelligence-based software development upstream and downstream task parameter transfer and optimization method, characterized in that: include: Constructing a parameter knowledge graph for software development, which includes a parameter mapping knowledge base, a task dependency library, and an optimization experience library; Receive parameter transfer data during the software development process, process the parameter transfer data using a graph neural network, match and analyze the parameter transfer data with information in the parameter mapping knowledge base and the task dependency library, and generate a parameter dependency graph, wherein the parameter dependency graph is used to characterize the transfer path and influence intensity between parameters; Real-time monitoring of parameter transfer during software development. When a parameter change is detected, the impact range of the parameter change is analyzed based on the parameter dependency graph to obtain a set of affected parameter nodes. Constructing a parameter optimization decision model, wherein the parameter optimization decision model takes the affected parameter node set as state input, retrieves optimization solutions for similar scenarios from the optimization experience library as prior knowledge, and uses a hierarchical reinforcement learning strategy to generate parameter optimization solutions, wherein the hierarchical reinforcement learning strategy includes a parameter selection layer and a parameter adjustment layer; The parameter selection layer determines the target parameters to be optimized, and the parameter adjustment layer generates specific parameter values, specifically including: the parameter optimization decision model includes a hierarchical reinforcement learning architecture, the hierarchical reinforcement learning architecture is composed of an upper parameter selection layer and a lower parameter adjustment layer with a shared state space and an independent action space, and the action output of the parameter selection layer serves as a constraint condition for the parameter adjustment layer; the affected parameter node set is converted into a state vector, the state vector serves as the input of the hierarchical reinforcement learning architecture, and the historical optimization scheme corresponding to the similar state is retrieved from the optimization experience library, and the decision results in the historical optimization scheme are extracted as the prior knowledge of the current decision; the parameter selection layer is used to evaluate The optimization importance of each affected parameter is calculated based on parameter importance, change sensitivity and impact range, and the optimization priority is calculated, and the parameter subset with the highest priority is selected as the target parameters to be optimized; the parameter adjustment layer generates an adjustment value for each target parameter, and the generation process of the adjustment value takes into account the dependency relationship between parameters, performance constraints and risk control factors; a hierarchical reward mechanism is used to update the parameter optimization decision model, and the reward of the parameter selection layer is calculated based on the coverage and accuracy of the selected parameter set, and the reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment. The rewards of the parameter selection layer and the parameter adjustment layer are weighted and combined to form the overall optimization goal; The parameter optimization scheme is executed, and the optimization effect is recorded and stored as new experience data in the optimization experience library.

2. The method according to claim 1, characterized in that The steps of constructing a parameter knowledge graph for software development, wherein the parameter knowledge graph includes a parameter mapping knowledge base, a task dependency library, and an optimization experience library, include: Collect multi-source parameter data during the software development process, including parameter definition data in the code repository, parameter specification data in the development documents, and parameter transfer data in the operation log; construct the basic structure of the parameter knowledge graph based on the multi-source parameter data, taking parameters, tasks, and optimization solutions as graph entities, and taking the mapping relationship between parameters, the dependency relationship between tasks, the association relationship between parameters and tasks, and the interaction relationship between optimization solutions and parameters as edges in the graph, to form a multi-heterogeneous knowledge network structure; Standardize parameter names based on morphological restoration, calculate semantic similarity between parameters, determine parameter mapping relationships based on a preset similarity threshold, and generate a parameter mapping knowledge base; establish parameter format conversion rules and store them in the parameter mapping knowledge base; Extract the calling relationships and parameter flow paths between tasks to obtain static task dependencies, track the parameter transfer during runtime to obtain dynamic task association information, and use a weighted fusion method to calculate the coupling degree between tasks. The weighted fusion method comprehensively considers the parameter sharing degree and transfer frequency to generate a task dependency library. Formalize historical optimization plans, extract optimization rules, calculate the similarity between optimization plans, and generate an optimization experience database; The parameter knowledge graph is subjected to consistency check and integrity verification, and an incremental knowledge update mechanism is established.

3. The method according to claim 1, characterized in that The steps of receiving parameter transfer data in the software development process, processing the parameter transfer data using a graph neural network, matching and analyzing the parameter transfer data with information in the parameter mapping knowledge base and the task dependency library, and generating a parameter dependency graph, wherein the parameter dependency graph is used to characterize the transfer path and influence intensity between parameters, include: Extracting parameter type codes, parameter name semantic codes, parameter value range codes, and parameter context feature codes from the parameter transfer data to generate a parameter feature vector; extracting transfer type, transfer frequency, and timing features from the parameter transfer data to generate a parameter transfer relationship feature; Matching the parameter feature vector with the information in the parameter mapping knowledge base, calculating the parameter semantic similarity, and determining the mapping relationship between the parameters based on the parameter semantic similarity; matching the parameter transfer relationship feature with the information in the task dependency relationship library, and calculating the task dependency strength; Constructing a graph structure, using the parameters with mapping relationships as nodes in the graph, using the parameter transfer relationship characteristics as attributes of the edges in the graph, and using the parameter feature vectors as initial features of the nodes; The constructed graph structure is processed using a graph neural network. Node messages are generated based on the parameter feature vectors of the nodes and the parameter transfer relationship features of the edges. The generated node messages are aggregated to obtain updated features of the nodes. The connection strength between nodes is calculated based on the updated features. A parameter dependency graph is generated based on the connection strength, where the parameter dependency graph represents the transfer path and influence strength between parameters, and the influence strength is determined by the parameter semantic similarity, the task dependency strength, and the connection strength.

4. The method according to claim 3, characterized in that Generating node messages based on the parameter feature vectors of the nodes and the parameter transfer relationship features of the edges, aggregating the generated node messages to obtain updated features of the nodes; and calculating the connection strength between the nodes based on the updated features includes: Generate a node message based on the parameter feature vector and the parameter transfer relationship feature of the edge, calculate the attention weights of features of different dimensions, and multiply the attention weights by the feature conversion matrix to enhance the node message; The enhanced node messages are hierarchically aggregated. Local message aggregation is performed within the local neighborhood range. The node messages of local neighbor nodes are weightedly combined based on the local aggregation weight to obtain local aggregate features. Global message aggregation is performed globally. The local aggregate features of global neighbor nodes are weightedly combined based on the global aggregation weight. The local aggregate features and global aggregate features are balanced through the gating parameters to obtain the updated features of the node. The connection strength between nodes is calculated based on the updated features, and the connection strength is obtained based on a weighted combination of direct connection strength, indirect connection strength and task association strength, wherein the direct connection strength is calculated based on the similarity of node features, the indirect connection strength is calculated based on the importance of the transmission path between nodes, and the task association strength is calculated based on the dependency relationship of the tasks to which the nodes belong.

5. The method according to claim 1, wherein The steps of monitoring parameter transfer in the software development process in real time and, when a parameter change is detected, analyzing the impact range of the parameter change based on the parameter dependency graph and obtaining the affected parameter node set include: Deploy a parameter change listener to capture parameter changes in real time through code submission hooks, configuration file monitoring, and runtime parameter tracking. When a parameter change is detected, the identifier, change type, and change value range of the changed parameter are recorded. The node corresponding to the changed parameter is located in the parameter dependency graph and marked as the change source node. Starting from the change source node, the parameter dependency graph is traversed, and the node influence coefficient is calculated based on the connection strength between nodes, where the node influence coefficient is the weighted product of all connection strengths on the path between the change source node and the node. For each traversed node, the sensitivity coefficient is calculated based on the parameter feature vector of the node, and the node influence coefficient is multiplied by the sensitivity coefficient to obtain the node influence value. When the influence value is greater than the preset influence threshold, the node is added to the affected node set.

6. The method according to claim 1, characterized in that The reward of the parameter adjustment layer is calculated based on the performance improvement and stability after adjustment, including the following steps: Calculating dynamic influence coefficients between parameters, where the dynamic influence coefficients are calculated based on the product of the partial derivative of the parameter value with respect to the performance index and the ratio of the parameter value to the performance index, and forming a parameter influence matrix with the dynamic influence coefficients; calculating performance improvement rewards based on the parameter influence matrix, where the performance improvement rewards are weighted based on the dynamic influence coefficients and the performance change before and after the parameter adjustment; The timing impact characteristics of parameter adjustment are described by amplitude, attenuation coefficient, oscillation frequency, and phase offset. A timing contribution matrix is ​​calculated based on the timing impact characteristics. The calculation process of the timing contribution matrix combines the parameter adjustment amount and the values ​​of the timing impact characteristics at different time steps. The stability reward is calculated based on the timing contribution matrix. The stability reward is calculated based on the rate of change of parameter performance within the sliding time window. The time series contribution matrix is ​​used to distribute the performance improvement reward and stability reward in time series, and the reward distribution results at different time steps are weighted and combined with historical optimization experience to generate the final parameter optimization reward; The parameter optimization strategy is updated based on the final parameter optimization reward. A parameter correlation constraint is introduced during the updating process of the parameter optimization strategy. The constraint is calculated based on the dynamic influence coefficient in the parameter influence matrix.

7. An electronic device, characterized in that: include: processor; a memory for storing processor-executable instructions; The processor is configured to call the instructions stored in the memory to execute the method according to any one of claims 1 to 6.

8. A computer-readable storage medium having computer program instructions stored thereon, characterized in that: When the computer program instructions are executed by a processor, the method according to any one of claims 1 to 6 is implemented.

Images