A method for service life cycle management of computer software

Abstract

The application discloses a service life cycle management method for computer software, relates to the technical field of service life cycle management, and constructs a heterogeneous graph based on original data of software services, takes various software service entity types of the heterogeneous graph as entity nodes, takes corresponding relations between entities as edges, processes the heterogeneous graph by adopting a network structure encoder, obtains a node representation matrix after network structure coding, filters the node representation matrix after network structure coding based on predefined node entity type labels, obtains a same-class node set, constructs a same-class neighbor subgraph based on a connection relation between nodes of the same-class node set and the heterogeneous graph, codes the same-class neighbor subgraph, obtains a node representation matrix after same-class enhanced coding, cooperatively optimizes the node representation matrix after network structure coding and the node representation matrix after same-class enhanced coding, obtains unified node representation, performs analysis and management, and obtains service life cycle management decision results.

Description

Technical Field

[0001] This invention relates to the field of service lifecycle management technology, and in particular to a service lifecycle management method for computer software. Background Technology

[0002] In recent years, with the widespread application of cloud computing and microservice architecture, the complexity and scale of software services have continued to grow. Service lifecycle management technology has become a key support for ensuring the continuous and stable operation of software. Effective service lifecycle management can not only achieve real-time monitoring of service status and rapid fault location and repair, but also optimize service upgrades, resource scheduling and user experience through data-driven decision-making, thereby significantly improving the reliability, maintainability and business continuity of the system.

[0003] However, existing service lifecycle management methods still have significant shortcomings. On the one hand, most methods only model single types of data or local relationships, failing to fully integrate multi-source heterogeneous information such as service metadata, operation logs, and user feedback, resulting in an incomplete characterization of service status. On the other hand, traditional graph learning methods often ignore the semantic differences and structural characteristics between different types of entities, making it difficult to effectively integrate heterogeneous relationships with deep semantic connections between similar entities, thus limiting the model's representation and reasoning capabilities in complex service scenarios. Summary of the Invention

[0004] The technical problem addressed by this invention is that existing service lifecycle management methods still have significant shortcomings. On the one hand, most methods only model single-type data or local relationships, failing to fully integrate multi-source heterogeneous information such as service metadata, operation logs, and user feedback, resulting in an incomplete characterization of service status. On the other hand, traditional graph learning methods often ignore the semantic differences and structural characteristics between different types of entities, making it difficult to effectively integrate heterogeneous relationships with deep semantic connections between similar entities, thus limiting the model's representation and reasoning capabilities in complex service scenarios.

[0005] To solve the above-mentioned technical problems, the present invention provides the following technical solution: a service lifecycle management method for computer software, comprising the following steps: Step S1: Construct a heterogeneous graph based on the original data of the software services. The heterogeneous graph uses various software service entity types as entity nodes and the correspondence between entities as edges. Step S2: Process the heterogeneous graph using a network structure encoder to obtain the node representation matrix after network structure encoding; Step S3: Based on the predefined node entity type labels, filter the node representation matrix after network structure encoding to obtain a set of nodes of the same category. Based on the connection relationship between the set of nodes of the same category and the nodes of the heterogeneous graph, construct a neighbor subgraph of the same category. Encode the neighbor subgraph to obtain the node representation matrix after enhanced encoding of the same category. Step S4: Perform collaborative optimization on the node representation matrix after network structure encoding and the node representation matrix after same-class augmentation encoding to obtain a unified node representation; Step S5: Based on the unified node representation, the system is parsed and managed to obtain the service lifecycle management decision results.

[0006] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S1 involves constructing a heterogeneous graph based on the original data of the software service. The heterogeneous graph uses multiple software service entity types as entity nodes and the correspondence between entities as edges. Step S1 includes steps S101, S102, S103, S104 and S105; Step S101: Obtain the raw data of the software service lifecycle. The raw data includes software service metadata, service operation logs, user feedback data, and deployment environment information. Step S102: Perform entity extraction processing on the original data to generate a structured entity table; The entity extraction process includes identifying software service metadata and service operation logs to obtain the service entity to be processed and the version entity to be processed, and standardizing the service entity to be processed and the version entity to be processed to obtain the service entity and the version entity respectively. Identify user feedback data and service operation logs to obtain user entities to be processed and fault entities to be processed. Standardize user entities to be processed and fault entities to be processed to obtain user entities and fault entities respectively. The deployment environment information and service operation logs are identified to obtain the node entity to be processed and the environment entity to be processed. The node entity to be processed and the environment entity to be processed are standardized to obtain the node entity and the environment entity respectively. The process of generating a structured entity table includes assigning a unique entity identifier and an entity type identifier to each entity among the service entity, version entity, user entity, fault entity, node entity, and environment entity. Create a corresponding data record for each entity. Each data record includes the entity ID, entity type, and entity attribute information. Entity types include service entities, version entities, user entities, fault entities, node entities, and environment entities; The entity ID stores the unique entity identifier assigned to the entity, the entity type identifier is stored by entity type, and the entity attribute information is stored by entity attribute information. Aggregate the data records of all entities to obtain a structured entity table; Step S103: Perform feature calculation processing on the structured entity table to generate an entity feature matrix; The feature calculation process includes, for the service entities in the structured entity table, calculating the number of calls, average response time and error rate of the service entities based on the service operation logs; The number of faults associated with service entities is counted based on user feedback data; The number of calls, average response time, error rate, and number of failures are aggregated by entity ID to obtain an entity feature matrix.

[0007] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S104 involves establishing a correspondence between entities based on the original data. The process of establishing the correspondence between entities includes establishing the publication relationship between the service entity and the corresponding version entity based on the association field between the service record and the version record in the software service metadata; Establish the dependencies between service entities based on the call chain in the service operation log; Based on user feedback data and user access records in service operation logs, establish the usage relationship between user entities and service entities; Based on the service information associated with user feedback data and error records in the service operation log, establish the triggering relationship between service entities and faulty entities; Based on the service instances and server nodes recorded in the deployment environment information, establish the deployment relationship between service entities and node entities; The publishing relationships, dependency relationships, usage relationships, triggering relationships, and deployment relationships are stored in the form of an edge list, forming a relationship edge table; Each edge record in the relation edge table includes the source entity ID, the target entity ID, and the relation type; The source entity ID and target entity ID are entity IDs in the structured entity table, and the relationship type is a correspondence between entities.

[0008] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S105 involves constructing a heterogeneous graph based on a structured entity table, a relational edge table, and an entity feature matrix. Based on the entity ID and entity type in the structured entity table, construct a set of nodes for a heterogeneous graph; Based on the entity types in the structured entity table, a node type mapping function is constructed, which maps each node in the node set to the corresponding entity type. Based on the source entity ID and target entity ID in the relation edge table, construct the edge set of the heterogeneous graph; Based on the relation type identifier in the relation edge table, an edge type mapping function is constructed, which maps each edge in the edge set to the corresponding relation type. The entity feature matrix is ​​used as the initial feature of the nodes in the heterogeneous graph; The output consists of a heterogeneous graph composed of a set of nodes, a set of edges, a node type mapping function, an edge type mapping function, and initial node features.

[0009] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S2 involves processing the heterogeneous graph using a network structure encoder to obtain a node representation matrix after network structure encoding. Step S2 includes steps S201 and S202; Step S201: Perform node feature transformation processing on the heterogeneous graph to obtain the transformed node feature matrix; The node feature transformation process includes obtaining the node type mapping function and the initial node features in the heterogeneous graph; Based on the node type mapping function, query the entity type corresponding to each node in the heterogeneous graph; Linear transformation parameters are configured for each entity type, including a weight matrix and a bias term; For each node in the heterogeneous graph, the initial node features are linearly transformed according to the linear transformation parameters corresponding to the entity type of each node to obtain intermediate linear features; The intermediate linear features are nonlinearly activated by the ReLU function to obtain the transformed features of the node in a unified feature space. The transformed features of all nodes in the heterogeneous graph are aggregated to form a transformed node feature matrix.

[0010] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S202 involves performing network structure encoding processing on the transformed node feature matrix and heterogeneous graph to obtain the node representation matrix after network structure encoding. The network structure encoding process includes obtaining the transformed node feature matrix and heterogeneous graph; Each type of relationship in the heterogeneous graph is associated with an attention vector through a network structure encoder; Based on the edge type mapping function in the transformed heterogeneous graph, the different relationship types between each node and its neighboring nodes are identified. For each node in the node set, perform relation-level attention encoding. For each relation type, sum the transformed features of all neighbor nodes under that relation type to obtain the neighbor aggregation feature of that relation type. The attention vector corresponding to the relationship type is multiplied by the neighbor aggregation feature, and the result is processed by a non-linear activation function to obtain the original attention score corresponding to the relationship type. The original attention scores for all relation types are normalized to obtain the normalized attention weights for the relation types. Based on the normalized attention weights, the neighbor aggregation features of the node under each relation type are weighted and fused to obtain a weighted fused feature vector. Type-level attention aggregation is performed on the weighted fused feature vectors of all nodes in the node set; The process of type-level attention aggregation specifically includes: using a fully connected network, performing a linear transformation on the weighted fusion feature vector of each node in the node set under the relation type to obtain a linearly transformed feature vector; and using the ReLU function to calculate the non-linear activation function on the linearly transformed feature vector to obtain the intermediate feature vector corresponding to each node. Perform a dot product operation between the intermediate feature vector and the attention vector of each node to obtain the individual importance score of the node under the relationship type; The average importance score of all nodes under the given relationship type is calculated to obtain the global importance score corresponding to the relationship type. Based on the global importance scores of all relation types, normalized aggregate weights are calculated for each relation type using the Softmax function; Based on the normalized aggregation weights, the weighted fusion feature vectors of each node under different relation types are weighted and summed to obtain the network structure encoding representation of the node. The network structure encoding representations of all nodes in the node set are aggregated to form the node representation matrix after network structure encoding and the corresponding final normalized attention weights.

[0011] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, in step S3, based on predefined node entity type labels, the node representation matrix after network structure encoding is filtered to obtain a set of nodes of the same category; based on the connection relationship between the set of nodes of the same category and the nodes of the heterogeneous graph, a neighbor subgraph of the same category is constructed; the neighbor subgraph is encoded to obtain a node representation matrix after enhanced encoding of the same category. Step S3 includes steps S301, S302, S303, S304 and S305; Step S301, wherein the process of same-category enhanced encoding includes obtaining the node representation matrix, heterogeneous graph and predefined service operation labels after the network structure is encoded; Step S302: Based on the service running label, filter out all other nodes with the same label in the heterogeneous graph for the current node to form an initial set of nodes of the same category; Calculate the semantic similarity between the current node and every node in the initial set of nodes of the same category; Based on semantic similarity, select the top K nodes with the highest similarity from the initial set of nodes of the same category, and use them as the final set of neighboring nodes of the same category for the current node; Step S303: Traverse all nodes in the graph and repeat step S302 to determine the final set of neighboring nodes of the same category for each node. Based on the final set of neighboring nodes of the same category for all nodes and the connection relationships between nodes in the corresponding heterogeneous graph, a neighboring subgraph of the same category is constructed. The nodes of the neighboring subgraph are composed of the union of the final set of neighboring nodes of the same category, and the edges of the neighboring subgraph are composed of the edges that actually exist in the heterogeneous graph for all nodes. Step S304: Perform graph convolutional coding on the same-category neighbor subgraph. The specific process includes: for each node in the same-category neighbor subgraph, normalize and aggregate the representations of all same-category neighbor nodes, and perform linear transformation and nonlinear activation calculation on the aggregation result to obtain the enhanced coded representation of the node. Step S305: Aggregate the enhanced codes of all nodes in the node set to form nodes with the same enhanced codes.

[0012] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S4 involves co-optimizing the node representation matrix after network structure encoding and the node representation matrix after enhanced encoding of the same category to obtain a unified node representation. Step S40 includes steps S401 and S402; Step S401, the collaborative optimization process includes obtaining the node representation matrix after network structure encoding and the node representation matrix after same-class enhancement encoding; Based on the relation edge table, node association rules are determined. Specifically, if two nodes in the heterogeneous graph are connected by a meta-path consisting of a relation type identifier stored in the relation edge table in a preset order or greater, then the two nodes are positive association sample nodes; otherwise, they are negative association sample nodes. Based on node association rules, the similarity between the network structure encoding representation of each node and the same-class augmented encoding representation of all nodes in the associated positive sample node set is calculated, and all positive sample similarities are aggregated to obtain the positive sample aggregate similarity. Calculate the similarity between the network structure encoding representation of each node and the same-class augmented encoding representation of all nodes in the associated positive sample node set and the associated negative sample node set, and aggregate all similarities to obtain the overall aggregated similarity; Based on the positive sample aggregation similarity and the overall aggregation similarity, the contrast loss component of each node is calculated; Step S402: For nodes with predefined service operation labels, calculate the predicted probability of each predefined category based on the network structure encoding representation; The classification optimization components for all nodes are calculated based on the actual service operation labels and predicted probabilities. Based on the comparison optimization component and classification optimization component of all nodes, the overall optimization target value is obtained by weighted summation. Based on the overall optimization target value, the node representation matrix after network structure encoding and the node representation matrix after the same category of enhanced encoding are adjusted and merged to generate the final node representation matrix.

[0013] As a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S5 involves parsing and performing management based on a unified node representation to obtain service lifecycle management decision results. Step S5 includes steps S501 and S502; Step S501: Perform label smoothing and propagation processing on the final node representation matrix to obtain stable labels; The label smoothing and propagation process includes obtaining the final node representation matrix and determining the initial predicted label for each node based on the final node representation matrix using a classifier. The initial predicted label for each node is processed by a label smoothing algorithm to obtain a smoothed label probability distribution; A label propagation matrix is ​​constructed based on the connection relationships between nodes in the heterogeneous graph; The smoothed label probability distribution is used as the initial value for iteration. The label propagation matrix is ​​used for iterative calculation to update the label probability distribution of all nodes in the heterogeneous system until the difference in label probability distribution between nodes is less than a preset threshold. Output the probability distribution of node labels that have reached convergence after iterative updates, as the final judgment result of the service lifecycle management task.

[0014] In a preferred embodiment of the service lifecycle management method for computer software described in this invention, step S502 involves performing service lifecycle management decision processing based on the final determination result to generate a management decision result. The processing is carried out based on the management decision results, specifically including identifying abnormal nodes and forming a set of faulty nodes based on the probability distribution of node labels in the final judgment results. Based on the connection relationship between nodes in the heterogeneous graph, reverse tracing is performed along the direction of the relationship edge. Starting from the nodes in the fault node set as the fault point, all upstream nodes and connection paths connecting the fault points are searched to form a potential root cause path set. Based on the final normalized attention weights, the weights of each path in the potential root cause path set are aggregated to obtain the propagation confidence of each path. The path with the highest propagation confidence is selected as the main fault propagation path, and the starting node of the path is identified as the key fault root cause node. A fault root cause location report is generated based on the main fault propagation path and key fault root cause nodes.

[0015] The beneficial effects of this invention are as follows: By constructing a heterogeneous graph integrating multi-source data such as service metadata, operation logs, and user feedback, and by innovatively introducing a collaborative optimization mechanism of network structure coding and same-category enhanced coding, a unified representation of multi-level and multi-type relationships of software service elements is achieved. This method effectively solves the limitations of existing technologies, such as fragmented multi-source information, insufficient semantic expression, and difficulty in integrating heterogeneous relationships and deep associations. This design can not only comprehensively and deeply depict the service operation status, but also significantly enhance the ability to capture semantic associations by using attention mechanisms and graph convolution technology, thereby greatly improving the accuracy of fault root cause localization and the reliability of management decisions, and providing more comprehensive, accurate, and efficient intelligent support for the full life cycle management of complex software service systems. Attached Figure Description

[0016] Figure 1 This is a flowchart illustrating the steps of a service lifecycle management method for computer software, provided as an embodiment of the present invention. Detailed Implementation

[0017] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments.

[0018] Example, refer to Figure 1 As an embodiment of the present invention, a service lifecycle management method for computer software is provided, comprising the following steps: Step S1: Construct a heterogeneous graph based on the original data of the software services. The heterogeneous graph uses various software service entity types as entity nodes and the correspondence between entities as edges. Step S2: Process the heterogeneous graph using a network structure encoder to obtain the node representation matrix after network structure encoding; Step S3: Based on the predefined node entity type labels, filter the node representation matrix after network structure encoding to obtain a set of nodes of the same category. Based on the connection relationship between the set of nodes of the same category and the nodes of the heterogeneous graph, construct a neighbor subgraph of the same category. Encode the neighbor subgraph to obtain the node representation matrix after enhanced encoding of the same category. Step S4: Perform collaborative optimization on the node representation matrix after network structure encoding and the node representation matrix after same-class augmentation encoding to obtain a unified node representation; Step S5: Based on the unified node representation, the system is parsed and managed to obtain the service lifecycle management decision results.

[0019] In one embodiment, a full-link service lifecycle management architecture is constructed, encompassing multi-source heterogeneous data fusion, deep semantic representation, and intelligent decision-making. Specifically, in step S1, by integrating multi-source data such as software service metadata, runtime logs, and user feedback from the original data, a heterogeneous graph is constructed with various service entity types as nodes and diverse relationships between entities as edges. This achieves unified modeling of the panoramic information of complex service systems at the data structure level, solving the information silo problem. In step S2, a network structure encoder is introduced, utilizing relational attention to encode the heterogeneous graph, generating a node representation matrix that captures heterogeneous dependencies between nodes. This effectively characterizes the structural features of service entity types under diverse relationships. To further enhance the deep semantic association between similar entities, in step S3, based on predefined entity type labels, nodes of the same category are selected from the heterogeneous graph. The system constructs a neighbor subgraph and extracts enhanced representations of the same category through graph convolutional coding, thereby strengthening local consistency at the semantic level. Step S4 uses a collaborative optimization mechanism to fuse and optimize the network structure coding and the enhanced coding of the same category, generating a unified and robust node representation. This design not only achieves the complementarity of heterogeneous and homogeneous information, but also improves the model's representation ability under complex relationships. Finally, in step S5, based on the unified node representation, label propagation and root cause tracing are performed to output service management decisions such as fault location and impact analysis, thus completing the closed loop from data to knowledge and then to decision. The overall architecture, through the progressive design of heterogeneous fusion, structure coding, semantic enhancement, collaborative optimization and decision output, achieves a panoramic depiction of service status, accurate location of fault root causes and interpretable output of management decisions, significantly improving the intelligence level and reliability of lifecycle management.

[0020] Step S1: Construct a heterogeneous graph based on the original data of the software services. The heterogeneous graph uses various software service entity types as entity nodes and the correspondence between entities as edges. Step S1 includes steps S101, S102, S103, S104 and S105; Step S101: Obtain the raw data of the software service lifecycle. The raw data includes software service metadata, service operation logs, user feedback data, and deployment environment information. Step S102: Perform entity extraction processing on the original data to generate a structured entity table; The entity extraction process includes identifying software service metadata and service operation logs to obtain the service entity to be processed and the version entity to be processed, and standardizing the service entity to be processed and the version entity to be processed to obtain the service entity and the version entity respectively. Identify user feedback data and service operation logs to obtain user entities to be processed and fault entities to be processed. Standardize user entities to be processed and fault entities to be processed to obtain user entities and fault entities respectively. The deployment environment information and service operation logs are identified to obtain the node entity to be processed and the environment entity to be processed. The node entity to be processed and the environment entity to be processed are standardized to obtain the node entity and the environment entity respectively. The process of generating a structured entity table includes assigning a unique entity identifier and an entity type identifier to each entity among the service entity, version entity, user entity, fault entity, node entity, and environment entity. Create a corresponding data record for each entity. Each data record includes the entity ID, entity type, and entity attribute information. Entity types include service entities, version entities, user entities, fault entities, node entities, and environment entities; The entity ID stores the unique entity identifier assigned to the entity, the entity type identifier is stored by entity type, and the entity attribute information is stored by entity attribute information. Aggregate the data records of all entities to obtain a structured entity table; Step S103: Perform feature calculation processing on the structured entity table to generate an entity feature matrix; The feature calculation process includes, for the service entities in the structured entity table, calculating the number of calls, average response time and error rate of the service entities based on the service operation logs; The number of faults associated with service entities is counted based on user feedback data; The number of calls, average response time, error rate, and number of failures are aggregated by entity ID to obtain an entity feature matrix.

[0021] Step S104: Establish the correspondence between entities based on the original data; The process of establishing the correspondence between entities includes establishing the publication relationship between the service entity and the corresponding version entity based on the association field between the service record and the version record in the software service metadata; Establish the dependencies between service entities based on the call chain in the service operation log; Based on user feedback data and user access records in service operation logs, establish the usage relationship between user entities and service entities; Based on the service information associated with user feedback data and error records in the service operation log, establish the triggering relationship between service entities and faulty entities; Based on the service instances and server nodes recorded in the deployment environment information, establish the deployment relationship between service entities and node entities; The publishing relationships, dependency relationships, usage relationships, triggering relationships, and deployment relationships are stored in the form of an edge list, forming a relationship edge table; Each edge record in the relation edge table includes the source entity ID, the target entity ID, and the relation type; The source entity ID and target entity ID are entity IDs in the structured entity table, and the relationship type is a correspondence between entities.

[0022] Step S105: Construct a heterogeneous graph based on the structured entity table, relation edge table, and entity feature matrix; Based on the entity ID and entity type in the structured entity table, construct a set of nodes for a heterogeneous graph; Based on the entity types in the structured entity table, a node type mapping function is constructed, which maps each node in the node set to the corresponding entity type. Based on the source entity ID and target entity ID in the relation edge table, construct the edge set of the heterogeneous graph; Based on the relation type identifier in the relation edge table, an edge type mapping function is constructed, which maps each edge in the edge set to the corresponding relation type. Use the entity feature matrix as the initial features of the nodes in the heterogeneous graph; The output consists of a heterogeneous graph composed of a set of nodes, a set of edges, a node type mapping function, an edge type mapping function, and initial node features.

[0023] In one embodiment, step S1 transforms the multi-source heterogeneous raw data into a structured heterogeneous graph. Specifically, it includes standardizing the raw entities identified in the software service metadata, service operation logs, user feedback data, and deployment environment information. The entities include at least service entities, version entities, user entities, fault entities, node entities, and environment entities. The standardization process is completed through unified naming, disambiguation, and format conversion. This includes unified naming, for example, mapping ServiceA and service_a to a unified identifier service_A; eliminating ambiguity, for example, distinguishing between timeouts as fault descriptions and timeout services as service names based on context; and format conversion, for example, converting unstructured text descriptions into key-value pairs. After standardization, each entity is assigned a unique entity ID and a predefined entity type identifier. The entity ID is, for example, a UUID or an auto-incrementing serial number. The predefined entity type refers to a set of types determined and maintained in a fixed list during the design phase based on general knowledge of the software service domain and the management objectives of this method. For example, in this embodiment, the six types explicitly listed are service, version, user, fault, node, and environment. Each entity's attribute information includes, for example, the creation time and team to which the service entity belongs; the build number and release time of the version entity; the registration channel and level of the user entity; the severity level and timestamp of the fault entity; the IP address and number of CPU cores of the node entity; and the name, region, entity ID, and entity type of the environment entity, all stored together to ultimately generate a structured entity table. Next, based on clear business logic and data associations, correspondences between entities are established. Specific rules include: establishing publishing relationships based on the binding fields of service records and version records in metadata, such as service_id:version_id; parsing call chain fields in service operation logs, such as trace_id or span information; if the log record indicates that service A called service B, then a dependency relationship from A to B is established; matching the user ID field in user feedback data or access logs with the accessed or reported service ID field to establish usage relationships; associating the fault report ID in error logs or user feedback with its explicitly associated service ID to establish triggering relationships; and establishing deployment relationships based on the mapping records of service instances and host node or container IDs in deployment configuration information or monitoring data. Publishing relationships, dependency relationships, usage relationships, triggering relationships, and deployment relationships are stored as a relational edge table in the form of an edge list. Each record includes the source entity ID, target entity ID, and relationship type identifier. Next, feature calculation processing is performed to generate an entity feature matrix. This feature calculation processing mainly targets the service entities that are most critical in the operational status analysis. Based on a preset statistical time window, such as the service operation log of the most recent hour, the number of calls, average response time, and error rate of each service entity are calculated. At the same time, the number of faults directly associated with each service entity is counted based on user feedback data. The rows of the entity feature matrix correspond to the unique IDs of all entities in sequence, and their columns correspond to the feature dimensions. For a service entity, its corresponding row vector is filled with the numerical features calculated above, namely the number of calls, average response time, error rate, and number of associated faults, after normalization. For other types of entities, such as users and nodes, their row vectors are constructed directly with numerical features based on their attribute information, such as user level and node CPU core count, or initialized as zero vectors. Their deep semantic representation will be generated through structural aggregation in the subsequent graph learning process. Subsequently, a heterogeneous graph is constructed based on the structured entity table and the relational edge table. Specifically, the node set is composed of all entity IDs in the structured entity table; a node type mapping function is constructed based on the entity type field in the entity table. This function takes the entity ID as input and returns its predefined entity type, such as service or user, by querying the aforementioned structured entity table; an edge set is composed of all records in the relational edge table; an edge type mapping function is constructed based on the relation type field in the edge table. This function takes an edge, identified by the source entity ID and the target entity ID, as input and returns its relation type, such as dependency or deployment, by querying the aforementioned relational edge table; the feature vector in the entity feature matrix corresponding to the entity ID of each node in the node set is used as the initial feature of that node; finally, the heterogeneous graph is output, which is jointly defined by the node set, the edge set, the node type mapping function, the edge type mapping function, and the initial node features. This step integrates scattered and heterogeneous raw data into a unified, semantically clear heterogeneous graph knowledge representation through entity standardization, relation rule definition, and feature engineering. This addresses the problem of isolated multi-source data that is difficult to directly use for complex model analysis, providing standardized and structured input for the entire solution. Furthermore, the heterogeneous graph constructed in this step, as the core data carrier and knowledge foundation of the entire method, with its deliberately distinguished and clearly defined node and edge types—i.e., graph heterogeneity—constitutes the fundamental premise for differentiated information processing and structured reasoning in subsequent steps. The entity types, entity features, and their diverse connections within the heterogeneous graph are the direct basis for subsequent steps to achieve advanced analytical functions such as relation-aware encoding, semantic enhancement of similar categories, and fault propagation path tracing. Entity features include service response time and the number of CPU cores in a node. Therefore, step S1 is the cornerstone for realizing the entire-link architecture from multi-source raw data to unified knowledge representation and then to intelligent decision-making, providing the necessary structural foundation for the entire solution.

[0024] Step S2: Process the heterogeneous graph using a network structure encoder to obtain the node representation matrix after network structure encoding; Step S2 includes steps S201 and S202; Step S201: Perform node feature transformation processing on the heterogeneous graph to obtain the transformed node feature matrix; The node feature transformation process includes obtaining the node type mapping function and the initial node features in the heterogeneous graph; Based on the node type mapping function, query the entity type corresponding to each node in the heterogeneous graph; Linear transformation parameters are configured for each entity type, including a weight matrix and a bias term; For each node in the heterogeneous graph, the initial node features are linearly transformed according to the linear transformation parameters corresponding to the entity type of each node to obtain intermediate linear features. By performing nonlinear activation on the intermediate linear features using the ReLU function, the transformed features of the nodes in a unified feature space are obtained. The transformed features of all nodes in the heterogeneous graph are aggregated to form a transformed node feature matrix.

[0025] Step S202: Perform network structure encoding processing on the transformed node feature matrix and heterogeneous graph to obtain the node representation matrix after network structure encoding; The network structure encoding process includes obtaining the transformed node feature matrix and heterogeneous graph; Each type of relationship in the heterogeneous graph is associated with an attention vector through a network structure encoder; Based on the edge type mapping function in the transformed heterogeneous graph, the different relationship types between each node and its neighboring nodes are identified. For each node in the node set, perform relation-level attention encoding. For each relation type, sum the transformed features of all neighbor nodes under the relation type to obtain the neighbor aggregation feature of the relation type. The attention vector corresponding to the relation type is multiplied by the neighbor aggregation feature, and the result is processed by a non-linear activation function to obtain the original attention score corresponding to the relation type. The original attention scores for all relation types are normalized to obtain the normalized attention weights for each relation type. Based on normalized attention weights, the neighbor aggregation features of nodes under various relation types are weighted and fused to obtain a weighted fused feature vector. Type-level attention aggregation is performed on the weighted fused feature vectors of all nodes in the node set; The process of type-level attention aggregation specifically includes: using a fully connected network, performing a linear transformation on the weighted fusion feature vector of each node in the node set under the relation type to obtain a linearly transformed feature vector; and then using the ReLU function to calculate the non-linear activation function on the linearly transformed feature vector to obtain the intermediate feature vector corresponding to each node. Perform a dot product operation between the intermediate feature vector and the attention vector of each node to obtain the individual importance score of the node under the relation type; The average importance score of each node under each relation type is calculated to obtain the global importance score corresponding to the relation type. Based on the global importance scores of all relation types, normalized aggregate weights are calculated for each relation type using the Softmax function; Based on the normalized aggregation weights, the weighted fusion feature vectors of each node under different relation types are weighted and summed to obtain the network structure encoding representation of the node; The network structure encoding representations of all nodes in the node set are aggregated to form the node representation matrix after network structure encoding and the corresponding final normalized attention weights.

[0026] In one embodiment, step S201 first involves performing node feature transformation. Specifically, this process utilizes the node type mapping function output in step S1 and the initial node features, i.e., the entity feature matrix, to configure independent linear transformation parameters (weight matrix and bias term) for each predefined entity type, such as service or user. These linear transformation parameters serve as learnable parameters for the model and are typically initialized randomly using the Xavier or Kaiming method, and optimized during training using the gradient descent algorithm. For each node in the heterogeneous graph, based on the type mapping result, the corresponding linear transformation parameters are selected. After performing linear operations on its initial features, they are processed using the ReLU activation function, thereby transforming the features of all nodes. Step S202: The process involves mapping the graph to a unified dimensional common feature space, outputting a unified dimensional transformed node feature matrix. Step S202: Subsequently, the core network structure encoding process is executed. This step randomly initializes and associates a trainable relation-specific attention vector with each relation type in the heterogeneous graph, such as dependency or deployment. The encoding process includes a two-layer attention aggregation mechanism at the relation level and the type level. In the relation-level attention encoding, for each node, the connection relationship type with its neighboring nodes is identified through the edge type mapping function. For each relation type involved, the transformed features of all neighboring nodes under that relation are summed to obtain the relation-specific neighbor aggregation feature. Then, the attention vector corresponding to that relation type is... The value and this aggregated feature are multiplied by a dot product and processed through a non-linear activation function, such as LeakyReLU, with a negative slope coefficient of 0.2, to obtain the original attention score for this relation type. The original scores of all related relation types for this node are normalized using the Softmax function to obtain the normalized attention weight for each relation type to this node. Based on this weight, the neighbor aggregated features of each relation type are weighted and summed to obtain the weighted fusion feature vector of this node that incorporates information from multiple relations. In type-level attention aggregation, to globally evaluate the importance of different relation types, a shared fully connected network is used, whose weights are shared across different relation types. The weighted fusion feature vector of each node is linearly processed. The process involves transforming the feature vector and applying ReLU activation to obtain an intermediate feature vector. This intermediate feature vector is then multiplied by the corresponding relation-specific attention vector to obtain the individual importance score of the node for that relation type. The arithmetic mean of the individual scores of all nodes for the same relation type is calculated to obtain the global importance score for that relation type. The global scores for all relation types are then normalized using the Softmax function to obtain the final global aggregate weights for each relation type. Finally, the network structure encoding representation of each node is obtained by weighting and summing its weighted fused feature vectors for different relation types according to these global aggregate weights. This step outputs the network structure encoding representation matrix for all nodes and the corresponding, interpretable final normalized attention weights. This step addresses the inconsistency in the feature space of heterogeneous graph nodes through type-specific feature transformations, and achieves refined modeling of complex heterogeneous relationships in the graph through a two-layer attention mechanism at the relational and type levels: relational attention can dynamically measure the differentiated association strength between a specific node and its various types of neighbors, while type-level attention can assess the general importance of various relationships in the entire graph from the perspective of global data distribution. From the core of the scheme design, this step transforms the data structure rich in type and topological information constructed in step S1 into a core intelligent module of deep knowledge representation including semantics and association weights. Its output node representation matrix not only encodes the node's own attributes and state, but more importantly, it encodes its structural position and multi-hop context information in the complex service relationship network.

[0027] Step S3: Based on the predefined node entity type labels, filter the node representation matrix after network structure encoding to obtain a set of nodes of the same category. Based on the connection relationship between the set of nodes of the same category and the nodes of the heterogeneous graph, construct a neighbor subgraph of the same category. Encode the neighbor subgraph to obtain the node representation matrix after enhanced encoding of the same category. Step S3 includes steps S301, S302, S303, S304 and S305; Step S301, wherein the process of same-category enhanced encoding includes obtaining the node representation matrix, heterogeneous graph and predefined service operation labels after network structure encoding; Step S302: Based on the service running label, filter out all other nodes with the same label in the heterogeneous graph for the current node to form an initial set of nodes of the same category; Calculate the semantic similarity between the current node and every node in the initial set of nodes of the same category; Based on semantic similarity, select the top K nodes with the highest similarity from the initial set of nodes of the same category, and use them as the final set of neighboring nodes of the same category for the current node; Step S303: Traverse all nodes in the graph and repeat step S302 to determine the final set of neighboring nodes of the same category for each node. Based on the final set of neighboring nodes of the same category for all nodes and the connection relationships between nodes in the corresponding heterogeneous graph, a neighboring subgraph of the same category is constructed. The nodes of the neighboring subgraph are composed of the union of the final set of neighboring nodes of the same category, and the edges of the neighboring subgraph are composed of the edges that actually exist in the heterogeneous graph for all nodes. Step S304: Perform graph convolutional coding on the subgraph of neighbors of the same category. The specific process includes: for each node in the subgraph of neighbors of the same category, normalize and aggregate the representations of all neighbor nodes of the same category, and perform linear transformation and nonlinear activation calculation on the aggregation result to obtain the enhanced coded representation of the node. Step S305: Aggregate the enhanced codes of all nodes in the node set to form nodes with the same enhanced codes.

[0028] In one embodiment, step S301 involves obtaining the node representation matrix after the network structure encoding output in step S2, the heterogeneous graph constructed in step S1, and predefined service operation labels, such as normal, abnormal, or specific service type labels. Step S302: Based on the service running label, select all other nodes with the same label in the heterogeneous graph for the current node to form an initial set of nodes of the same category. Next, calculate the semantic similarity between the current node and each node in the initial set of nodes of the same category. This similarity is obtained by calculating the cosine similarity between the feature vector of the current node to be calculated and the feature vector of a candidate node in the initial set of nodes of the same category. Based on the calculated semantic similarity, select the top K nodes with the highest similarity from the initial set of nodes of the same category as the final set of neighboring nodes of the same category for the current node, where K is an adjustable hyperparameter. In this embodiment, the value is specifically set to 15. This setting is based on the fact that this value falls within the median range of 5 to 20, a typical empirical range. This is sufficient to avoid local semantic sparsity due to too few neighbors (less than 10) and effectively prevents significant noise and computational overhead due to too many neighbors (greater than 20). It is a commonly used and effective practical value for balancing information richness and model computational efficiency. Step S303: Traverse all nodes in the heterogeneous graph, repeating step S302, to determine the final set of neighboring nodes of the same category for each node. Then, based on these final neighbors of all nodes... The set of nodes and their actual connections (edges) in the original heterogeneous graph are used to construct a subgraph of the same-class neighbors. The nodes of this subgraph are composed of the union of all final sets of the same-class neighbors, and the edges of this subgraph are directly inherited from the original heterogeneous graph, retaining only the two endpoints of those edges, i.e., edges where both the source node and the target node belong to the union of these nodes. Step S304 involves performing graph convolutional coding (GCN) on the constructed subgraph of the same-class neighbors. Specifically, for each node in the subgraph, firstly, the network structure encoding representations of all its same-class neighbors are normalized and aggregated; this aggregation typically... To calculate the mean of the neighbor feature vectors and normalize them using the node's degree (number of neighbors), for example, the aggregation result is specifically calculated by summing the feature vectors of all the node's neighbors and then normalizing by dividing by the square root of the node's degree. A linear transformation (through a learnable weight matrix) and a nonlinear activation function (such as ReLU) are applied to the aggregation result to obtain the enhanced encoding representation of the node after semantic enhancement of the same category. In step S305, the enhanced encoding representations of all nodes in the node set are aggregated to form a node representation matrix after enhanced encoding of the same category. This step addresses the potential issue in step S2's network structure encoding that it may fail to capture deep semantic patterns among similar entities. Through its design, it introduces semantic similarity-based neighbor filtering and subgraph convolution to specifically mine and enhance commonalities and association patterns among nodes belonging to the same predefined category, such as those with the same service status or type. This generates a set of node representations focused on semantic consistency within the category. At its core, step S3 and step S2 form a dual-driven approach of structure and semantics. Step S2 emphasizes structural information encoding driven by heterogeneous relationships, while step S3 focuses on semantic information enhancement guided by category labels. The node representation matrix output by step S2 after network structure encoding and the node representation matrix output by step S3 after same-category enhancement encoding respectively characterize service entities from different perspectives. This step is a crucial design for achieving multi-level information fusion and improving the model's discrimination and generalization capabilities.

[0029] Step S4: Perform collaborative optimization on the node representation matrix after network structure encoding and the node representation matrix after same-class augmentation encoding to obtain a unified node representation; Step S40 includes steps S401 and S402; Step S401, the collaborative optimization process includes obtaining the node representation matrix after network structure encoding and the node representation matrix after same-class enhancement encoding; Based on the relation edge table, node association rules are determined. Specifically, if two nodes in the heterogeneous graph are connected by a meta-path consisting of a relation type identifier stored in the relation edge table in a preset order or greater, then the two nodes are positive association sample nodes; otherwise, they are negative association sample nodes. Based on node association rules, the similarity between the network structure encoding representation of each node and the same-class augmented encoding representation of all nodes in the associated positive sample node set is calculated, and all positive sample similarities are aggregated to obtain the positive sample aggregate similarity. Calculate the similarity between the network structure encoding representation of each node and the same-class augmented encoding representation of all nodes in the associated positive sample node set and the associated negative sample node set, and aggregate all similarities to obtain the overall aggregated similarity; Based on the positive sample aggregation similarity and the overall aggregation similarity, the contrast loss component of each node is calculated; Step S402: For nodes with predefined service operation labels, calculate the predicted probability of each predefined category based on the network structure encoding representation; The classification optimization components for all nodes are calculated based on the actual service operation labels and predicted probabilities. Based on the comparison optimization component and classification optimization component of all nodes, the overall optimization target value is obtained by weighted summation. Based on the overall optimization target value, the node representation matrix after network structure encoding and the node representation matrix after the same type of enhanced encoding are adjusted and merged to generate the final node representation matrix.

[0030] In one embodiment, step S4 uses a multi-task optimization framework combining contrastive learning and supervised learning to align, refine, and fuse the two node representations generated in steps S2 and S3, thereby obtaining a unified and robust final node representation. Step S401 first obtains the node representation matrix encoded by the network structure and the node representation matrix encoded by the same category of enhancement. Based on the relational edge table obtained from step S1, node association rules are determined to construct positive and negative sample pairs. Specifically, a meta-path refers to a path pattern predefined according to domain knowledge, sequentially connected by specific relation types. For example, in this embodiment, a meaningful meta-path can be preset as service-dependency -> service-deployment -> node. If two nodes can be connected through at least one such predefined meta-path, they are determined to be associated positive sample nodes; otherwise, they are associated negative sample nodes. Contrast optimization is performed, and for each node i, the following calculations are executed: Calculate the cosine similarity between its network structure encoding representation and the same-class augmented encoding representation of all its associated positive sample nodes j; The similarity of all positive sample pairs is aggregated by summing the logarithms to obtain the aggregated similarity of positive samples; Compute the cosine similarity between the network structure encoding representation of node i and the same-class augmented encoding representation of all nodes (including their associated positive and negative samples); All similarities are aggregated by summing logarithms to obtain the overall aggregated similarity. Finally, based on the information noise contrast estimation, the contrast loss component of the node is calculated. The specific process includes adding the negative positive sample aggregation similarity to the logarithm of the overall aggregation similarity. The design of this loss function is to narrow the representation distance of positive sample nodes from two different perspectives, while widening the distance with negative sample nodes. Step S402: This step first performs supervised optimization on nodes with predefined service operation labels, such as normal and abnormal. The service operation label is a status identifier determined in advance for the relevant nodes according to clear business rules. In a specific implementation, the judgment is based on the feature indicators calculated for the service entity in step S103, such as the error rate. For example, the error rate threshold is set to 5%. When the error rate of a service entity exceeds this threshold, it is marked as abnormal; otherwise, it is marked as normal. The threshold of 5% is an application parameter that can be adjusted according to the quality requirements of the specific business system. Specifically, the network structure encoding representation of each node is input into a linear classifier, and the predicted probability of it belonging to each predefined category is calculated by the Softmax function. Using the standard cross-entropy loss function, the classification loss component of the node is calculated based on the node's real service operation label and its predicted probability. Subsequently, multi-objective fusion and optimization are performed. The overall optimization objective value is obtained as follows: First, the average value of the contrastive loss component of all nodes is calculated and denoted as the node loss component average value. Second, the average value of the classification loss component of all labeled nodes is calculated and denoted as the label loss component average value. Finally, the node loss component average value and the label loss component average value are weighted and summed according to preset weight coefficients. The weight coefficients of the contrastive loss and classification loss are adjustable hyperparameters used to balance the importance of the two tasks, and their typical initial empirical values ​​are all set to 1.0. Based on the overall optimization objective value, the network structure encoder of step S2, the same-class augmentation encoder of step S3, and all learnable parameters of the linear classifier are updated simultaneously through the backpropagation algorithm and gradient descent optimizer, such as Adam. The final node representation matrix is ​​obtained. After the model training is completed and convergence is achieved, for any node in the graph, its optimized network structure encoding representation vector and the same-class augmentation encoding representation vector are concatenated. The resulting composite vector is used as the unified final representation of the node. The final representations of all nodes together constitute the final node representation matrix. This step combines contrastive learning with supervised learning. By utilizing the semantic associations defined by the metapath, it forces the alignment of node representations from the structural view and the semantic view, thus resolving the potential inconsistency in representation space between step S2 (structural view) and step S3 (semantic view). Using a small number of label signals, it guides the model to learn features that are discriminative for downstream management tasks, such as state classification. Through weighted joint optimization, the two approaches achieve representation alignment and refinement.

[0031] From a design perspective, step S4 deeply integrates and corrects the two complementary perspectives generated by step S2 (focusing on heterogeneous structures) and step S3 (focusing on homogeneous semantics) through a unified optimization objective. The final node representation output includes complex service topology relationships, strengthens semantic consistency within categories, and is highly relevant to specific lifecycle management task objectives. Therefore, this step is the core mechanism to ensure that the learned knowledge representation has high robustness, strong discriminative power, and task adaptability.

[0032] Step S5: Based on the unified node representation, perform parsing and management to obtain the service lifecycle management decision results; Step S5 includes steps S501 and S502; Step S501: Perform label smoothing and propagation processing on the final node representation matrix to obtain stable labels; The label smoothing and propagation process includes obtaining the final node representation matrix and determining the initial predicted label for each node based on the final node representation matrix using a classifier. The initial predicted label for each node is processed by a label smoothing algorithm to obtain a smoothed label probability distribution; A label propagation matrix is ​​constructed based on the connection relationships between nodes in the heterogeneous graph; The smoothed label probability distribution is used as the initial value for iteration. The label propagation matrix is ​​used for iterative calculation to update the label probability distribution of all nodes in the heterogeneous system until the difference in label probability distribution between nodes is less than a preset threshold. Output the probability distribution of node labels that have reached convergence after iterative updates, as the final judgment result of the service lifecycle management task.

[0033] Step S502: Based on the final judgment result, perform service lifecycle management decision processing to generate management decision results; The processing is carried out based on the management decision results, specifically including identifying abnormal nodes and forming a set of faulty nodes based on the probability distribution of node labels in the final judgment results. Based on the connection relationships between nodes in the heterogeneous graph, we trace back in reverse along the direction of the relationship edges, starting from the nodes in the set of faulty nodes as the fault points, and find all upstream nodes and connection paths that connect to the fault points, as a set of potential root cause paths. Based on the final normalized attention weights, the weights of each path in the potential root cause path set are aggregated to obtain the propagation confidence of each path. The path with the highest propagation confidence is selected as the main fault propagation path, and the starting node of the path is identified as the key fault root cause node. A fault root cause location report is generated based on the main fault propagation path and key fault root cause nodes.

[0034] In one embodiment, step S5 parses the unified node representation generated in step S4 and transforms it into directly executable service lifecycle management decisions, completing the closed loop from data analysis to operation and maintenance actions; step S501, this step first obtains the final node representation matrix output in step S4; based on this matrix, the initial predicted label of each node's state, such as normal or abnormal, is determined using the linear classifier defined and optimized in step S402; the initial predicted label of each node is processed by a label smoothing algorithm, specifically, the one-hot encoding of the initial predicted label is mixed with a uniform distribution, the smoothing coefficient is set to 0.1 to control the degree of mixing, 0.1 is a common empirical value, thereby obtaining a more robust smoothed label probability distribution to alleviate the uncertainty of prediction; based on the connection relationship (adjacency matrix) between nodes in the heterogeneous graph constructed in step S1, and using the final normalized attention weight output in step S2 as the edge weight, a label propagation matrix is ​​constructed; specifically, by adjusting the weighted adjacency matrix as follows... The algorithm is normalized to obtain a random walk probability transition matrix, which serves as the label propagation matrix. The smoothed label probability distribution is used as the initial value for iteration. Iterative calculations are performed using this label propagation matrix, for example, employing a standard consensus propagation algorithm. Under the constraint of a heterogeneous graph structure, the label probability distribution of all nodes is updated until the average absolute error of the label probability distribution of all nodes between two consecutive iterations is less than a preset threshold, such as 1e-5. This threshold is an empirical value set based on the accuracy requirements of numerical calculation, indicating that convergence can be considered achieved when the update amount is sufficiently small. The node label probability distribution after iterative convergence is output as the final judgment result of the service lifecycle management task. Step S502: Based on the final judgment result output in step S501, this step performs specific service lifecycle management decision processing. Based on the node label probability distribution in the final judgment result, nodes with anomaly category probabilities higher than a set confidence level, such as 0.5, are identified as anomalous nodes. This confidence level threshold is a balance parameter that can be adjusted according to different tolerances for false positives and false negatives, 0.5 is a commonly used initial value, forming a set of faulty nodes. Based on the connection relationships between nodes in the heterogeneous graph constructed in step S1, reverse tracing is performed along the directions of dependency and deployment relationship edges. Taking each node in the faulty node set as the fault point, a graph traversal algorithm using depth-first search (DFS) is used, setting a maximum search depth, such as 5 hops. This depth of 5 hops is based on the common length of fault propagation links in actual software service systems, aiming to cover most actual propagation scenarios while avoiding the introduction of irrelevant nodes and excessive computational overhead due to excessive search depth. All upstream nodes directly or indirectly connected to the fault point and complete connections are found. The path is used to form a set of potential root cause paths. Based on the final normalized attention weights output in step S2, for each path in the set of potential root cause paths, the attention weights corresponding to the relationship types of each edge on the path are multiplied and aggregated to obtain the propagation confidence that the path is a real fault propagation path. Among all potential root cause paths, the path with the highest propagation confidence is selected as the main fault propagation path, and the starting node of this path is identified as the key fault root cause node. A structured fault root cause localization report is automatically generated, which includes a list of fault nodes, key root cause nodes, main propagation paths and their confidence, and remediation suggestions. Step S501 enhances robustness to prediction uncertainty through label smoothing and incorporates global consistency constraints based on graph structure into state determination using the label propagation algorithm, making the results more stable and reliable. Step S502 defines a set of clear rules from probability determination to root cause localization and achieves automated and interpretable tracing of the fault impact chain by combining graph traversal and attention weights. From a design perspective, step S5 is the value realization and output terminal of the entire method. It transforms the deep and unified node representation learned in the previous steps into specific decisions that can be understood and executed in the operation and maintenance scenario, such as status reporting and root cause diagnosis, thus completing the full-link intelligent closed loop from multi-source heterogeneous data input to precise management action output.

[0035] This invention constructs a heterogeneous graph integrating multi-source data such as service metadata, operation logs, and user feedback. It innovatively introduces a collaborative optimization mechanism combining network structure coding and similar-category enhanced coding, achieving a unified representation of multi-level and multi-type relationships among software service elements. This method effectively addresses the limitations of existing technologies, such as fragmented multi-source information, insufficient semantic expression, and difficulty in integrating heterogeneous relationships and deep connections. This design not only comprehensively and deeply depicts the service's operational status but also significantly enhances the ability to capture semantic connections through attention mechanisms and graph convolution techniques. This greatly improves the accuracy of fault root cause localization and the reliability of management decisions, providing more comprehensive, accurate, and efficient intelligent support for the full lifecycle management of complex software service systems.

[0036] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product implemented on one or more computer-usable storage media containing computer-usable program code. The storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read Only Memory (EPROM), Programmable Red-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0037] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the protection scope of the present invention.

Claims

1. A method for service lifecycle management of computer software, characterized in that, Includes the following steps: Step S1: Construct a heterogeneous graph based on the original data of the software services. The heterogeneous graph uses various software service entity types as entity nodes and the correspondence between entities as edges. Step S2: Process the heterogeneous graph using a network structure encoder to obtain the node representation matrix after network structure encoding; Step S3: Based on the predefined node entity type labels, filter the node representation matrix after network structure encoding to obtain a set of nodes of the same category. Based on the connection relationship between the set of nodes of the same category and the nodes of the heterogeneous graph, construct a neighbor subgraph of the same category. Encode the neighbor subgraph to obtain the node representation matrix after enhanced encoding of the same category. Step S4: Perform collaborative optimization on the node representation matrix after network structure encoding and the node representation matrix after same-class augmentation encoding to obtain a unified node representation; Step S5: Based on the unified node representation, the system is parsed and managed to obtain the service lifecycle management decision results.

2. The service lifecycle management method for computer software as described in claim 1, characterized in that, Step S1: Construct a heterogeneous graph based on the original data of the software service. The heterogeneous graph uses various software service entity types as entity nodes and the correspondence between entities as edges. Step S1 includes steps S101, S102, S103, S104 and S105; Step S101: Obtain the raw data of the software service lifecycle. The raw data includes software service metadata, service operation logs, user feedback data, and deployment environment information. Step S102: Perform entity extraction processing on the original data to generate a structured entity table; The entity extraction process includes identifying software service metadata and service operation logs to obtain the service entity to be processed and the version entity to be processed, and standardizing the service entity to be processed and the version entity to be processed to obtain the service entity and the version entity respectively. Identify user feedback data and service operation logs to obtain user entities to be processed and fault entities to be processed. Standardize user entities to be processed and fault entities to be processed to obtain user entities and fault entities respectively. The deployment environment information and service operation logs are identified to obtain the node entity to be processed and the environment entity to be processed. The node entity to be processed and the environment entity to be processed are standardized to obtain the node entity and the environment entity respectively. The process of generating a structured entity table includes assigning a unique entity identifier and an entity type identifier to each entity among the service entity, version entity, user entity, fault entity, node entity, and environment entity. Create a corresponding data record for each entity. Each data record includes the entity ID, entity type, and entity attribute information. Entity types include service entities, version entities, user entities, fault entities, node entities, and environment entities; The entity ID stores the unique entity identifier assigned to the entity, the entity type identifier is stored by entity type, and the entity attribute information is stored by entity attribute information. Aggregate the data records of all entities to obtain a structured entity table; Step S103: Perform feature calculation processing on the structured entity table to generate an entity feature matrix; The feature calculation process includes, for the service entities in the structured entity table, calculating the number of calls, average response time and error rate of the service entities based on the service operation logs; The number of faults associated with service entities is counted based on user feedback data; The number of calls, average response time, error rate, and number of failures are aggregated by entity ID to obtain an entity feature matrix.

3. The service lifecycle management method for computer software as described in claim 2, characterized in that, Step S104: Establish the correspondence between entities based on the original data; The process of establishing the correspondence between entities includes establishing the publication relationship between the service entity and the corresponding version entity based on the association field between the service record and the version record in the software service metadata; Establish the dependencies between service entities based on the call chain in the service operation log; Based on user feedback data and user access records in service operation logs, establish the usage relationship between user entities and service entities; Based on the service information associated with user feedback data and error records in the service operation log, establish the triggering relationship between service entities and faulty entities; Based on the service instances and server nodes recorded in the deployment environment information, establish the deployment relationship between service entities and node entities; The publishing relationships, dependency relationships, usage relationships, triggering relationships, and deployment relationships are stored in the form of an edge list, forming a relationship edge table; Each edge record in the relation edge table includes the source entity ID, the target entity ID, and the relation type; The source entity ID and target entity ID are entity IDs in the structured entity table, and the relationship type is a correspondence between entities.

4. A service lifecycle management method for computer software as described in claim 3, characterized in that, Step S105: Construct a heterogeneous graph based on the structured entity table, relation edge table, and entity feature matrix; Based on the entity ID and entity type in the structured entity table, construct a set of nodes for a heterogeneous graph; Based on the entity types in the structured entity table, a node type mapping function is constructed, which maps each node in the node set to the corresponding entity type. Based on the source entity ID and target entity ID in the relation edge table, construct the edge set of the heterogeneous graph; Based on the relation type identifier in the relation edge table, an edge type mapping function is constructed, which maps each edge in the edge set to the corresponding relation type. The entity feature matrix is ​​used as the initial feature of the nodes in the heterogeneous graph; The output consists of a heterogeneous graph composed of a set of nodes, a set of edges, a node type mapping function, an edge type mapping function, and initial node features.

5. A service lifecycle management method for computer software as described in claim 4, characterized in that, Step S2: Process the heterogeneous graph using a network structure encoder to obtain the node representation matrix after network structure encoding; Step S2 includes steps S201 and S202; Step S201: Perform node feature transformation processing on the heterogeneous graph to obtain the transformed node feature matrix; The node feature transformation process includes obtaining the node type mapping function and the initial node features in the heterogeneous graph; Based on the node type mapping function, query the entity type corresponding to each node in the heterogeneous graph; Linear transformation parameters are configured for each entity type, including a weight matrix and a bias term; For each node in the heterogeneous graph, the initial node features are linearly transformed according to the linear transformation parameters corresponding to the entity type of each node to obtain intermediate linear features; The intermediate linear features are nonlinearly activated by the ReLU function to obtain the transformed features of the node in a unified feature space. The transformed features of all nodes in the heterogeneous graph are aggregated to form a transformed node feature matrix.

6. A service lifecycle management method for computer software as described in claim 5, characterized in that, Step S202: Perform network structure encoding processing on the transformed node feature matrix and heterogeneous graph to obtain the node representation matrix after network structure encoding; The network structure encoding process includes obtaining the transformed node feature matrix and heterogeneous graph; Each type of relationship in the heterogeneous graph is associated with an attention vector through a network structure encoder; Based on the edge type mapping function in the transformed heterogeneous graph, the different relationship types between each node and its neighboring nodes are identified. For each node in the node set, perform relation-level attention encoding. For each relation type, sum the transformed features of all neighbor nodes under that relation type to obtain the neighbor aggregation feature of that relation type. The attention vector corresponding to the relationship type is multiplied by the neighbor aggregation feature, and the result is processed by a non-linear activation function to obtain the original attention score corresponding to the relationship type. The original attention scores for all relation types are normalized to obtain the normalized attention weights for the relation types. Based on the normalized attention weights, the neighbor aggregation features of the node under each relation type are weighted and fused to obtain a weighted fused feature vector. Type-level attention aggregation is performed on the weighted fused feature vectors of all nodes in the node set; The process of type-level attention aggregation specifically includes: using a fully connected network, performing a linear transformation on the weighted fusion feature vector of each node in the node set under the relation type to obtain a linearly transformed feature vector; and using the ReLU function to calculate the non-linear activation function on the linearly transformed feature vector to obtain the intermediate feature vector corresponding to each node. Perform a dot product operation between the intermediate feature vector and the attention vector of each node to obtain the individual importance score of the node under the relationship type; The average importance score of all nodes under the given relationship type is calculated to obtain the global importance score corresponding to the relationship type. Based on the global importance scores of all relation types, normalized aggregate weights are calculated for each relation type using the Softmax function; Based on the normalized aggregation weights, the weighted fusion feature vectors of each node under different relation types are weighted and summed to obtain the network structure encoding representation of the node. The network structure encoding representations of all nodes in the node set are aggregated to form the node representation matrix after network structure encoding and the corresponding final normalized attention weights.

7. A service lifecycle management method for computer software as described in claim 6, characterized in that, Step S3: Based on the predefined node entity type labels, the node representation matrix after the network structure encoding is filtered to obtain a set of nodes of the same category. Based on the connection relationship between the set of nodes of the same category and the nodes of the heterogeneous graph, a neighbor subgraph of the same category is constructed. The neighbor subgraph is encoded to obtain the node representation matrix after enhanced encoding of the same category. Step S3 includes steps S301, S302, S303, S304 and S305; Step S301, wherein the process of same-category enhanced encoding includes obtaining the node representation matrix, heterogeneous graph and predefined service operation labels after the network structure is encoded; Step S302: Based on the service running label, filter out all other nodes with the same label in the heterogeneous graph for the current node to form an initial set of nodes of the same category; Calculate the semantic similarity between the current node and every node in the initial set of nodes of the same category; Based on semantic similarity, select the top K nodes with the highest similarity from the initial set of nodes of the same category, and use them as the final set of neighboring nodes of the same category for the current node; Step S303: Traverse all nodes in the graph and repeat step S302 to determine the final set of neighboring nodes of the same category for each node. Based on the final set of neighboring nodes of the same category for all nodes and the connection relationships between nodes in the corresponding heterogeneous graph, a neighboring subgraph of the same category is constructed. The nodes of the neighboring subgraph are composed of the union of the final set of neighboring nodes of the same category, and the edges of the neighboring subgraph are composed of the edges that actually exist in the heterogeneous graph for all nodes. Step S304: Perform graph convolutional coding on the same-category neighbor subgraph. The specific process includes: for each node in the same-category neighbor subgraph, normalize and aggregate the representations of all same-category neighbor nodes, and perform linear transformation and nonlinear activation calculation on the aggregation result to obtain the enhanced coded representation of the node. Step S305: Aggregate the enhanced codes of all nodes in the node set to form nodes with the same enhanced codes.

8. A service lifecycle management method for computer software as described in claim 7, characterized in that, Step S4: Perform collaborative optimization on the node representation matrix after network structure encoding and the node representation matrix after same-class augmentation encoding to obtain a unified node representation; Step S40 includes steps S401 and S402; Step S401, the collaborative optimization process includes obtaining the node representation matrix after network structure encoding and the node representation matrix after same-class enhancement encoding; Based on the relation edge table, node association rules are determined. Specifically, if two nodes in the heterogeneous graph are connected by a meta-path consisting of a relation type identifier stored in the relation edge table in a preset order or greater, then the two nodes are positive association sample nodes; otherwise, they are negative association sample nodes. Based on node association rules, the similarity between the network structure encoding representation of each node and the same-class augmented encoding representation of all nodes in the associated positive sample node set is calculated, and all positive sample similarities are aggregated to obtain the positive sample aggregate similarity. Calculate the similarity between the network structure encoding representation of each node and the same-class augmented encoding representation of all nodes in the associated positive sample node set and the associated negative sample node set, and aggregate all similarities to obtain the overall aggregated similarity; Based on the positive sample aggregation similarity and the overall aggregation similarity, the contrast loss component of each node is calculated; Step S402: For nodes with predefined service operation labels, calculate the predicted probability of each predefined category based on the network structure encoding representation; The classification optimization components for all nodes are calculated based on the actual service operation labels and predicted probabilities. Based on the comparison optimization component and classification optimization component of all nodes, the overall optimization target value is obtained by weighted summation. Based on the overall optimization target value, the node representation matrix after network structure encoding and the node representation matrix after the same category of enhanced encoding are adjusted and merged to generate the final node representation matrix.

9. A service lifecycle management method for computer software as described in claim 8, characterized in that, Step S5: Based on the unified node representation, perform parsing and management to obtain the service lifecycle management decision results; Step S5 includes steps S501 and S502; Step S501: Perform label smoothing and propagation processing on the final node representation matrix to obtain stable labels; The label smoothing and propagation process includes obtaining the final node representation matrix and determining the initial predicted label for each node based on the final node representation matrix using a classifier. The initial predicted label for each node is processed by a label smoothing algorithm to obtain a smoothed label probability distribution; A label propagation matrix is ​​constructed based on the connection relationships between nodes in the heterogeneous graph; The smoothed label probability distribution is used as the initial value for iteration. The label propagation matrix is ​​used for iterative calculation to update the label probability distribution of all nodes in the heterogeneous system until the difference in label probability distribution between nodes is less than a preset threshold. Output the probability distribution of node labels that have reached convergence after iterative updates, as the final judgment result of the service lifecycle management task.

10. A service lifecycle management method for computer software as described in claim 9, characterized in that, Step S502: Based on the final judgment result, perform service lifecycle management decision processing to generate management decision results; The processing is carried out based on the management decision results, specifically including identifying abnormal nodes and forming a set of faulty nodes based on the probability distribution of node labels in the final judgment results. Based on the connection relationship between nodes in the heterogeneous graph, reverse tracing is performed along the direction of the relationship edge. Starting from the nodes in the fault node set as the fault point, all upstream nodes and connection paths connecting the fault points are searched to form a potential root cause path set. Based on the final normalized attention weights, the weights of each path in the potential root cause path set are aggregated to obtain the propagation confidence of each path. The path with the highest propagation confidence is selected as the main fault propagation path, and the starting node of the path is identified as the key fault root cause node. A fault root cause location report is generated based on the main fault propagation path and key fault root cause nodes.

Images