Intelligent calculation operation and maintenance RDF knowledge graph updating method and device and electronic equipment

Abstract

The invention provides an intelligent calculation operation and maintenance RDF knowledge graph updating method and device and electronic device.The method comprises the steps that in response to a detected dynamic change event associated with a target object, the dynamic change event is converted into a resource description framework RDF triple and an operation intention corresponding to the RDF triple; according to the event type of the dynamic change event, performing target verification on the initial RDF knowledge graph of the intelligent calculation operation and maintenance; and under the condition that the initial RDF mapping knowledge domain passes the target verification, updating the initial RDF mapping knowledge domain according to the RDF triple and the operation intention to obtain an updated RDF mapping knowledge domain. According to the method, the consistency and integrity of graph state evolution can be ensured, data exception caused by conflict change can be effectively avoided, and the reliability of knowledge graph maintenance and the intelligent calculation operation and maintenance level are improved.

Description

Technical Field

[0001] This application relates to the fields of artificial intelligence technology such as knowledge graphs and large models, and in particular to a method, apparatus and electronic device for updating an intelligent computing operation and maintenance RDF knowledge graph. Background Technology

[0002] With the rapid development of artificial intelligence and large-scale model training tasks, intelligent computing (AI) clusters have become an indispensable core computing infrastructure for enterprises and research institutions, and are rapidly evolving towards high density, multi-tenancy, heterogeneity, and high dynamism. Against this backdrop, how to effectively improve the operation and maintenance level of AI clusters has become a critical issue that urgently needs to be addressed. Summary of the Invention

[0003] This application provides a method, apparatus, and electronic device for updating an intelligent computing operations and maintenance RDF knowledge graph. The specific solution is as follows: The first aspect of this application proposes a method for updating an intelligent computing operations and maintenance RDF knowledge graph, including: In response to the detection of dynamic change events associated with the target object, the dynamic change events are converted into Resource Description Framework (RDF) triples and the corresponding operation intentions of the RDF triples. Based on the event type of dynamically changing events, target verification is performed on the initial RDF knowledge graph of intelligent computing operations and maintenance; the initial RDF knowledge graph is used to describe the resources, objects and tasks in the intelligent computing cluster. If the initial RDF knowledge graph passes the target verification, the initial RDF knowledge graph is updated according to the RDF triples and the operation intent to obtain the updated RDF knowledge graph.

[0004] A second aspect of this application proposes an update device for an intelligent computing operations and maintenance RDF knowledge graph, comprising: The conversion module is used to respond to the detection of dynamic change events associated with the target object by converting the dynamic change events into RDF triples and the corresponding operation intentions of the RDF triples. The verification module is used to perform target verification on the initial RDF knowledge graph of intelligent computing operations and maintenance based on the event type of dynamically changing events; the initial RDF knowledge graph is used to describe the resources, objects and tasks in the intelligent computing cluster. The update module is used to update the initial RDF knowledge graph based on the RDF triples and operation intent, after the initial RDF knowledge graph has passed the target verification, so as to obtain the updated RDF knowledge graph.

[0005] A third aspect of this application provides an electronic device, including: a processor, and a memory communicatively connected to the processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory to implement the method described in the first aspect embodiment above.

[0006] A fourth aspect of this application provides a computer-readable storage medium storing computer-executable instructions that, when executed by a processor, are used to implement the method described in the first aspect above.

[0007] A fifth aspect of this application provides a computer program product including a computer program that, when executed by a processor, implements the method described in the first aspect of the present application.

[0008] The intelligent computing operation and maintenance RDF knowledge graph updating method, device, electronic device, and storage medium provided in this application accurately convert detected dynamic change events into RDF triples and their corresponding operation intentions. This enables the explicit expression of the target object's state change requirements in a semantic and structured manner. Furthermore, by combining the event types of dynamic change events, targeted target verification is performed on the initial RDF knowledge graph, improving the accuracy of the verification logic. Once verification is successful, the initial RDF knowledge graph for intelligent operation is updated based on the operation intentions and RDF triples. This not only ensures the consistency and integrity of the graph's state evolution but also effectively avoids data anomalies caused by conflicting changes, thereby improving the reliability of knowledge graph maintenance and the level of intelligent computing operation and maintenance.

[0009] Additional aspects and advantages of this application will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0010] The above and / or additional aspects and advantages of this application will become apparent and readily understood from the following description of the embodiments taken in conjunction with the accompanying drawings, wherein: Figure 1 A flowchart illustrating a method for updating an intelligent computing operation and maintenance RDF knowledge graph, provided in some embodiments of this application; Figure 2 A schematic diagram of an RDF knowledge graph for intelligent operation and maintenance provided in some embodiments of this application; Figure 3 A flowchart illustrating another method for updating an intelligent computing operation and maintenance RDF knowledge graph, provided in some embodiments of this application; Figure 4 A flowchart illustrating another method for updating an intelligent computing operation and maintenance RDF knowledge graph, provided in some embodiments of this application; Figure 5A flowchart illustrating another method for updating an intelligent computing operation and maintenance RDF knowledge graph, provided in some embodiments of this application; Figure 6 This is a schematic diagram of the structure of an intelligent computing operation and maintenance RDF knowledge graph updating device provided in some embodiments of this application. Detailed Implementation

[0011] The embodiments of this application are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this application, and should not be construed as limiting this application.

[0012] It should be noted that the acquisition, storage, use, and processing of data in this application comply with the relevant provisions of national laws and regulations and do not violate public order and good morals.

[0013] The following description, with reference to the accompanying drawings, describes a method, apparatus, electronic device, and storage medium for updating an intelligent computing operations and maintenance RDF knowledge graph according to embodiments of this application.

[0014] Figure 1 This is a flowchart illustrating a method for updating an intelligent computing operations and maintenance RDF knowledge graph, provided in some embodiments of this application. Figure 1 As shown, the method for updating the intelligent computing operations and maintenance RDF knowledge graph includes the following steps: Step 101: In response to the detection of a dynamic change event associated with the target object, the dynamic change event is converted into an RDF triple and the corresponding operation intent of the RDF triple.

[0015] In this application, the target object can be any organization or individual using the computing resources of the intelligent computing cluster. For example, the target object can also be described as a target tenant, and this application does not limit the name of the target object.

[0016] For example, dynamic change events may include, but are not limited to, object addition events (i.e., tenant addition events), object deletion events (i.e., tenant deletion events), resource quota adjustment events, user addition / removal events, task submission events, and task completion events (i.e., task completion events).

[0017] For example, an object addition event can refer to an event that adds an object to use computing resources, i.e., adding a tenant.

[0018] For example, an object can have one or more users. If an object is a company that provides search services and the company's search services use the computing resources of an intelligent cluster, then the users who use the search services provided by the company are the users of that object.

[0019] For example, a user add / remove event can refer to an object, adding or removing its users' events.

[0020] In this application, based on the operation of the target object on the intelligent computing cluster, the dynamic change events associated with the target object can be obtained, and according to the rules, the dynamic change events can be converted into RDF (Resource Description Framework) triples and the operation intent corresponding to the RDF triples.

[0021] RDF is a resource description format that emphasizes transforming each object into a resource and providing its related attributes and relationships, thereby linking various objects together to form a knowledge graph. Furthermore, RDF uses triples (subject, predicate, object) to describe resources, a data structure that adapts well to different data formats and data sources.

[0022] For example, dynamic change events may include, but are not limited to, task identifiers, target object identifiers, and resource information related to the task.

[0023] For example, if the target object Alice submits a task request that requires 4 GPU resources, the obtained dynamic change event is: JobSubmittedEvent(job_id="12345",user="Alice",gpu_requeset=4). As you can see, the dynamic change event includes the task identifier, the name of the target object, and the number of GPUs required for the submitted task.

[0024] As an example, a dynamic change event is a resource quota adjustment event, which can include the object identifier whose resource quota needs to be adjusted, the adjusted resource quota, etc.

[0025] Step 102: Based on the event type of the dynamically changing event, perform target verification on the initial RDF knowledge graph of intelligent computing operation and maintenance.

[0026] For example, event types may include, but are not limited to, adding objects, deleting objects, adjusting resource quotas, adding or removing users, submitting tasks, and ending tasks.

[0027] For example, the initial RDF knowledge graph for intelligent computing operations and maintenance can be used to describe resources, objects, and tasks in an intelligent computing cluster. This RDF knowledge graph is an object-oriented operations and maintenance knowledge graph for intelligent computing clusters, enabling fine-grained monitoring and assurance of tasks, resources, and performance for individual objects.

[0028] When constructing an RDF knowledge graph for intelligent computing operations and maintenance to describe the resources, tenants, and tasks of an intelligent computing cluster, we can first define some basic RDF concepts. For example, a resource refers to a physical or virtual server in the intelligent computing cluster; a tenant is an organization or individual that uses the computing resources in the intelligent computing cluster; and a task is a unit of work executed on the intelligent computing cluster.

[0029] Then, you can define object domain RDF classes and properties, resource domain RDF classes and properties, and task domain RDF classes and properties.

[0030] For example, the following are examples of object domain RDF classes and properties: # Define Classes :Tenant a owl:Class. :User a owl:Class. :Project a owl:Class. # The project is a subgroup within the tenant. :Quota a owl:Class. # Define properties :belongsTo a owl:ObjectProperty; # The user belongs to a tenant / project rdfs:domain :User; rdfs:range :Tenant. :hasMember a owl:ObjectProperty; # The project has members rdfs:domain :Project; rdfs:range :User. :hasQuota a owl:ObjectProperty; # Tenant has quota rdfs:domain :Tenant; rdfs:range :Quota. Here, "Tenant a owl:Class" declares that Tenant is a class in an OWL ontology.

[0031] For example, in an intelligent computing cluster, for the object domain, resource domain, and task domain, key association attributes between domains can be defined. By establishing semantic relationships between domains, an interconnected graph can be formed, resulting in an RDF knowledge graph. Figure 2 The RDF knowledge graph shown.

[0032] For example, key association attributes between domains may include the association between objects and resources as resource allocation (e.g., which tenant is allocated which physical pools), the indirect association between tasks and objects as through users (e.g., which object this task ultimately serves), the runtime association between resources and tasks as scheduling (e.g., which GPU this task specifically uses), and the association between quotas and resource pools as capacity definition (e.g., how many total capacities does this resource pool have, and which quotas does it actually provide).

[0033] The reasoning rules defining these related attributes incorporate domain knowledge and business requirements, allowing for continuous iteration and validation to ensure their correctness and effectiveness. These rules include: a) The inherent relationships within the data itself For example, transitivity: "A resource pool contains nodes, nodes contain GPUs, therefore the resource pool also contains these GPUs." This is a natural transitive relationship.

[0034] b) Business Logic and Strategy For example, the quota policy states: "If a user belongs to a tenant, then all the resources consumed by the tasks submitted by that user should be counted towards that tenant's quota usage." c) Requirements of upper-layer applications The design of rules needs to serve the final application scenario. For example, resource scheduling requires "finding all nodes that meet the GPU requirements of the task and whose tenant quotas have not been exceeded," which requires the quota check rules mentioned earlier as support. The operations dashboard can "display the 'real resource utilization' (allocated / total quota) of each tenant in real time," which requires rules to aggregate the total resource requests of all tasks under each tenant in real time.

[0035] It is evident that constructing an object operation and maintenance knowledge graph for intelligent computing clusters based on the association attributes between tasks, resources, and objects in the intelligent computing cluster can provide decision support for precise operation and maintenance.

[0036] For example, the initial RDF knowledge graph can be either the initial knowledge graph of intelligent computing operations and maintenance that has been constructed, or it can be the one obtained from the previous update; there is no limitation on this. For example, the data requirements of intelligent computing objects can be derived based on business scenario analysis, and the initial knowledge graph of intelligent computing operations and maintenance can be constructed based on these data requirements.

[0037] In a multi-cluster environment, the "computation task" and "the data it requires" are physically separated. The "data it requires" can refer to the input data that the AI ​​training and scientific computing workflows rely on, and which needs to be read and processed by the computation task. This separation presents significant performance challenges and operational complexity. In this application, these elements can be explicitly linked using an RDF knowledge graph, which can drive intelligent decision-making.

[0038] Single cluster operation and maintenance focuses on the resource utilization, task scheduling efficiency, node fault isolation and recovery within the intelligent computing cluster. The RDF knowledge graph of a single cluster can have relatively fixed fusion points, mainly the relationship between objects, tasks and resources. All resources and tasks are closed within a single intelligent computing cluster.

[0039] Multi-cluster operations focus on cross-cluster resource distribution, load balancing, data scheduling, global views, and a unified SLA (Service Level Agreement). Tasks for the same object can be distributed across different intelligent computing clusters, and there may be data dependencies between tasks across intelligent computing clusters. For a cross-domain RDF knowledge graph of a single cluster, new concepts (Classes) and relationships (Properties) can be introduced to describe the characteristics of multi-cluster operations.

[0040] For example, ":Cluster" serves as a container for all resources; ":hasLocation" describes the geographical location of the cluster or resource; ":needsDataset" describes the dataset required by the object's task; ":interClusterLink" describes the network connection attributes between clusters (such as bandwidth, latency, cost, etc.); ":Dataset" and its ":storedIn" specify which cluster or location is crucial for cross-cluster data task scheduling.

[0041] Therefore, with relationships like ":Dataset", ":storedIn", and ":needsDataset", the RDF knowledge graph can find the task and dataset using ":needsDataset" and locate the data location using ":storedIn". The optimal cluster is usually the cluster where the data resides, thus avoiding unnecessary cross-cluster transfers. For example, if the problem "task X runs very slowly on the cluster in city a", the knowledge graph can pinpoint that the dataset D1 required by task X is stored on the cluster in city b. The bottleneck is likely due to cross-cluster network input / output, rather than the computing resources themselves.

[0042] In this application, the correspondence between event types and verification methods can be pre-set. Based on the event type of the dynamically changing event, the correspondence can be queried to determine the target verification corresponding to the event type of the dynamically changing event, and target verification can be performed on the initial RDF knowledge graph of intelligent computing operation and maintenance.

[0043] For example, the verification methods for submitting a task can include entity existence verification and resource quota verification. Entity existence verification verifies whether the entity referenced by the RDF triple is an entity that already exists in the initial RDF knowledge graph of the intelligent dimension operation. Resource quota verification verifies whether the resources consumed by all tasks of the submitted task object exceed the object's resource quota after the task is submitted. The verification methods for ending a task can include task existence verification, which verifies whether the ending task exists in the initial RDF knowledge graph of the intelligent dimension operation. The verification methods for adding an object can include object existence verification, which verifies whether the object to be added exists in the initial RDF knowledge graph of the intelligent dimension operation.

[0044] For example, the initial RDF knowledge graph can be an RDF knowledge graph of a single intelligent computing cluster, or it can be an RDF knowledge graph of multiple clusters. This application does not limit this.

[0045] As can be seen, for dynamically changing events of different event types, this application can adopt a verification method that matches the event type to verify the initial RDF knowledge graph and achieve accurate verification.

[0046] Step 103: If the initial RDF knowledge graph passes the target verification, update the initial RDF knowledge graph of intelligent computing operation and maintenance according to the operation intention and RDF triples to obtain the updated RDF knowledge graph.

[0047] In this application, if the initial RDF knowledge graph passes the target verification, the initial RDF knowledge graph can be updated according to the entities in the RDF triples and the relationships between the entities, so as to obtain the updated RDF knowledge graph.

[0048] For example, the RDF triple {:Job_12345:belongsTo:User_Alice} is intended to insert a relationship between the entities:Job_12345 and User_Alice. Therefore, the relationship between the entities in this RDF triple can be added to the RDF knowledge graph.

[0049] The RDF knowledge graph for intelligent computing operations and maintenance in this embodiment provides a powerful semantic foundation for resource management, monitoring, and optimization of intelligent computing clusters. This enables data based on the RDF knowledge graph to be queried and analyzed efficiently, and can achieve basic intelligent computing operations and maintenance service assurance capabilities such as data observation at the object-oriented (i.e., tenant) level, cluster health checks, task interruption / deterioration diagnosis, and job task path tracing.

[0050] In this embodiment, if a dynamic change event associated with a target object is detected, the dynamic change event is converted into an RDF triple and its corresponding operation intent. Based on the event type of the dynamic change event, the initial RDF knowledge graph for intelligent computing operations is subjected to target verification. If the initial RDF knowledge graph passes the target verification, it is then updated based on the RDF triple and the operation intent to obtain the updated RDF knowledge graph. Thus, by accurately converting detected dynamic change events into RDF triples and their corresponding operation intents, the state change requirements of the target object can be clearly expressed in a semantic and structured manner. Furthermore, by combining the event type of the dynamic change event with targeted target verification of the initial RDF knowledge graph, the accuracy of the verification logic can be improved. Under the premise of successful verification, the initial RDF knowledge graph for intelligent computing operations is updated based on the operation intent and the RDF triple. This not only ensures the consistency and integrity of the graph's state evolution but also effectively avoids data anomalies caused by conflicting changes, improving the reliability of knowledge graph maintenance and the level of intelligent computing operations.

[0051] Figure 3 This is a flowchart illustrating another method for updating an intelligent computing operations and maintenance RDF knowledge graph, provided in some embodiments of this application. For example... Figure 3 As shown, the method for updating the intelligent computing operations and maintenance RDF knowledge graph may include the following steps: Step 301: In response to detecting a dynamic change event associated with the target object, the dynamic change event is converted into an RDF triple and the corresponding operation intent of the RDF triple.

[0052] In this application, step 301 can be implemented in any of the embodiments of this application, so it will not be described in detail here.

[0053] Step 302: In response to the event type of the dynamic change event being "submit task", determine the target verification, which includes entity existence verification.

[0054] In this application, if the event type of the dynamic change event is a task submission, the verification method corresponding to the task submission is determined to include entity existence verification based on the correspondence between event type and verification method. That is, the target verification can include entity existence verification, and entity existence verification is performed on the initial RDF knowledge graph.

[0055] In other words, if the dynamic change event is a task submission event, entity existence verification can be performed on the initial RDF knowledge graph.

[0056] Step 303: Based on the initial RDF knowledge graph, determine the new triples in the RDF triples.

[0057] In this application, for each RDF triple after the transformation of a dynamic change event, it is determined whether the RDF triple is a new triple by querying the initial RDF knowledge graph.

[0058] For example, you can query the entities and relationships between entities in an RDF triple in the initial RDF knowledge graph. If no entity or relationship between entities is found in the initial RDF knowledge graph, the RDF triple can be identified as a new triple.

[0059] Step 304: Based on the entities referenced by the new triples, perform entity existence verification on the initial RDF knowledge graph to obtain the existence verification results.

[0060] In this application, for a new triple, we can query whether the entity referenced by the new triple exists in the initial RDF knowledge graph to obtain the existence verification result.

[0061] For example, the entity referenced by the new triple can refer to the entity that is pointed to as a semantic dependency in the new triple, which is an external dependency object required to establish an association or perform a state change. Here, "external" refers to the main entity relative to the operational intent of the new triple, and the external dependency object is another entity that is associated with the main entity but is not itself an object directly affected by the operational intent.

[0062] For example, in the RDF triple {:Job:12345:belongsTo:User_Alice}, the entity User_Alice is the entity associated with the task, that is, the triple User_Alice is the entity referenced.

[0063] For example, if the operation intent of the new triplet is an insertion operation, that is, in the insertion operation scenario, the referenced entity mainly appears in the object position of the new triplet; if the operation intent of the new triplet is an update or deletion operation, the entity in the subject position is the referenced entity. For example, in the RDF triple {:Use_Alice: hasStatus :"suspended"}, the operation intent is to update the user status, and the entity Use_Alice is the entity referenced by this triplet.

[0064] For example, the existence verification result can be used to indicate whether the entity referenced by the new triple already exists in the initial RDF knowledge graph.

[0065] For example, if the entity referenced by the new triple is found in the initial RDF knowledge graph, the initial RDF knowledge graph can be considered to have passed the existence verification; if the entity referenced by the new triple is not found in the initial RDF knowledge graph, the initial RDF knowledge graph can be considered to have failed the existence verification.

[0066] For example, if the new triple is {:Job:12345:belongsTo:User_Alice}, and the entity User_Alice does not exist in the initial RDF knowledge graph, this may be an error, requiring the user creation process to be triggered or the update to be rejected.

[0067] Step 305: If the initial RDF knowledge graph passes the target verification, update the initial RDF knowledge graph of intelligent computing operation and maintenance according to the RDF triples and operation intentions to obtain the updated RDF knowledge graph.

[0068] In this application, step 305 can be implemented in any of the embodiments of this application, so it will not be described in detail here.

[0069] In this application, the event type of the dynamic change event is the task submission. If the initial RDF knowledge graph passes the entity existence verification in the target verification, the initial RDF knowledge graph can be updated according to the RDF triples and operation intentions.

[0070] In this embodiment of the application, if the event type of the dynamic change event is a task submission, the target verification can be determined to include entity existence verification. Based on the initial RDF knowledge graph, the new triples in the RDF triples obtained by the dynamic change event are determined. It is verified whether the entity referenced by the new triples already exists in the initial RDF knowledge graph. If the referenced entity exists, the initial RDF knowledge graph is then updated. This can avoid errors in knowledge graph updates caused by the non-existence of the referenced entity, thereby improving the accuracy of knowledge graph updates.

[0071] In some embodiments of this application, the following approach can also be used to perform target verification on the initial RDF knowledge graph of intelligent computing operations and maintenance based on the event type of the dynamic change event: If the event type of the dynamic change event is a task submission, the verification method corresponding to the task submission can be determined according to the correspondence between event type and verification method. This means that the target verification can include resource quota verification, and resource quota verification can be performed on the initial RDF knowledge graph. In other words, if the dynamic change event is a task submission event, resource quota verification can be performed on the initial RDF knowledge graph.

[0072] For example, the task submission event may include the resources required by the first target task, which is the task submitted by the target object. Resource quota verification of the initial RDF knowledge graph can be performed as follows: The initial RDF knowledge graph can be queried to obtain the resource quota of the target object and the total resources consumed by all tasks under the target object. Based on the resource quota, total resources, and resources required by the first target task, the RDF triples are verified for resource quota, and the verification result is obtained. The query performed on the initial RDF knowledge graph here is a SPARQL query. SPARQL (SPARQL Protocol and RDF Query Language) is a standard query language recommended by the W3C (World Wide Web Consortium) for RDF data retrieval. For example, the total resources and the resource quota required for the first target task can be compared. If the total resources and the resource quota required for the first target task do not exceed the resource quota, it means that the resource quota of the target object can meet the task requirements when updating the initial RDF knowledge graph according to the submitted task. That is, the initial RDF knowledge graph passes the resource quota verification. If the total resources and the resource quota required for the first target task exceed the resource quota, it can be considered that the initial RDF knowledge graph fails the resource quota verification.

[0073] For example, the resource quota verification result can be used to indicate whether the sum of total resources and the resources required for the first objective task exceeds the resource quota.

[0074] For example, if the event type of the dynamic change event is a task submission, and the initial RDF knowledge graph passes the resource quota verification in the target verification, the initial RDF knowledge graph can be updated according to the RDF triples and operation intent.

[0075] Therefore, if the event type of the dynamic change event is a task submission, a SPARQL query can be performed on the initial RDF knowledge graph. Based on the resources required by the submitted task, the resource quota of the target object and the total resources consumed by all tasks under the target object can be obtained through the query. Resource quota verification can then be performed. If it is confirmed that the resources required by the new task will not cause the resource quota to exceed the limit, the initial RDF knowledge graph can be updated according to the RDF triples and the corresponding operation intentions. This not only ensures that the graph state complies with business policy constraints, but also effectively prevents resource overload and improves the compliance, consistency and operational reliability of intelligent computing cluster resource management.

[0076] Optionally, if the event type of the dynamic change event is a task submission, the target verification can be determined to include entity existence verification and resource quota verification. Entity existence verification and resource quota verification can be performed on the initial RDF knowledge graph separately. If both verifications pass, the initial RDF knowledge graph is updated based on the RDF triples and operation intent. Therefore, updating the initial RDF knowledge graph based on the RDF triples and operation intent after passing entity existence verification and resource quota verification avoids errors caused by non-existent references and prevents resource overload, thus improving the accuracy of the graph update.

[0077] In some embodiments of this application, the dynamic change event can be a task completion event of the first target task. After receiving the first target task submitted by the target object, the first target task can be detected. If a task completion event is detected, the task completion event can be converted into an RDF triple and the corresponding operation intent. Based on the event type of the task completion event, the initial RDF knowledge graph is target-verified. After successful verification, the initial RDF knowledge graph is updated based on the RDF triple obtained from the task completion event and the corresponding operation intent. If the initial RDF knowledge graph is successfully updated, a notification message of the completion of the first target task can be sent to the target system component, so that the target system component can perform a billing operation upon receiving the notification message.

[0078] For example, the target system component can be a system component that has subscribed to a task and is changing its state from running to completion.

[0079] Therefore, after detecting a task completion event, a notification message can be sent to the relevant system components to trigger the billing operation, thereby improving the accuracy of billing.

[0080] In some embodiments of this application, the initial RDF knowledge graph can be a multi-cluster knowledge graph, that is, the initial RDF can be used to describe the resources, objects, and tasks of multiple intelligent computing clusters. In multi-cluster operation and maintenance, cross-cluster task scheduling can be performed. The following uses a cross-cluster task scheduling scenario as an example, combined with... Figure 4 This section explains the updates to the RDF knowledge graph. Figure 4 This is a flowchart illustrating another method for updating an intelligent computing operations and maintenance RDF knowledge graph, provided in some embodiments of this application. For example... Figure 4 As shown, the method for updating the intelligent computing operations and maintenance RDF knowledge graph may also include the following steps: Step 401: Obtain task submission information.

[0081] The task submission information may include task information for the second target task. For example, the task information may include, but is not limited to, a task identifier, task description information, and the computing cluster in which the second target task was submitted.

[0082] For example, the second objective task may be the same as or different from the first objective task described above, and there is no limitation on this.

[0083] Step 402: Based on the task information, determine the dataset required for the second target task and query the cluster where the dataset is located.

[0084] In this application, the dataset required for the second target task can be determined based on the task description information in the task information, and the cluster in which the dataset required for the second target task is stored can be queried.

[0085] Step 403: In response to the dataset being stored in the first cluster, the available resources of the first cluster being less than a preset threshold, and the available resources of the second cluster being greater than a preset threshold, the second target task is scheduled to the second cluster, and the dataset in the first cluster is synchronized to the second cluster.

[0086] In this application, if the dataset required for the second target task is in the first cluster, a query is performed to determine if there are available resources in the first cluster. If the query result shows that the available resources in the first cluster are less than a preset threshold and the available resources in the second cluster are greater than the preset threshold, that is, the available resources in the first cluster are insufficient and the available resources in the second cluster are sufficient, the decision can be made based on the query result to schedule the task to the second cluster, transfer the dataset from the first cluster to the second cluster, schedule the second target task to the second cluster according to the decision, and synchronize the dataset in the first cluster to the second cluster so that the second target task can be processed in the second cluster based on the required dataset.

[0087] It should be noted that both the first and second clusters mentioned above are intelligent computing clusters used to construct the initial RDF knowledge graph.

[0088] Step 404: Update the initial RDF knowledge graph based on the relationship between the dataset and the second cluster.

[0089] In this application, after the dataset is successfully synchronized to the second cluster, the initial RDF knowledge graph can be updated based on the dataset and the second cluster it belongs to, and the second target task can be started in the second cluster. If a notification message that the second target task has been started is received, the RDF knowledge graph can be updated based on the cluster information of the second cluster where the second target task is located and the status information of the second target task.

[0090] For example, the relationship between a dataset and a second cluster can be that the dataset is stored in the second dataset.

[0091] Therefore, updating the RDF knowledge graph with the state of the second target task being located in the second cluster and the second target task being running can achieve global state consistency updates and improve the accuracy of knowledge graph updates.

[0092] Furthermore, the reasoning and updating of cross-cluster dependencies differ significantly from those of a single cluster. For instance, an update in one cluster may trigger actions in another cluster, leading to a chain reaction of updates. For example, when the rule "network link interruption between cluster C1 and cluster C2" is triggered, a batch of update operations can be automatically generated, updating the status of all tasks running on cluster C1 that depend on cluster C2 data to "Blocked".

[0093] In this embodiment, after receiving the task submission information, the dataset required for the second target task can be determined based on the task information of the submitted second target task, and the cluster where the required dataset is located can be queried. If the resources of the first cluster where the dataset is located are insufficient, while the resources of the second cluster are sufficient, cross-cluster task scheduling can be performed on the second target task and the dataset. Based on the relationship between the dataset and the second cluster, the RDF knowledge graph of intelligent operation and maintenance can be updated, thereby realizing the automatic updating of the RDF knowledge graph in the cross-cluster task scheduling scenario and improving the update accuracy of the multi-cluster knowledge graph.

[0094] In addition, the update method of multi-cluster RDF knowledge graph needs to handle richer event sources (such as multi-cluster, heterogeneous clusters, etc.) and adapt to more complex inference rules (such as cross-cluster dependencies). This can ensure that the global RDF knowledge graph can become a real-time, accurate, and reliable "operation and maintenance knowledge brain", providing a reliable data foundation for cross-cluster intelligent scheduling, fault isolation and resource optimization.

[0095] In some embodiments of this application, if the RDF knowledge graph of intelligent computing operations and maintenance is a multi-cluster knowledge graph, the SPARQL query language can be used to query and manipulate these cross-domain data, and the RDF structure supports complex SPARQL queries.

[0096] For example, you can use the SPARQL query language to find all the running tasks of an object and the specific GPUs they use in the RDF knowledge graph of intelligent computing operations and maintenance. Alternatively, you can find out which tasks of which objects were affected by a crashed node.

[0097] In some embodiments of this application, advanced capabilities such as intelligent Q&A for tenant operations and maintenance can be achieved based on the RDF knowledge graph of intelligent computing operations and maintenance, combined with a large model. The following will be combined with... Figure 5 To explain, Figure 5This is a flowchart illustrating another method for updating an intelligent computing operations and maintenance RDF knowledge graph, provided in some embodiments of this application. For example... Figure 5 As shown, the method for updating the intelligent computing operations and maintenance RDF knowledge graph may include the following steps: Step 501: Obtain the intelligent operation and maintenance issues input by the target object.

[0098] In this application, the target object can input intelligent operation and maintenance questions described in natural language in the client interface of the intelligent operation and maintenance system. After the client obtains the intelligent operation and maintenance questions, it can send them to the server, so that the server can obtain the intelligent operation and maintenance questions input by the target object.

[0099] Step 502: Based on the intelligent operation and maintenance problem, search the current RDF knowledge graph of intelligent operation and maintenance to obtain the structured knowledge description related to the intelligent operation and maintenance problem.

[0100] In this application, a structured knowledge description related to the intelligent operation and maintenance problem can be obtained by searching the current RDF knowledge graph of intelligent operation and maintenance based on the intelligent operation and maintenance problem and its context.

[0101] For example, the structured knowledge description (i.e. the graph schema description) is the relevant partial schema information retrieved from the vector index of the current RDF knowledge graph of the intelligent computing operations and maintenance.

[0102] For example, structured knowledge description can refer to the set of meta-information in an RDF knowledge graph used to define entity categories, attribute associations, and instance mappings. Its content comes from the schema layer of the graph and includes, but is not limited to, the definitions of classes, properties, and individuals.

[0103] Step 503: Based on the structured knowledge description, use a large model to obtain the response information for intelligent operation and maintenance issues.

[0104] In this application, based on the structured knowledge description and the intelligent operation and maintenance problem, a large model is first used to generate the query statement corresponding to the intelligent operation and maintenance problem. Then, the query statement corresponding to the intelligent operation and maintenance problem is executed on the current RDF knowledge graph to obtain the structured query results. Finally, based on the structured query results and the intelligent operation and maintenance problem, the large model is used to generate the response information. Here, the query statement refers to a SPARQL query statement.

[0105] For example, based on structured knowledge descriptions and intelligent operation and maintenance issues, and combined with corresponding prompt templates, a query statement can be generated to produce prompt information. This prompt information can then be processed using a large model to obtain the query statement.

[0106] For example, the prompt template may include task information for converting natural language questions into SPARQL query statements. For instance, the task information could be: Your task is to convert natural language questions about the operation and maintenance of intelligent computing clusters into accurate SPARQL query statements.

[0107] For example, this query generation prompt can be used to prompt large models to perform SPARQL query generation tasks.

[0108] For example, based on the structured query results and intelligent operation and maintenance issues, and combined with the corresponding prompt templates, a prompt message can be generated to answer the question. The prompt message can then be processed using a large model to obtain the answer message.

[0109] For example, the prompt template may include task information for generating a response based on the SPARQL query results. For instance, the task information could be: "Please generate a natural and fluent answer to reply to the user based on the following SPARQL query results." For example, the question-and-answer generation prompt information can be used to prompt a large model to perform the question-and-answer generation task.

[0110] For example, if the target user's question is "Which tasks submitted by user Alice yesterday failed?", the large model's output response would be: "Hello, two tasks submitted by user Alice yesterday failed. Their IDs are Job_12345 and Job_67890. You can click on the ID to view the detailed logs, or contact the operations and maintenance personnel to further investigate the cause." Therefore, by using a large model to automatically transform intelligent operation and maintenance questions in natural language form into precise SPARQL queries, and by performing semantic alignment data retrieval on the RDF knowledge graph based on structured knowledge descriptions, high-fidelity structured query results are obtained. Then, the large model is used again to integrate the question intent and query results to generate natural, accurate, and interpretable response information. This not only significantly reduces the technical threshold for operation and maintenance personnel to access complex graph data, but also realizes end-to-end intelligent interaction from "fuzzy questioning" to "precise answering". It can effectively improve the accuracy, contextual consistency, and response efficiency of operation and maintenance question answering, and improve the operation and maintenance efficiency and service quality of intelligent computing environments.

[0111] In this embodiment, by combining the natural language understanding and generation capabilities of large models with the structured semantic expression and precise reasoning capabilities of RDF knowledge graphs, an intelligent question-answering engine for intelligent computing cluster operation and maintenance is constructed. This engine can dynamically retrieve structured knowledge descriptions related to questions based on the current knowledge graph, and generate accurate, consistent, and interpretable response information based on these descriptions. This not only improves the accuracy and credibility of tenant-side operation and maintenance questions and answers, but also effectively reduces the cost of manual intervention, enhances the autonomous operation and maintenance capabilities of the intelligent computing environment, and thus comprehensively improves operation and maintenance efficiency, service response quality, and user experience.

[0112] In this embodiment of the application, the object operation and maintenance knowledge graph construction, updating and intelligent question answering scheme for intelligent computing clusters can connect the overall end-to-end process of intelligent computing underlying operation and maintenance and upper-layer business, so that the upper-layer business can effectively perceive the progress of underlying operation and maintenance, and the underlying operation and maintenance can accurately perceive the status of upper-layer business, effectively solving the problems of difficult fault delimitation and location and slow processing progress in intelligent computing, and ensuring the stable operation of upper-layer intelligent computing business.

[0113] Figure 6 This is a schematic diagram of the structure of an intelligent computing operation and maintenance RDF knowledge graph updating device provided in some embodiments of this application.

[0114] like Figure 6 As shown, the intelligent computing operations and maintenance RDF knowledge graph update device 600 includes: The conversion module 610 is used to convert the dynamic change event associated with the target object into an RDF triple and the corresponding operation intent in response to the detection of the dynamic change event. The verification module 620 is used to perform target verification on the initial RDF knowledge graph of intelligent computing operation and maintenance based on the event type of dynamically changing events; wherein, the initial RDF knowledge graph is used to describe the resources, objects and tasks in the intelligent computing cluster; The update module 630 is used to update the initial RDF knowledge graph based on the RDF triples and operation intent, after the initial RDF knowledge graph has passed the target verification, so as to obtain the updated RDF knowledge graph.

[0115] Optionally, the verification module 620 is used for: The event type that responds to dynamic change events is task submission, and the target verification includes entity existence verification. Based on the initial RDF knowledge graph, determine the new triples in the RDF triples; Based on the entities referenced by the new triples, the existence of the entities in the initial RDF knowledge graph is verified to obtain the existence verification result; the existence verification result is used to indicate whether the entities referenced by the new triples already exist in the initial RDF knowledge graph.

[0116] Optionally, the verification module 620 is used for: The event type responding to the dynamic change event is task submission, and the target verification includes resource quota verification; wherein, the dynamic change event includes the resources required by the first target task; The initial RDF knowledge graph is queried to obtain the resource quota of the target object and the total resources consumed by all tasks under the target object; Based on the resource quota, total resources, and resources required for the first objective task, the initial RDF knowledge graph is subjected to resource quota verification to obtain the resource quota verification result. The resource quota verification result is used to indicate whether the sum of the total resources and the resources required for the first objective task exceeds the resource quota.

[0117] Optionally, the dynamic change event includes the task completion event of the first target task, and the device may further include: The sending module is used to send a notification message that the first target task has been completed to the target system component in response to the successful initial RDF knowledge graph update, so that the target system component can perform billing operations when it receives the notification message; The target system component is the system component whose state changes from running to completion of the subscribed task.

[0118] Optionally, the initial RDF knowledge graph belongs to a multi-cluster knowledge graph, and the device may further include: The first acquisition module is used to acquire task submission information; wherein, the task submission information includes the task information of the second target task; The query module is used to determine the dataset required for the second target task based on the task information, and to query the cluster where the dataset is located; The scheduling module is used to schedule the second target task to the second cluster and synchronize the dataset in the first cluster to the second cluster in response to the following conditions: the dataset is stored in the first cluster, the available resources of the first cluster are less than a preset threshold, and the available resources of the second cluster are greater than a preset threshold. The update module 630 is also used to update the initial RDF knowledge graph based on the relationship between the dataset and the second cluster.

[0119] Optionally, the device may further include: The startup module is used to launch the second target task in the second cluster. The update module 630 is also used to update the initial RDF knowledge graph in response to receiving a notification that the second target task has been started, based on the cluster information where the second target task is located and the status information of the second target task.

[0120] Optionally, the device may further include: The second acquisition module is used to acquire intelligent operation and maintenance questions input by the target object; The retrieval module is used to search the current RDF knowledge graph of intelligent computing operations and maintenance based on intelligent operation and maintenance issues, and obtain structured knowledge descriptions related to intelligent operation and maintenance issues. The third acquisition module is used to obtain response information for intelligent operation and maintenance issues based on structured knowledge descriptions and large models.

[0121] Optionally, the third acquisition module is used for: Based on the descriptions of intelligent operation and maintenance issues and structured knowledge, a large model is used to generate query statements corresponding to intelligent operation and maintenance issues. For the current RDF knowledge graph, execute the query statement corresponding to the intelligent operation and maintenance problem to obtain the structured query results; Based on the structured query results and intelligent operation and maintenance issues, a large model is used to generate response information.

[0122] It should be noted that the explanation of the above-described embodiment of the method for updating the intelligent computing operation and maintenance RDF knowledge graph also applies to the device for updating the intelligent computing operation and maintenance RDF knowledge graph in this embodiment, and will not be repeated here.

[0123] In this embodiment, by accurately converting detected dynamic change events into RDF triples and their corresponding operational intentions, the state change requirements of the target object can be clearly expressed in a semantic and structured manner. At the same time, by combining the event type of the dynamic change event, targeted target verification can be performed on the initial RDF knowledge graph, which can improve the accuracy of the verification logic. Under the premise of successful verification, the initial RDF knowledge graph of intelligent dimension operation is updated according to the operational intention and RDF triples. This not only ensures the consistency and integrity of the graph state evolution, but also effectively avoids data anomalies caused by conflicting changes, thereby improving the reliability of knowledge graph maintenance and the level of intelligent computing operation and maintenance.

[0124] To implement the above embodiments, this application also proposes an electronic device, including: a processor and a memory communicatively connected to the processor; the memory stores computer execution instructions; the processor executes the computer execution instructions stored in the memory to implement the method provided in the foregoing embodiments.

[0125] To implement the above embodiments, this application also proposes a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the methods provided in the foregoing embodiments.

[0126] To implement the above embodiments, this application also proposes a computer program product, including a computer program that, when executed by a processor, implements the methods provided in the foregoing embodiments.

[0127] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in this application all comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0128] It should be noted that personal information collected from users should be used for legitimate and reasonable purposes and should not be shared or sold outside of these legitimate uses. Furthermore, such collection / sharing should only be conducted after receiving the user's informed consent, including but not limited to notifying the user to read the user agreement / user notice and sign an agreement / authorization that includes authorization of relevant user information before the user uses the function. In addition, any necessary steps must be taken to protect and safeguard access to such personal information data and ensure that others with access to personal information data comply with their privacy policies and procedures.

[0129] This application is intended to provide an implementation scheme for users to selectively prevent the use or access to their personal information data. Specifically, this disclosure is intended to provide hardware and / or software to prevent or block access to such personal information data. Once personal information data is no longer needed, risks can be minimized by restricting data collection and deleting data. Furthermore, where applicable, such personal information is de-identified to protect user privacy.

[0130] In the foregoing descriptions of the embodiments, the terms "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., refer to specific features, structures, materials, or characteristics described in connection with that embodiment or example, which are included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0131] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0132] Any process or method description in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or more executable instructions for implementing custom logic functions or processes, and the scope of the preferred embodiments of this application includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as should be understood by those skilled in the art to which embodiments of this application pertain.

[0133] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable media include: an electrical connection having one or more wires (electronic device), a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Alternatively, the computer-readable medium may be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in a computer memory.

[0134] It should be understood that various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0135] Those skilled in the art will understand that all or part of the steps of the methods in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, the program includes one or a combination of the steps of the method embodiments.

[0136] Furthermore, the functional units in the various embodiments of this application can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0137] The storage medium mentioned above can be a read-only memory, a disk, or an optical disk, etc. Although embodiments of this application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting this application. Those skilled in the art can make changes, modifications, substitutions, and variations to the above embodiments within the scope of this application.

Claims

1. A method for updating an intelligent computing operations and maintenance RDF knowledge graph, characterized in that, include: In response to the detection of a dynamic change event associated with the target object, the dynamic change event is converted into a Resource Description Framework (RDF) triple and the corresponding operation intent of the RDF triple; Based on the event type of the dynamically changing event, target verification is performed on the initial RDF knowledge graph of the intelligent computing operation and maintenance; wherein, the initial RDF knowledge graph is used to describe the resources, objects and tasks in the intelligent computing cluster; If the initial RDF knowledge graph passes the target verification, the initial RDF knowledge graph is updated according to the RDF triples and the operation intent to obtain the updated RDF knowledge graph.

2. The method as described in claim 1, characterized in that, The step of performing target verification on the initial RDF knowledge graph of intelligent computing operations and maintenance based on the event type of the dynamically changing event includes: In response to the event type of the dynamic change event being task submission, it is determined that the target verification includes entity existence verification; Based on the initial RDF knowledge graph, determine the new triples in the RDF triples; Based on the entity referenced by the new triple, the existence of the entity is verified on the initial RDF knowledge graph to obtain an existence verification result; wherein, the existence verification result is used to indicate whether the entity referenced by the new triple already exists in the initial RDF knowledge graph.

3. The method as described in claim 1, characterized in that, The step of performing target verification on the initial RDF knowledge graph of intelligent computing operations and maintenance based on the event type of the dynamically changing event includes: In response to the event type of the dynamic change event being "task submission", the target verification is determined to include resource quota verification; wherein, the dynamic change event includes the resources required by the first target task; The initial RDF knowledge graph is queried to obtain the resource quota of the target object and the total resources consumed by all tasks under the target object; Based on the resource quota, the total resources, and the resources required for the first target task, the resource quota is verified on the initial RDF knowledge graph to obtain a resource quota verification result; wherein, the resource quota verification result is used to indicate whether the sum of the total resources and the resources required for the first target task exceeds the resource quota.

4. The method as described in claim 1, characterized in that, The dynamic change event includes the task completion event of the first target task, and the method further includes: In response to the successful update of the initial RDF knowledge graph, a notification message indicating the completion of the first target task is sent to the target system component, so that the target system component performs a billing operation upon receiving the notification message; The target system component is a system component whose subscribed task changes state from running to completion.

5. The method as described in claim 1, characterized in that, The initial RDF knowledge graph is a multi-cluster knowledge graph, and the method further includes: Obtain task submission information; wherein, the task submission information includes task information of the second target task; Based on the task information, determine the dataset required for the second target task, and query the cluster where the dataset is located; In response to the dataset being stored in a first cluster, the available resources of the first cluster being less than a preset threshold, and the available resources of the second cluster being greater than the preset threshold, the second target task is scheduled to the second cluster, and the dataset in the first cluster is synchronized to the second cluster; The initial RDF knowledge graph is updated based on the relationship between the dataset and the second cluster.

6. The method as described in claim 5, characterized in that, The method further includes: Start the second target task in the second cluster; In response to receiving a notification that the second target task has been started, the initial RDF knowledge graph is updated based on the cluster information where the second target task is located and the status information of the second target task.

7. The method as described in claim 1, characterized in that, The method further includes: Intelligent operation and maintenance issues obtained from the target object; Based on the intelligent operation and maintenance problem, a search is performed in the current RDF knowledge graph of intelligent computing operation and maintenance to obtain a structured knowledge description related to the intelligent operation and maintenance problem; Based on the structured knowledge description, a large model is used to obtain the response information for the intelligent operation and maintenance problem.

8. The method as described in claim 7, characterized in that, The step of obtaining the response information for the intelligent operation and maintenance problem based on the structured knowledge description and using a large model includes: Based on the intelligent operation and maintenance problem and the structured knowledge description, the large model is used to generate the query statement corresponding to the intelligent operation and maintenance problem; For the current RDF knowledge graph, execute the query statement corresponding to the intelligent operation and maintenance problem to obtain the structured query results; Based on the structured query results and the intelligent operation and maintenance problem, the large model is used to generate the response information.

9. A device for updating an intelligent computing operations and maintenance RDF knowledge graph, characterized in that, include: The conversion module is used to convert the dynamic change event associated with the target object into an RDF triple and the corresponding operation intent in response to the detection of the dynamic change event. The verification module is used to perform target verification on the initial RDF knowledge graph of the intelligent computing operation and maintenance according to the event type of the dynamic change event; wherein, the initial RDF knowledge graph is used to describe the resources, objects and tasks in the intelligent computing cluster; An update module is used to update the initial RDF knowledge graph according to the RDF triples and the operation intent, if the initial RDF knowledge graph passes the target verification, to obtain an updated RDF knowledge graph.

10. An electronic device, characterized in that, include: A processor, and a memory communicatively connected to the processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory to implement the method as described in any one of claims 1-8.

Images