Instruction cluster generation method and system based on instruction collaborative network

Abstract

The invention provides an instruction cluster generation method based on an instruction collaboration network, which comprises the following steps of: constructing the instruction collaboration network, and modeling instruction node characteristics and dependency relationships by utilizing a graph neural network (GNN); dynamic scheduling is realized through graph convolution optimization of an instruction cooperation relationship and combination of reinforcement learning (RL) and a deep Q network (DQN); automatically decomposing the task into sub-tasks based on a semantic mapping function and generating an instruction sequence; a fault-tolerant mechanism is designed, and the robustness of the system is guaranteed through fault detection, dynamic rescheduling and feedback optimization. The multi-instruction cooperation efficiency and the resource utilization rate are remarkably improved, and the labor cost is reduced; a fault-tolerant mechanism enhances system reliability and task continuity; the scheme is suitable for the fields of industrial automation, robot control, big data processing and the like, and solves the common problem of multi-task cooperative execution.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of instruction coordination network, and particularly relates to an instruction cluster generation method and system based on an instruction coordination network. BACKGROUND

[0002] With the rapid development of industrial automation, robot control and big data processing, the demand for efficient execution of complex tasks is increasing. In such scenarios, the execution of tasks often involves the coordinated scheduling of multiple instructions, which requires coordination of the timing dependencies between instructions, resource allocation and fault tolerance processing to improve the execution efficiency and robustness of the overall system. However, existing task scheduling and instruction generation techniques still face significant challenges.

[0003] 1) Traditional methods mainly rely on rule-based static scheduling strategies or manually preset resource allocation schemes. For example, a rule engine arranges instruction execution through predefined priorities or sequences, which can handle simple tasks, but has obvious shortcomings in dynamic environments: 2) Static scheduling defects: existing solutions mostly use fixed rules, which cannot be dynamically adjusted according to real-time resource status or task requirements, resulting in low resource utilization or execution delay; 3) Lack of intelligence: traditional techniques lack deep analysis of complex relationships between instructions, making it difficult to optimize scheduling strategies using machine learning (such as reinforcement learning, graph neural networks), especially when dealing with high concurrency and multi-dependence tasks; 4) Weak fault tolerance: existing systems often lack effective fault detection and recovery mechanisms, and device abnormalities or resource conflicts can easily cause task interruptions, affecting system reliability; 5) Lack of instruction coordination: the timing dependencies, concurrency requirements and resource conflicts between instructions are not fully modeled, and simple sequential scheduling or resource allocation cannot achieve efficient coordination.

[0004] In recent years, some research has attempted to introduce machine learning techniques to improve task scheduling, such as using reinforcement learning to optimize dynamic decision-making or using graph structures to model task relationships. However, existing improvements still have limitations: most methods only focus on a single aspect (such as scheduling or instruction generation), and fail to integrate task decomposition, semantic mapping, coordination optimization and fault tolerance mechanisms into a complete process; the application of graph neural networks is mostly focused on node feature extraction, without deep optimization of the dependencies between instructions and resource conflicts; fault tolerance mechanisms lack real-time linkage with dynamic scheduling, resulting in low fault recovery efficiency.

[0005] Therefore, there is an urgent need for a systematic method that integrates intelligent task decomposition, instruction coordination optimization, dynamic scheduling and fault tolerance processing to address the multi-dimensional challenges in complex task execution environments, improving execution efficiency, resource utilization and system robustness. SUMMARY

[0006] The application provides an instruction cluster generation method and system based on an instruction collaborative network, which solves the problems of low data standardization and governance efficiency and the inability to comprehensively cover the whole process from data governance to intelligent analysis in the prior art. The technical scheme of the application is implemented as follows: An instruction cluster generation method based on an instruction collaborative network comprises the following steps: Step S1: An instruction collaborative network is constructed, a task is decomposed into multiple subtasks, each subtask is mapped to an instruction node, a feature vector of the instruction node is modeled by a graph neural network (GNN), the feature vector comprises an execution type, resource demand, execution time and priority, a dependency relationship between the instruction nodes is defined by an adjacency matrix, and the dependency relationship comprises a time sequence dependency, a concurrent dependency and a resource conflict; Step S2: The instruction collaborative network is optimized, a graph convolution layer is used to iteratively update the feature vector of the instruction node, neighbor node information is converged, and the collaborative execution relationship between the instructions is optimized; Step S3: An instruction cluster is generated, according to the optimized instruction collaborative network, a semantic mapping function is combined to convert the subtask target into a specific execution instruction, and a collaborative instruction cluster is generated; Step S4: The instruction cluster is dynamically scheduled, a state, an action and a reward mechanism are defined based on a reinforcement learning framework, a deep Q network (DQN) is used to adjust the instruction execution order in real time, and resource utilization is maximized; Step S5: Fault tolerance processing, device state and instruction execution abnormities are monitored in real time, dynamic rescheduling is triggered, a fault diagnosis model is optimized through a feedback mechanism, and task continuity is ensured.

[0007] As a further technical scheme, the feature vector of the instruction node is represented by the following formula:

[0008] wherein, represents an instruction type, represents a resource required by the instruction, represents an execution time of the instruction, represents a priority of the instruction, represents an execution duration of the instruction.

[0009] As a further technical scheme, the node feature updating formula of the graph convolution layer is as follows:

[0010] wherein, is a feature vector of a kth layer node i, N(i) represents a neighbor set of the node i, is a normalization coefficient in an adjacency matrix, is a weight matrix of the kth layer, is a bias term, and σ is an activation function.

[0011] As a further technical solution, the reward mechanism of the reinforcement learning framework is defined by the following formula:

[0012] where J(π) is the maximum reward value, γ is a discount factor, and E represents the importance of future rewards, is the reward for taking action in state .

[0013] As a further technical solution, the fault diagnosis model evaluates the instruction fault score by the following formula:

[0014] wherein represents the fault score of instruction I, is the i-th feature of the device performance, is the weight of the corresponding feature.

[0015] As a further technical solution, the semantic mapping function is a mapping protocol based on predefined rules and task constraints, which converts subtask goals into executable instruction sequences.

[0016] As a further technical solution, in the deep Q network, the Q value update formula is as follows:

[0017] wherein α is the learning rate, S t is the current state, a t is the current action; S t+1 is the next state, a t+1 is the next action, and the goal of the Q value update is to gradually approach the optimal scheduling strategy through learning and experimentation.

[0018] An instruction cluster generation system based on an instruction collaborative network, comprising: an instruction collaborative network construction module: for decomposing a task into multiple subtasks and mapping each subtask to an instruction node; modeling the feature vector of the instruction node through a graph neural network (GNN), and defining the dependency relationship between the instruction nodes through an adjacency matrix; an instruction collaboration optimization module: iteratively updating the feature vector of the instruction node using a graph convolution layer to optimize the collaborative execution relationship between instructions; an instruction cluster generation module: generating a collaborative instruction cluster according to the optimized instruction collaborative network in combination with a semantic mapping function; Dynamic scheduling module: based on reinforcement learning framework and deep Q network (DQN), real-time adjustment of instruction execution order, and maximization of resource utilization; Fault-tolerant processing module: real-time monitoring of device state and instruction execution exception, triggering dynamic rescheduling, and optimizing fault diagnosis model through feedback mechanism; Storage module: for storing instruction coordination network structure, historical scheduling data and fault diagnosis model; Interactive device: provides a friendly interactive interface to support instruction generation interaction with users.

[0019] As a further technical solution, the dynamic scheduling module includes: Policy update unit: adjust the instruction execution order according to the Q value output by the deep Q network; Reward calculation unit: based on resource utilization, execution time and task completion rate to calculate immediate reward; As a further technical solution, the fault-tolerant processing module includes: Fault detection unit: evaluate the instruction fault score through real-time performance indicators; Dynamic rescheduling unit: generate an alternative scheduling scheme based on historical execution data when a fault is detected; Feedback optimization unit: update the feature weights in the fault diagnosis model according to the fault handling results.

[0020] Compared with the prior art, the present scheme has the following beneficial effects: (1) Instruction coordination efficiency is significantly improved: the temporal dependence, concurrency dependence and resource conflict relationship between instructions are modeled by graph neural network (GNN), the instruction coordination network is optimized, the execution time and resource waste are reduced, and the multi-instruction coordination execution efficiency is improved; (2) Dynamic scheduling adaptability: based on reinforcement learning (RL) and deep Q network (DQN), real-time adjustment of instruction execution order and resource allocation, breaking through the limitations of traditional static scheduling, adapting to dynamic environmental changes, maximizing resource utilization; (3) System robustness is enhanced: through real-time fault detection, dynamic rescheduling and feedback optimization mechanism, quickly recover task execution when device is abnormal or resource conflict, guarantee system high availability and task continuity; (4) Task-to-instruction automatic generation: using semantic mapping function to decompose complex tasks into subtasks, and automatically generating specific execution instructions, reducing the dependence on artificial rules, improving instruction generation accuracy and efficiency; (5) Multi-domain applicability: the technical solution covers the whole process of task decomposition, instruction generation, coordination optimization and fault-tolerant processing, and can be widely applied to industrial automation, robot control, big data processing and other multi-task coordination scenarios. BRIEF DESCRIPTION OF DRAWINGS

[0021] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings needed to be used in the embodiments or prior art description. Obviously, the drawings in the following description only constitute some embodiments of the present application, and for those skilled in the art, other drawings can also be obtained without creative labor on the basis of these drawings.

[0022] Figure 1 The method flow chart of the instruction cluster generation method based on the instruction collaborative network of the present application; Figure 2 The structural block diagram of the instruction cluster generation system based on the instruction collaborative network of the present application. DETAILED DESCRIPTION

[0023] The technical solutions of the present application will be described clearly and completely in combination with the embodiments of the present application. Obviously, the described embodiments only constitute some embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the protection scope of the present application.

[0024] REFERENCE Figure 1 The present application proposes an instruction cluster generation method based on an instruction collaborative network, which utilizes advanced technologies such as graph neural network (GNN), reinforcement learning (RL), semantic mapping, and task scheduling algorithm to realize automatic instruction generation and optimization for complex tasks. The purpose of instruction cluster generation is to automatically generate an efficient execution scheme that meets the task requirements, and to solve problems such as resource scheduling and time optimization in multi-task execution by deeply optimizing the collaborative relationship between instructions. The following is the detailed implementation process of the present application, which covers instruction collaborative network construction, task decomposition and instruction generation, reinforcement learning scheduling, fault tolerance mechanism, and other aspects.

[0025] 1. Construction of instruction collaborative network

[0026] The instruction collaborative network is the core component of the present application. By decomposing tasks into multiple instructions and deeply optimizing the collaborative relationship between instructions through graph neural network (GNN), the system can efficiently generate instruction clusters that meet the requirements.

[0027] 1.1 Instruction node construction and feature representation

[0028] In the construction of the instruction collaborative network, each instruction is represented as a node in the network. The feature vector of each node reflects multiple attributes of the instruction, such as execution type, resource demand, execution time, etc. The feature vector of the instruction can be represented in the following way:

[0029] where, represents the instruction type (e.g., computation, data transfer, etc.), represents the resources required by the instruction (e.g., CPU, memory, etc.), represents the execution time of the instruction, represents the priority of the instruction, represents the execution duration of the instruction. By modeling these characteristics, the requirements and features of each instruction can be comprehensively understood.

[0030] 1.2 Modeling of Inter-Instruction Relationships and Dependencies

[0031] The dependencies between instructions are represented by edges. Each edge represents the relationship between instructions and , and the weight of the edge reflects the degree of dependency between them. The dependencies between instructions mainly include: Temporal dependency: Instruction must be executed before .

[0032] Concurrent dependency: Instructions and must be executed within the same time period.

[0033] Resource conflict: Instructions and need to share resources, and if resources are insufficient, scheduling processing is required.

[0034] Dependencies are represented by an adjacency matrix A, where the elements in the matrix take values of 0 or 1, indicating whether instructions have a dependency relationship:

[0035] 1.3 Graph Neural Network Optimizes Instruction Collaboration Network

[0036] Graph Neural Network (GNN) optimizes the instruction collaboration network through graph convolution layers. In each layer of graph convolution, the node features will be aggregated with the information of neighboring nodes, and further processed through weight matrices and activation functions. The update formula of the k-th layer is as follows:

[0037] where, is the feature vector of node i in the k-th layer, N(i) represents the neighbor set of node i, is the normalization coefficient in the adjacency matrix, is the weight matrix of the k-th layer, is the bias term, and σ is the activation function (e.g., ReLU). Through multi-layer graph convolution, the system can continuously optimize the coordination relationship between instructions and improve the generation efficiency of instruction clusters.

[0038] 2. Task decomposition and instruction cluster generation

[0039] Task decomposition refers to the process of breaking down a complex task into multiple sub-tasks, each of which can be completed through different instructions. The system converts sub-tasks into corresponding instructions through semantic mapping and optimizes the generation of instruction clusters through the instruction coordination network.

[0040] 2.1 Task decomposition and sub-task generation

[0041] The purpose of task decomposition is to break down a complex task T into multiple independent sub-tasks . Each sub-task has a clear goal and constraints. The mathematical formula of task decomposition is:

[0042] The dependency relationship between sub-tasks can be further optimized through graph neural networks to ensure the collaboration relationship and execution order between sub-tasks. When generating sub-tasks, you can automatically derive the specific execution steps of each sub-task according to the task type and goal, through predefined mapping rules and standardized protocols.

[0043] 2.2 Semantic mapping and instruction generation

[0044] The semantic mapping process maps tasks into specific execution instructions . Through the semantic mapping function M, the system can automatically generate corresponding instructions according to the target requirements of the task and the characteristics of the instructions. The mapping formula is:

[0045] Here, M is the semantic mapping function, which aims to generate adaptive instructions according to the target requirements of the sub-task and the characteristics of the instructions. Semantic mapping not only depends on the goal of the task, but also takes into account the execution environment, resource requirements, and other factors of the task to ensure that the generated instructions are feasible and efficient.

[0046] 2.3 Instruction coordination network construction

[0047] After instruction generation, all instructions are combined into an instruction coordination network. This network not only considers the temporal dependencies between instructions, but also optimizes the collaboration relationship between instructions through graph neural networks. The coordination relationship between instructions is further optimized through graph convolution, ensuring optimal resource scheduling and task execution efficiency when executing instructions.

[0048] 3. Reinforcement Learning for Optimizing Instruction Scheduling

[0049] Reinforcement Learning (RL) is used to optimize the execution order of instructions to ensure that tasks are executed in the optimal order, maximizing efficiency and resource utilization. Through a feedback mechanism of state, action, and reward, the system continuously adjusts the scheduling policy.

[0050] 3.1 Reinforcement Learning Framework and Scheduling Policy

[0051] The reinforcement learning framework includes the definition of state , action , and reward . The state represents the current execution state of the task, the action represents the current scheduling choice, and the reward represents the pros and cons of the scheduling result. The goal of reinforcement learning is to maximize the cumulative reward:

[0052] where γ is the discount factor, E represents the importance of future rewards, is the reward for taking action in state .

[0053] 3.2 Q-learning and Deep Q Network (DQN)

[0054] Through the Q-learning algorithm, the system selects the optimal scheduling scheme according to the current state and action . The Q-value update formula is as follows:

[0055] where α is the learning rate, controlling the weight update in the learning process. The goal of Q-value update is to gradually approach the optimal scheduling policy through learning and experimentation.

[0056] For complex scheduling problems, a Deep Q Network (DQN) is used to approximate the Q-value function. DQN trains a Q-value function approximator through a deep neural network to solve scheduling problems in high-dimensional state space.

[0057] 4. Fault Tolerance Mechanism and Robustness Improvement

[0058] To improve the robustness of the system, the invention designs a dynamic fault tolerance mechanism to ensure that the system can continue to execute tasks when devices fail or resources are insufficient, and through task rescheduling to ensure the smooth completion of tasks.

[0059] 4.1 Fault Detection and Diagnosis

[0060] The system can automatically trigger fault-tolerant mechanisms when it detects device failures or abnormal command execution through real-time monitoring of device status. Fault detection is performed by evaluating performance indicators (such as load, response time, etc.) of the device online to form a fault diagnosis model:

[0061] wherein, represents the fault score of the command III, is the i-th feature of the device performance, is the weight of the corresponding feature.

[0062] 4.2 Task rescheduling

[0063] After detecting a fault, the system will reschedule tasks through a reinforcement learning mechanism to select the optimal execution scheme. The new scheduling scheme will be adjusted based on real-time feedback and historical execution to ensure that task execution is not affected in the event of a fault.

[0064] 4.3 Feedback mechanism

[0065] The system continuously optimizes task scheduling and fault-tolerant strategies through a real-time feedback mechanism. By collecting fault types and task execution results, the system can adjust the scheduling strategy based on historical data to improve the efficiency and robustness of the fault-tolerant mechanism.

[0066] Correspondingly, the present embodiment also provides a kind of instruction cluster generation system based on instruction coordination network for matching use, refer to Figure 2 which includes: instruction coordination network construction module: for decomposing task into multiple sub-tasks, and mapping each sub-task as instruction node;Through graph neural network (GNN), the feature vector of instruction node is modeled, and the dependence relationship between instruction nodes is defined by adjacency matrix; instruction coordination optimization module: the feature vector of instruction node is iteratively updated using graph convolution layer, to optimize the cooperative execution relationship between instructions; instruction cluster generation module: according to the optimized instruction coordination network, combined with semantic mapping function, cooperative instruction cluster is generated; dynamic scheduling module: based on reinforcement learning framework and deep Q network (DQN), real-time adjusts instruction execution order, and maximizes resource utilization; fault-tolerant processing module: real-time monitoring device status and instruction execution exception, triggers dynamic rescheduling, and optimizes fault diagnosis model through feedback mechanism; storage module: for storing instruction coordination network structure, historical scheduling data and fault diagnosis model; interactive device: provide friendly interactive interface, support and user instruction generation interaction.

[0067] Wherein, the dynamic scheduling module comprises: The policy updating unit adjusts the execution order according to the Q value output by the deep Q network; The reward calculation unit calculates the immediate reward based on resource utilization, execution time and task completion rate; Further, the fault-tolerant processing module comprises: The fault detection unit evaluates the instruction fault score through real-time performance indicators; The dynamic rescheduling unit generates an alternative scheduling scheme based on historical execution data when a fault is detected; The feedback optimization unit updates the feature weights in the fault diagnosis model according to the fault handling result.

[0068] To verify the effectiveness of the "instruction cluster generation method based on instruction coordination network" of the present application, a complete instruction cluster generation example is constructed taking the robot assembly task in the industrial manufacturing scene as an example, and the whole process from task reception to instruction cluster output is demonstrated. Assuming that the system faces the following comprehensive automation operation task: Task name: multi-step robot collaborative operation task Task goal: use industrial robots to complete the following operation process: 1) Identify the location of the target part; 2) Control the robot arm to go to the target position; 3) Complete the grabbing operation; 4) Transport the part to the assembly station; 5) Complete the automatic assembly of the part.

[0069] This task has typical complex instruction dependency structure, resource conflict management demand and collaborative execution characteristics, and is suitable for being used as an example verification object of the method of the present application.

[0070] Step one: task decomposition and semantic mapping

[0071] 1. Subtask decomposition

[0072] The system first receives the task requirement text or instruction, and through natural language analysis and domain rule matching, the overall task is decomposed into multiple subtasks, and the structure is as follows:

[0073] 2. Semantic mapping generates preliminary instructions

[0074] Each subtask is converted into a structured instruction Ii through a semantic mapping function M(Ti, Ci), corresponding to module resources, estimated time, priority, etc., and an example is as follows:

[0075] The feature vector structure of each instruction is: = [typ , resourc , exec_tim , priorit , duratio ] This structure will serve as the initial feature representation of the subsequent graph neural network input nodes.

[0076] Step two: build instruction coordination network

[0077] 1. Network structure definition

[0078] A directed graph G = (V, E) containing 5 nodes is constructed, where: Each node corresponds to an execution instruction ; Indicates that instruction must be executed before instruction I ; The dependency relationship between nodes comes from task logic, resource constraints, timing requirements, etc. The adjacency matrix A is as follows:

[0079] The node features are updated iteratively using a multi-layer GNN, and the feature update of each layer is as follows: 2. Graph neural network optimization After 3 rounds of GNN iteration:

[0080] The system identifies that the dependency strength of I4 and I5 is weak, and can be scheduled in advance through task merging or soft scheduling; Identify the similarity of I2 and I3 features, and use branch prediction to improve parallelism.

[0081] Step three: reinforcement learning optimization scheduling order

[0082] 1. State-action-reward modeling

[0083] State s_t: current instruction execution state and resource distribution; Action a_t: current instruction selection for scheduling; Reward r_t: completion, parallelism, conflict loss; The reinforcement learning objective function is to maximize the expected total return:

[0084] Using the Deep Q-Network (DQN) framework, a Q-value approximator is trained to guide scheduling.

[0085] 2. Output scheduling policy

[0086] Optimization order: I1→I2→(I3 partially overlaps with I4)→I5

[0087] Overall time-consuming optimization: original 675ms reduced to 540ms, improving 20% scheduling efficiency.

[0088] Step four: instruction cluster generation and executable packaging

[0089] Packaging the optimized instruction set after scheduling into an instruction cluster: Cluster = { Number of instructions: 5, Execution order: [I1, I 2, (I3 parallel I4), I5], Fault tolerance strategy: I3 fails up to 2 retries, I4 switches to the backup channel when there is a bus conflict, Execution time budget: 540ms }.

[0090] Based on the above statements and examples, the present scheme has the following outstanding technical progress compared to the prior art: Intelligent optimization: through the use of graph neural networks (GNN) and reinforcement learning (RL) techniques, the present invention can intelligently optimize the generation of instruction clusters and task scheduling, maximizing execution efficiency and resource utilization.

[0091] Dynamic scheduling: the introduction of reinforcement learning allows the system to dynamically adjust task scheduling based on real-time feedback, adapting to different execution environments and resource constraints, avoiding the limitations of traditional static scheduling schemes.

[0092] Strong fault tolerance: the present invention designs a complete fault tolerance mechanism that can automatically adjust task execution schemes in the event of device failure or resource conflict, ensuring high availability and robustness of the system.

[0093] Efficient instruction collaboration: the instruction collaboration network optimizes the timing and resource scheduling relationship between instructions, ensuring efficient collaboration of instructions in task execution and reducing execution time and resource waste.

[0094] Widely applicable: this method is applicable to a variety of task scheduling and instruction generation scenarios, especially suitable for applications in industrial automation, robot control, big data processing, etc.

[0095] The above merely provides the preferred embodiment of the present application, and is not used to limit the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the protection scope of the present application.

Claims

1. A method for generating an instruction cluster based on an instruction coordination network, characterized in that: The following steps are involved: Step S1: Construct an instruction collaboration network, decompose the task into multiple subtasks, map each subtask to an instruction node, and use a graph neural network (GNN) to model a feature vector for the instruction node. The feature vector includes execution type, resource requirements, execution time, and priority. Defining dependency relationships between instruction nodes through an adjacency matrix, wherein the dependency relationships include timing dependency, concurrency dependency, and resource conflict; Step S2: Optimize the instruction coordination network, use the graph convolution layer to iteratively update the feature vector of the instruction node, aggregate neighbor node information, and optimize the coordinated execution relationship between instructions; Step S3: Generate an instruction cluster. According to the optimized instruction coordination network, the subtask objectives are converted into specific execution instructions in combination with the semantic mapping function to generate a coordinated instruction cluster. Step S4: Dynamically schedule instruction clusters. Based on the reinforcement learning framework, define the state, action, and reward mechanism. Use the Deep Q Network (DQN) to adjust the instruction execution order in real time to maximize resource utilization. Step S5: Fault-tolerant processing, real-time monitoring of device status and instruction execution anomalies, triggering dynamic rescheduling, and optimizing the fault diagnosis model through feedback mechanism to ensure task continuity.

2. The method for generating an instruction cluster based on an instruction coordination network according to claim 1, wherein: The characteristic vector of the instruction node is expressed by the following formula: in, Indicates the instruction type, Indicates the resources required by the instruction, Indicates the execution time of the instruction, Indicates the priority of the instruction. Indicates the execution duration of the instruction.

3. The method for generating an instruction cluster based on an instruction coordination network according to claim 1, wherein: The node feature update formula of the graph convolution layer is: in, is the feature vector of node i in the kth layer, N(i) represents the neighbor set of node i, is the normalized coefficient in the adjacency matrix, is the weight matrix of the kth layer, is the bias term and σ is the activation function.

4. The method for generating an instruction cluster based on an instruction coordination network according to claim 1, wherein: The reward mechanism of the reinforcement learning framework is defined by the following formula: in, is the maximum reward value, γ is the discount factor, and E represents the importance of future rewards. Is in state t Take action rewards.

5. The method for generating an instruction cluster based on an instruction coordination network according to claim 1, wherein: The fault diagnosis model evaluates the instruction fault score using the following formula: in, represents the fault score of instruction I, is the i-th feature of the device performance, is the weight of the corresponding feature.

6. The method for generating an instruction cluster based on an instruction coordination network according to claim 1, wherein: The semantic mapping function is a mapping protocol based on predefined rules and task constraints, which converts subtask objectives into executable instruction sequences.

7. The method for generating an instruction cluster based on an instruction coordination network according to claim 1, wherein: In the deep Q network, the Q value update formula is as follows: Among them, α is the learning rate, S t is the current state, a t is the current action; S t+1 is the next state, a t+1 is the next action, and the goal of the Q value update is to gradually approach the optimal scheduling strategy through learning and experimentation.

8. An instruction cluster generation system based on an instruction coordination network, characterized in that: include: Instruction coordination network building module: used to decompose a task into multiple subtasks and map each subtask to an instruction node; Model the feature vectors of instruction nodes through graph neural networks (GNNs), and define the dependencies between instruction nodes through adjacency matrices; Instruction collaborative optimization module: uses the graph convolution layer to iteratively update the feature vectors of instruction nodes to optimize the collaborative execution relationship between instructions; Instruction cluster generation module: Generates collaborative instruction clusters based on the optimized instruction coordination network and the semantic mapping function; Dynamic Scheduling Module: Based on the reinforcement learning framework and Deep Q Network (DQN), it adjusts the instruction execution order in real time and maximizes resource utilization; Fault-tolerant processing module: monitors device status and instruction execution anomalies in real time, triggers dynamic rescheduling, and optimizes fault diagnosis models through feedback mechanisms; Storage module: used to store instruction coordination network structure, historical scheduling data and fault diagnosis model; Interactive device: provides a friendly interactive interface and supports command generation and interaction with users.

9. The instruction cluster generation system based on the instruction coordination network according to claim 8, characterized in that: The dynamic scheduling module includes: Policy update unit: adjusts the instruction execution order according to the Q value output by the deep Q network; Reward calculation unit: Calculates instant rewards based on resource utilization, execution time, and task completion rate.

10. The instruction cluster generation system based on the instruction coordination network according to claim 8, characterized in that: The fault-tolerant processing module includes: Fault detection unit: evaluates instruction fault scores through real-time performance indicators; Dynamic rescheduling unit: generates alternative scheduling plans based on historical execution data when a failure is detected; Feedback optimization unit: updates the feature weights in the fault diagnosis model according to the fault processing results.

Images