A load balancing scheduling method and system for heterogeneous supercomputing platforms

By obtaining the load situation and implicit representation of the scheduling strategy of the heterogeneous supercomputing platform, the load balancing scheduling agent determines the policy matching degree and performs distributed adjustment, the problem of tuning agents in heterogeneous environments is solved, and the problem of tuning agents in heterogeneous environments is improved. Load balancing effects and system performance.

CN118733285BActive Publication Date: 2024-11-26CHENGDU SUPERCOMPUTING CENT OPERATION MANAGEMENT CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202411230949.0
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Filing Date
2024-09-04
Publication Date
2024-11-26
Estimated Expiration
2044-09-04

AI Technical Summary

Technical Problem

Existing agents are difficult to flexibly adapt to different workloads and computing environments in heterogeneous supercomputing platforms. The tuning process is complex and time-consuming, or the performance and adaptability are limited, making it difficult to achieve efficient load balancing.

Method used

By obtaining the implicit representation of load situation of heterogeneous supercomputing platforms and the implicit representation of the policy of scheduling policies, the load balancing scheduling agent is used to determine the policy matching degree, select the target scheduling strategy that is suitable for the current load environment, and adopt a distributed scheduling method Adjustment is performed according to the characteristics of the agent, including architecture distribution adjustment and sample distribution adjustment.

Benefits of technology

It has achieved the adjustment requirements of complex and simple agents, improved the load balancing effect and system performance, and ensured the elastic extension ability in different agents and environments.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118733285B_ABST
    Figure CN118733285B_ABST
Patent Text Reader

Abstract

The present application provides a load balancing scheduling method and system for a heterogeneous supercomputing platform. According to the classification of load balancing scheduling agents, the load balancing scheduling agents of agent type Net1 are calibrated based on architecture distribution calibration, and the load balancing scheduling agents of agent type Net2 are calibrated based on sample distribution calibration. This method can not only adapt to the calibration needs of complex agents with high requirements, but also adapt to the calibration needs of simple agents with low requirements, so as to adapt to the flexible extension capabilities of different agents in terms of calibration capabilities.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present application relates to the field of data processing, and more specifically, to a method and system for load balancing and scheduling of a heterogeneous supercomputing platform. Background Art

[0002] With the development of high-performance computing and big data processing technologies, heterogeneous supercomputing platforms have been widely used in scientific research, engineering simulation, artificial intelligence and other fields due to their powerful computing power and flexibility. However, how to effectively manage the computing resources on these platforms and achieve efficient task scheduling and load balancing remains a challenge. Traditional load balancing methods often rely on fixed rules and strategies, which are difficult to adapt to the ever-changing workloads and computing environments. In recent years, with the advancement of machine learning and artificial intelligence technologies, the concept of agents has been introduced into the field of load balancing. Agents can make decisions autonomously and dynamically adjust task allocation strategies according to the current system status, thereby improving resource utilization and task processing efficiency. However, existing agents still have some limitations in practical applications, especially in heterogeneous environments. The tuning and optimization of agents often require special design and adjustment to adapt to different workloads and computing environments. On the one hand, for complex agents, they usually have a large number of parameters and complex architectures, which makes the tuning process very complicated and time-consuming. On the other hand, although simple agents are easy to deploy and use, their performance and adaptability may be limited. Therefore, developing a tuning method that can flexibly adapt to the characteristics and needs of different intelligent agents to improve the load balancing effect and the overall performance of the system has become an important direction of current research. Summary of the invention

[0003] The purpose of the present invention is to provide a method and system for load balancing scheduling of a heterogeneous supercomputing platform.

[0004] The embodiment of the present application is implemented as follows:

[0005] In a first aspect, the present application provides a method for load balancing scheduling of a heterogeneous supercomputing platform, the method comprising: obtaining an implicit representation of the load condition of a target heterogeneous supercomputing platform and an implicit representation of the policies of multiple scheduling policies; determining the policy matching degree of each scheduling policy based on the implicit representation of the load condition of the target heterogeneous supercomputing platform and the implicit representation of the policies of each scheduling policy according to a load balancing scheduling intelligent agent; determining a target scheduling policy that is adapted to the current load environment of the target heterogeneous supercomputing platform from multiple scheduling policies based on the policy matching degree of each scheduling policy; and executing the target scheduling policy for load balancing scheduling. Among them, the calibration process of the load balancing scheduling agent includes the following steps: obtaining the agent characteristics of the initialized load balancing scheduling agent; identifying the agent type of the load balancing scheduling agent based on the agent characteristics; if the load balancing scheduling agent corresponds to the agent type Net1, calibrating the load balancing scheduling agent based on the first distributed calibration method, and the first distributed calibration method represents the fusion calibration method of the architecture distribution calibration and the sample distribution calibration; if the load balancing scheduling agent corresponds to the agent type Net2, calibrating the load balancing scheduling agent based on the second distributed calibration method, and the second distributed calibration method represents the calibration method of the sample distribution calibration; among them, the architecture distribution calibration represents the mechanism of dividing the components of the load balancing scheduling agent into multiple computing units for calibration, and the sample distribution calibration represents the mechanism of distributing the knowledge template of the load balancing scheduling agent to multiple computing units for calibration; if the load balancing scheduling agent is a high-load environment scheduling agent, calibrating the load balancing scheduling agent based on the first distributed calibration method; if the load balancing scheduling agent is a low-load environment scheduling agent, calibrating the load balancing scheduling agent based on the second distributed calibration method.

[0006] In a second aspect, the present application provides a computer system comprising: one or more processors; a memory; and one or more computer programs; wherein the one or more computer programs are stored in the memory and configured to be executed by the one or more processors, and when the one or more computer programs are executed by the processors, the above method is implemented.

[0007] The beneficial effects of the present application include at least: the load balancing scheduling method and system for heterogeneous supercomputing platforms provided by the present application, based on the classification of load balancing scheduling agents, the load balancing scheduling agents of agent type Net1 are calibrated based on architecture distribution calibration, and the load balancing scheduling agents of agent type Net2 are calibrated based on sample distribution calibration. It can not only adapt to the calibration needs of complex agents with high requirements, but also adapt to the calibration needs of simple agents with low requirements, so as to adapt to the flexible extension capabilities of different agents in calibration capabilities. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] Figure 1It is a flow chart of a load balancing scheduling method for a heterogeneous supercomputing platform provided in an embodiment of the present application.

[0009] Figure 2 It is a schematic diagram of the composition of a computer system provided in an embodiment of the present application. DETAILED DESCRIPTION

[0010] The execution subject of the load balancing scheduling method for a heterogeneous supercomputing platform provided in the embodiment of the present application is a computer system in the heterogeneous supercomputing platform, such as Figure 1 As shown, the method comprises the following steps:

[0011] Step S100: Obtain an implicit representation of the load condition of the target heterogeneous supercomputing platform and an implicit representation of the policies of multiple scheduling policies.

[0012] In step S100, the computer system aims to obtain an implicit representation of the load of the target heterogeneous supercomputing platform and an implicit representation of the policies of multiple scheduling policies. Assume a specific heterogeneous supercomputing platform, which contains different types of computing resources, such as CPU, GPU, and dedicated accelerators. These resources jointly undertake various computing tasks, and the goal of the computer system is to ensure that these tasks can run efficiently on the platform to avoid overload or waste of resources.

[0013] The computer system first determines the load of the current platform and collects data about the usage of various computing resources. For example, the computer system can monitor the CPU utilization, memory utilization, disk I / O rate, and network bandwidth utilization of each computing node. These data can be used to construct an implicit representation of the load situation. The implicit representation mentioned here is actually a simplified or abstract representation form that facilitates subsequent processing and analysis. For example, the computer system can represent the load situation of each computing node as a vector that contains the values ​​of the above indicators. An exemplary implicit representation of the load situation may be as follows: implicit representation vector of load situation = [CPU utilization, memory utilization, disk I / O rate, network bandwidth utilization]. For example, the implicit representation of the load situation of a computing node may be [75%, 60%, 20MB / s, 50Mbps].

[0014] Next, obtain the implicit policy representations of multiple scheduling policies. Scheduling policies refer to the specific rules for how to allocate tasks to computing resources on the platform. These policies can be very diverse, ranging from simple First-Come, First-Served (FCFS) to complex prediction-based task allocation. Each scheduling policy needs to be converted into a form that the computer system can understand, namely, the implicit policy representation. For example, suppose there are two scheduling policies, one is to allocate tasks based on the principle of the longest idle time of computing resources, and the other is to determine task allocation based on the performance indicators of computing resources. The implicit representations of these two policies can be as follows: policy implicit representation vector = [scheduling principle, priority allocation, task type preference]; the implicit representation of the policy based on the longest idle time may be ["longest idle time", "decrease in priority", "no preference"]. The implicit representation of the policy based on performance indicators may be ["performance first", "increase in priority", "preference for computing-intensive tasks"].

[0015] It is worth noting that these implicit representation vectors of strategies do not directly contain numerical values, but express the characteristics of the strategies through some labels. In practical applications, these labels may be further converted into numerical values ​​for the convenience of intelligent agents to process. For example, "longest idle time" can be converted into a weight coefficient to quantify the importance of this principle in the decision-making process. In this way, the computer system can comprehensively consider the load conditions of the platform and the available scheduling strategies, and then determine the most appropriate scheduling strategy to cope with the current load environment. This step lays a solid foundation for subsequent load balancing scheduling.

[0016] Step S200: Determine the policy matching degree of each scheduling policy based on the implicit representation of the load condition of the target heterogeneous supercomputing platform and the implicit representation of each scheduling policy by the load balancing scheduling agent.

[0017] In step S200, the computer system determines the policy matching degree of each scheduling strategy based on the implicit representation of the load situation of the target heterogeneous supercomputing platform and the implicit representation of the policy of each scheduling strategy. This process aims to evaluate the degree of fit of each scheduling strategy with the current platform load environment, so as to provide a basis for the subsequent selection of the best scheduling strategy. The computer system determines the matching degree of each scheduling strategy with the current platform load environment, which can be completed by a certain scoring mechanism or calculation model. Specifically, the computer system can use a load balancing scheduling agent, which is an AI model, such as a support vector machine (SVM) or a neural network, to evaluate the matching degree of each scheduling strategy. Assuming that a simple linear regression model is used for evaluation, the model can be defined as: .

[0018] Among them, w1~w4 are weight coefficients, which can be pre-set based on historical data and experience, or obtained through the training process. For example, assuming w1=0.4, w2=0.3, w3=0.15, w4=0.15, then for the computing node load in the above example, the implicit representation is [75%, 60%, 20MB / s, 50Mbps], the matching degree can be calculated as follows: This means that based on the agent, the match between the load of the computing node and the scheduling strategy is 0.585. The computer system performs similar calculations for each scheduling strategy, thereby obtaining a series of matching values. These matching values ​​will be used in the next step to select the scheduling strategy that best suits the current platform load environment.

[0019] Let's take another scenario. Assume that the target heterogeneous supercomputing platform is composed of multiple types of computing nodes, including high-performance CPU nodes, GPU acceleration nodes, and FPGA dedicated processing nodes. Currently, the platform is facing a large-scale data processing task, and it is necessary to reasonably allocate computing resources to ensure efficient completion of the task. The computer system has obtained the implicit representation of the platform's load (such as feature vectors such as CPU usage and memory occupancy) and the implicit representation of multiple scheduling strategies through step S100.

[0020] As in the previous example, a load balancing scheduling agent can be a component that integrates a machine learning algorithm (such as a neural network) that can automatically learn and predict the performance of different scheduling strategies under a specific load based on the input load implicit representation and scheduling strategy implicit representation. This agent may be a trained model that can handle complex nonlinear relationships and quickly give a matching score for the scheduling strategy and the current load environment.

[0021] The computer system first passes the implicit representation of the load situation (such as the feature vector) and the implicit representation of the scheduling strategy obtained in step S100 as input to the load balancing scheduling agent. For example, the load situation feature vector may be as follows [0.75, 0.5, 200 MB / s, 0.8 Gbps]. It contains the quantized values ​​of CPU usage, memory occupancy, disk I / O rate, and network bandwidth usage.

[0022] After receiving the input, the load balancing scheduling agent processes the input using an internally integrated machine learning model (such as a deep neural network). The model may contain multiple hidden layers to extract deep features of the input data and predict the performance of different scheduling strategies under the current load through nonlinear transformations. The model outputs a score for the matching degree between each scheduling strategy and the current load environment. This score can be a value between 0 and 1, indicating the degree of matching. The higher the score, the more likely the scheduling strategy is to bring good system performance under the current load environment. For example, for three scheduling strategies (round robin, least connection scheduling, weight-based scheduling), the model may output the following matching scores: [0.6, 0.85, 0.9]. This shows that under the current load environment, the weight-based scheduling strategy has the highest matching degree with the platform load.

[0023] Assume that some form of loss function is used internally by the model to optimize the accuracy of the fit score. For example, the model may be trained by minimizing the difference between the predicted performance and the actual performance (i.e., the prediction error). One possible form of the loss function is the mean squared error (MSE). In practice, indirect metrics (such as task completion time, resource utilization, etc.) can be used to approximate the performance for training.

[0024] It can be understood that the basic model architecture, specific structural design, sample selection and setting, training process, loss function selection, etc. adopted by the load balancing scheduling agent are not limited and can be any feasible AI model. The focus of this application is on the targeted adjustment for different types of agents, so no further details will be given here.

[0025] Step S300: Based on the policy matching degree of each scheduling policy, determine a target scheduling policy that is adapted to the current load environment of the target heterogeneous supercomputing platform from among multiple scheduling policies.

[0026] In step S300, the computer system determines the target scheduling strategy that adapts to the current load environment of the target heterogeneous supercomputing platform from multiple scheduling strategies based on the strategy matching degree of each scheduling strategy. This process is one of the key links of the load balancing scheduling method, and its purpose is to select the scheduling strategy that best suits the current load environment to ensure the effective use of platform resources.

[0027] For example, a specific heterogeneous supercomputing platform includes different types of computing resources, such as CPU, GPU, and dedicated accelerators. These resources jointly undertake various computing tasks, and the goal of the computer system is to ensure that these tasks can run efficiently on the platform to avoid overload or waste of resources. The computer system has obtained the policy matching degree of each scheduling strategy through step S200. These matching degrees represent the degree of fit between each scheduling strategy and the current platform load environment. In order to determine the final target scheduling strategy, the computer system compares the matching degrees of all scheduling strategies and selects the highest one as the target scheduling strategy.

[0028] Step S400: Execute the target scheduling strategy to perform load balancing scheduling.

[0029] In step S400, the computer system executes the selected target scheduling strategy to perform load balancing scheduling. This process is the actual operation stage of the load balancing scheduling method, and its goal is to allocate computing tasks on the target heterogeneous supercomputing platform according to the selected scheduling strategy to achieve the optimal load balancing state. Continuing with the previous example of a heterogeneous supercomputing platform. The platform contains different types of computing resources, such as CPU, GPU, and dedicated accelerators. These resources jointly undertake various computing tasks, and the goal of the computer system is to ensure that these tasks can run efficiently on the platform to avoid overload or waste of resources.

[0030] For example, suppose there are four computing nodes on the current platform and their load conditions are as follows:

[0031] Compute node 1: CPU utilization = 70%, GPU utilization = 40%, memory utilization = 55%;

[0032] Compute node 2: CPU utilization = 60%, GPU utilization = 60%, memory utilization = 45%;

[0033] Compute node 3: CPU utilization = 80%, GPU utilization = 30%, memory utilization = 60%;

[0034] Compute node 4: CPU utilization = 50%, GPU utilization = 70%, memory utilization = 40%;

[0035] Considering the rules of scheduling strategy A, the computer system will first look for nodes with lower CPU utilization, and then assign tasks in descending order of task priority. Assume that the current list of tasks to be assigned is as follows:

[0036] Task 1: Computation-intensive task, priority = 3;

[0037] Task 2: Data-intensive task, priority = 2;

[0038] Task 3: Computation-intensive task, priority = 1;

[0039] According to scheduling policy A, the computer system will first consider task 3 (highest priority) because it is a compute-intensive task and has the highest priority. Next, the computer system will find the node with the lowest CPU utilization, namely compute node 4 (CPU utilization = 50%), and assign task 3 to it. Next, the computer system will consider the next higher priority task, namely task 1 (priority = 3). Since task 1 is also a compute-intensive task, the computer system will again look for a node with lower CPU utilization. In the current case, compute node 2 (CPU utilization = 60%) would be the next best choice, so task 1 would be assigned to compute node 2. Finally, considering that task 2 is a data-intensive task and has a lower priority, the computer system may assign it to compute node 3 (CPU utilization = 80%, GPU utilization = 30%), which has higher CPU utilization but lower GPU utilization. In this way, the computer system implements the target scheduling policy A and achieves a reasonable distribution of load. This process ensures efficient utilization of platform resources and helps avoid the problem of overloading any single resource. As tasks are continuously executed and new tasks are added, the computer system will continue to monitor the load of the platform and make dynamic adjustments based on the target scheduling strategy to maintain a good load balance state.

[0040] In the embodiment of the present application, the calibration process of the load balancing scheduling agent includes the following steps:

[0041] Step S10: Obtain the agent characteristics of the initialized load balancing scheduling agent.

[0042] In step S10, the computer system obtains the agent characteristics of the initialized load balancing scheduling agent. These characteristics can help the computer system better understand the basic properties of the agent, so as to select the appropriate tuning method to improve the performance of the agent. The agent characteristics may include the neural network structure of the agent, such as the number of parameters, or the application environment of the agent, such as load balancing scheduling in a high load or low load environment. The computer system obtains the agent characteristics of the initialized load balancing scheduling agent. Assume that the computer system is processing a load balancing scheduling agent that uses a deep neural network as a core component. The agent characteristics may include the following aspects: Neural network structure: the number of layers of the neural network, the number of neurons in each layer, the activation function used, etc. Number of parameters: the total number of parameters of the neural network in the agent, which will be adjusted during the training process to optimize the performance of the agent. Application environment: whether the agent is designed for a high load environment or a low load environment. A high load environment may mean that a large number of concurrent tasks need to be processed, while a low load environment may only need to process a small number of tasks.

[0043] Assume that the neural network structure of the agent is as follows:

[0044] Input layer: Contains 3 neurons that receive information about the load of computing resources, such as CPU utilization, memory usage, and disk I / O rate.

[0045] Hidden layer: contains 2 layers, each with 10 neurons, using ReLU as the activation function.

[0046] Output layer: contains 1 neuron, which is used to output the selection probability of the scheduling strategy.

[0047] Assume that the number of parameters of the neural network is as follows:

[0048] The weight matrix from the input layer to the hidden layer 1: 3×10=303×10=30 weight parameters.

[0049] Bias vector for hidden layer 1: 10 bias parameters.

[0050] The weight matrix from hidden layer 1 to hidden layer 2: 10×10=10010×10=100 weight parameters.

[0051] Bias vector for hidden layer 2: 10 bias parameters.

[0052] The weight matrix from hidden layer 2 to output layer: 10×1=1010×1=10 weight parameters.

[0053] Bias vector of the output layer: 1 bias parameter.

[0054] Then, the total number of parameter variables of this neural network is 151.

[0055] Assume that the agent is mainly used for load balancing scheduling in a high-load environment. This means that the agent needs to handle a large number of concurrent tasks and needs to respond quickly to changing load conditions.

[0056] The computer system obtains the neural network structure and the number of parameters of the agent to determine the complexity of the agent. For example, if the number of parameters is large (such as more than 1,000), this may mean that the agent is more complex and suitable for handling high-load environments. If the number of parameters is small (such as less than 100), it may mean that the agent is simpler and more suitable for handling low-load environments. In addition, the computer system also considers the application environment of the agent. If the agent is designed for a high-load environment, the computer system will select the first distributed tuning method (including architecture distribution tuning and sample distribution tuning) to tune the agent. If the agent is designed for a low-load environment, the computer system will select the second distributed tuning method (mainly sample distribution tuning). For example, taking the agent mentioned above as an example, since the number of parameters is 151, which is relatively small, this indicates that the agent may be more suitable as a load balancing scheduling agent in a low-load environment. Therefore, the computer system will select the second distributed tuning method to tune the agent, focusing mainly on sample distribution tuning, that is, the parameters of the agent will be trained on different computing units, and the training data will be distributed among these computing units. In this way, the computer system can ensure that the agent can be effectively tuned according to its characteristics and thus better adapt to the specific load environment.

[0057] Step S20: Identify the agent type of the load balancing scheduling agent based on the agent characteristics.

[0058] In step S20, the computer system identifies the agent type of the load balancing scheduling agent based on the agent characteristics. This process is intended to determine which category the agent belongs to based on the agent characteristics, and then determine the best way to adjust it later. The agent characteristics may include the neural network structure of the agent (such as the number of parameters) or the application environment of the agent (such as load balancing scheduling in a high load or low load environment). Based on these characteristics, the agent can be divided into different categories, such as agent type Net1 or agent type Net2. Assume that the agent is mainly used for load balancing scheduling in a high load environment. This means that the agent needs to handle a large number of concurrent tasks and needs to respond quickly to changing load conditions.

[0059] The computer system determines the type of agent based on the number of parameters of the agent or the application environment. For example: if the number of parameters is large (such as more than 1000), this may mean that the agent is more complex and suitable for handling high-load environments. In this case, the computer system classifies the agent as agent type Net1. If the number of parameters is small (such as less than 100), it may mean that the agent is simpler and more suitable for handling low-load environments. In this case, the computer system classifies the agent as agent type Net2. For example, if the number of parameters is 151, which is between 100 and 1000, the computer system may determine whether to classify it as agent type Net1 or Net2 based on a set threshold (such as a third reference number). Assuming the third reference number is set to 500 parameters, the agent will be classified as agent type Net1 because its number of parameters exceeds 500.

[0060] Taking into account the above-mentioned agent characteristics, the computer system will identify the agent type of the load balancing scheduling agent based on the agent characteristics. For example: if the number of parameters of the agent is 161, the computer system identifies the agent as agent type Net1, which means that the agent needs to handle tasks in a high-load environment. If the number of parameters of the agent is 50, the computer system identifies the agent as agent type Net2, which means that the agent is mainly used for tasks in a low-load environment. In this way, the computer system can ensure that the agent is correctly classified, so as to select the appropriate method for the subsequent calibration process.

[0061] Step S30: If the load balancing scheduling agent corresponds to the agent type Net1, the load balancing scheduling agent is calibrated based on a first distributed calibration method, where the first distributed calibration method represents a fusion calibration method of architecture distribution calibration and sample distribution calibration.

[0062] In step S30, if the computer system determines that the load balancing scheduling agent belongs to agent type Net1, the agent will be tuned based on the first distributed tuning method. The first distributed tuning method combines architecture distribution tuning and sample distribution tuning to meet the needs of high-load environments. This process improves the efficiency and performance of tuning by distributing the components and training data of the agent to multiple computing units.

[0063] Architecture distributed tuning means splitting the components of the agent across multiple computing units for tuning. This can significantly reduce the computational burden on a single computing unit and allow for parallel processing. For example, suppose the agent's neural network contains an input layer, two hidden layers, and an output layer. The computer system can split these components across different computing units for tuning.

[0064] The first component: includes the input layer and the first hidden layer. The second component: includes the second hidden layer and the output layer. Assume that the first component needs to process A knowledge templates, each of which has corresponding features (such as CPU utilization, memory utilization, etc.), which can be represented as feature vectors. For example, for a knowledge template, its feature vector may be [75%, 60%, 20MB / s, 50Mbps], which respectively represent CPU utilization, memory utilization, disk I / O rate, and network bandwidth utilization.

[0065] Sample distribution calibration refers to distributing the training data set (i.e., knowledge templates) on different computing units for processing. This helps reduce the cost of data transmission and allows parallel processing of data. Assume that A knowledge templates are divided into a subsets, each of which contains several knowledge templates.

[0066] First component: The processed knowledge template set includes the first 1 / 3 of the A knowledge templates.

[0067] Second component: The processed knowledge template set includes the last 2 / 3 of the A knowledge templates.

[0068] The computer system first divides the first component into a subcomponents, and shares the agent parameters of these subcomponents to a computing units. For example, if the first component contains 100 parameters, these parameters can be divided into 10 subsets, each subset contains 10 parameters, and then assigned to 10 computing units. Next, each computing unit processes the set of knowledge templates assigned to it. For example, the e-th computing unit processes the e-th subset of A knowledge templates. Each computing unit generates a corresponding sub-implicit representation based on the processed knowledge template. These sub-implicit representations will eventually be merged into a complete first result implicit representation.

[0069] Assume that the first component needs to process 100 knowledge templates, which are divided into 10 subsets, each of which contains 10 knowledge templates. The computer system divides the first component into 10 subcomponents, each of which processes a subset of knowledge templates.

[0070] Computation unit 1: processes the knowledge template of the first subset and generates the first sub-implicit representation.

[0071] Computation unit 2: processes the knowledge template of the second subset and generates the second implicit representation.

[0072] …

[0073] Computation unit 10: processes the knowledge template of the 10th subset and generates the 10th implicit representation.

[0074] These sub-implicit representations will eventually be merged into the first result implicit representation.

[0075] For the second component, the computer system shares the agent parameter variables to b computing units and divides the A knowledge templates into b template sets, each template set containing one or more knowledge templates. For example, if the second component needs to process 100 knowledge templates, these knowledge templates are divided into 10 template sets, each set containing 10 knowledge templates.

[0076] The first computing unit: processes the knowledge templates in the first template set, and generates a second result implicit representation of the first template set.

[0077] The second computing unit: processes the knowledge templates in the second template set, and generates a second result implicit representation of the second template set.

[0078] …

[0079] The 10th computing unit: processes the knowledge templates in the 10th template set, and generates a second result implicit representation of the 10th template set.

[0080] These second result implicit representations will eventually be merged into a complete second result implicit representation.

[0081] After processing all the knowledge templates, the computer optimizes the agent parameters of each computing unit based on the implicit representation of the second result. For example, assume that the fth computing unit updates its agent parameters based on the implicit representation of the second result of the set of knowledge templates it processes. These updated parameters are then shared among all computing units to ensure consistency and accuracy across the agent. In this way, multiple computing units can be effectively utilized to calibrate the load balancing scheduling agent, especially when dealing with high-load environments. This distributed calibration method not only improves the speed of calibration, but also ensures that the agent can better adapt to complex load environments.

[0082] Step S40: If the load balancing scheduling agent corresponds to the agent type Net2, the load balancing scheduling agent is calibrated based on the second distributed calibration method, and the second distributed calibration method represents a calibration method of sample distribution calibration. Among them, the architecture distribution calibration represents a mechanism for dividing the components of the load balancing scheduling agent into multiple computing units for calibration, and the sample distribution calibration represents a mechanism for distributing the knowledge template of the load balancing scheduling agent to multiple computing units for calibration; if the load balancing scheduling agent is a high-load environment scheduling agent, the load balancing scheduling agent is calibrated based on the first distributed calibration method; if the load balancing scheduling agent is a low-load environment scheduling agent, the load balancing scheduling agent is calibrated based on the second distributed calibration method.

[0083] In step S40, if the computer system determines that the load balancing scheduling agent belongs to agent type Net2, the agent will be calibrated based on the second distributed calibration method. This calibration method mainly focuses on sample distribution calibration, that is, distributing the knowledge templates used for training to multiple computing units for processing. This process is intended to improve training efficiency, especially in low-load environments, because the agent structure is relatively simple and has fewer parameters, so complex and large-scale architecture distribution calibration is not required as in high-load environments.

[0084] Sample distribution calibration means distributing knowledge templates to different computing units for processing. For example, suppose there is a training data set consisting of 1,000 knowledge templates, each of which contains information about the execution of a task, such as task type, required resources, execution time, etc. To simplify the description, these features are represented as feature vectors. For example, a knowledge template may contain a feature vector [task_type, required_resources, execution_time], where task_type may be an integer encoding, and required_resources and execution_time are specific values. The computer system will divide these 1,000 knowledge templates into several subsets according to certain rules, and assign these subsets to different computing units for processing. For example, 1,000 knowledge templates can be divided into 10 subsets, each containing 100 knowledge templates. Each computing unit is responsible for processing the knowledge template subset assigned to it.

[0085] During the implementation of the second distributed calibration method, the computer system divides the entire knowledge template set into multiple subsets and sends these subsets to different computing units for processing. For example, if there are 1,000 knowledge templates in total, they can be divided into 10 subsets, each containing 100 knowledge templates. Assuming there are 10 computing units in the computer system, each computing unit will process a subset of knowledge templates.

[0086] The first computing unit: processes the knowledge template of the first subset.

[0087] The second computing unit: processes the knowledge template of the second subset.

[0088] …

[0089] The 10th computing unit: processes the knowledge template of the 10th subset.

[0090] Each computing unit processes its assigned subset of knowledge templates and updates the agent's parameters based on these knowledge templates. For example, the first computing unit may process a subset of 100 knowledge templates that contain instances of various task types, as well as the resource requirements and execution times associated with the tasks. By processing these knowledge templates, the first computing unit updates the agent parameters to learn how to better schedule tasks. Assume that the load balancing scheduling agent is a simple neural network with an input layer, a hidden layer, and an output layer. The input layer receives feature vectors from the knowledge templates, and the output layer produces scheduling decisions. Assume that the hidden layer has 100 nodes, each representing an agent parameter. Each computing unit will update these parameters based on the subset of knowledge templates it processes.

[0091] When all computing units have completed their respective processing, they aggregate the updated parameters to a central location. For example, the first computing unit may have updated the parameters w1, w2, ..., w100. These updated parameters are then shared among all computing units to ensure consistency and accuracy across the agent. During training, each computing unit calculates a loss function to evaluate the effectiveness of the agent's parameter updates. Assume that the loss function used is the mean squared error (MSE), which measures the difference between the predicted value and the actual value. In this way, the computer system can effectively utilize multiple computing units to tune the load balancing scheduling agent, especially when dealing with low-load environments. This distributed tuning method not only improves training speed, but also ensures that the agent can accurately learn how to make optimal scheduling decisions in different situations.

[0092] As an implementation method, the load balancing scheduling agent includes a first component obtained based on architecture distribution calibration, and a second component obtained based on sample distribution calibration; wherein the execution information of the first component includes the first loading implicit representation corresponding to each of the A knowledge templates, and the output of the first component includes the first result implicit representation corresponding to each of the A knowledge templates, and the execution information of the second component includes the second loading implicit representation corresponding to each of the A knowledge templates, and the output of the second component includes the second result implicit representation corresponding to each of the A knowledge templates, and A≥2. Based on this, step S30, based on the first distributed calibration method, calibrates the load balancing scheduling agent, which may specifically include:

[0093] Step S31: For the first component, divide the first component into a sub-components, and share the intelligent agent parameter variables of the a sub-components to a computing units, the e-th computing unit among the a computing units stores the intelligent agent parameter variables of the e-th sub-component among the a sub-components, a≥2, 1≤e≤a.

[0094] In step S31, the computer system divides the first component into a subcomponents and shares the agent parameters of these subcomponents to a computing units. Each computing unit saves the agent parameters of one of the subcomponents. Assume that the computer system is managing a heterogeneous supercomputing platform that needs to handle a large number of scientific computing tasks. In order to optimize the scheduling of these tasks, the computer system uses a load balancing scheduling agent, which is composed of multiple components. In this example, the focus is on the first component, which is responsible for processing task-related knowledge templates, which contain task attributes such as required resources, estimated execution time, and priority. Assume that the first component contains a set of machine learning models that are used to predict the best scheduling strategy for different types of computing tasks. In order to increase the speed of training and prediction, the computer system decides to divide the first component into multiple subcomponents and deploy each subcomponent on a different computing unit. Assume that a is set to 10, which means that the first component is divided into 10 subcomponents, each of which focuses on processing different types of tasks. For example, the first subcomponent may be responsible for processing knowledge templates for CPU-intensive tasks, while the second subcomponent may process knowledge templates for GPU-intensive tasks. Each subcomponent has its own specific agent parameters that define the behavior of the model, such as learning rate, weight matrix, etc. The computer system shares the agent parameters of these 10 subcomponents to 10 computing units. In this way, the first computing unit saves the parameters of the first subcomponent, the second computing unit saves the parameters of the second subcomponent, and so on, until the tenth computing unit saves the parameters of the tenth subcomponent. Specifically, assume that the knowledge template that the first subcomponent needs to process contains the following feature vectors as input: [task type, expected execution time, number of CPU cores required]. Each feature vector can be represented as an array, for example [0, 60, 4] represents a CPU-intensive task with an expected execution time of 60 seconds and requires 4 CPU cores. The learning parameters that the first subcomponent may need to adjust include learning rate (learning_rate), weight matrix (weights_matrix), etc. Assume that the learning rate is 0.01 and the weight matrix is ​​a two-dimensional array [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]].

[0095] The computer system ensures that each computing unit only stores and processes the agent parameters related to the subcomponent assigned to it. This design enables the computer system to process tasks in parallel across multiple computing units, thereby improving the overall performance of the load-balanced scheduling agent.

[0096] For example, in the above example, the first computing unit only saves the parameters of the first subcomponent, that is, the learning rate is 0.01, and the weight matrix is ​​[[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]]. This design allows the first computing unit to independently process the knowledge template associated with CPU-intensive tasks without being affected by the types of tasks processed by other computing units. In this way, the computer system effectively utilizes multiple computing units to accelerate the training and prediction process of the load balancing scheduling agent, thereby improving the response speed and scheduling efficiency of the overall system.

[0097] Step S32: for the e-th computing unit, the first loaded implicit representations corresponding to the A knowledge templates are processed respectively according to the e-th sub-component to obtain the e-th sub-implicit representations corresponding to the A knowledge templates, A≥2.

[0098] In step S32, the computer system processes the first loaded implicit representation corresponding to each of the A knowledge templates according to the e-th subcomponent for the e-th computing unit to obtain the e-th sub-implicit representation corresponding to each of the A knowledge templates. This process is one of the key steps in the calibration of load balancing scheduling agents, which improves the training efficiency of the agents through parallel processing.

[0099] Assume that the first component has been split into 10 subcomponents, each of which handles a specific type of computing task. The computer system shares the agent parameters of these 10 subcomponents to 10 computing units. The first computing unit is responsible for processing the first subcomponent, the second computing unit is responsible for processing the second subcomponent, and so on. The e-th computing unit will process the set of knowledge templates assigned to it. For example, the first computing unit processes the parameters of the first subcomponent and processes the first subset of A knowledge templates. For each knowledge template, the computing unit processes it based on the first loaded implicit representation (i.e., input features) to generate the e-th sub-implicit representation. Assume that the first subcomponent is responsible for processing knowledge templates associated with CPU-intensive tasks, which contain the following feature vectors as input: [task type, expected execution time, number of CPU cores required]. Each feature vector can be represented as an array, for example [0, 60, 4] represents a CPU-intensive task with an expected execution time of 60 seconds and requires 4 CPU cores.

[0100] For the first computing unit, it will process the knowledge templates related to the first subcomponent. Assume that the knowledge template set that the first computing unit needs to process contains 50 knowledge templates. Each knowledge template will be input into the machine learning model of the first subcomponent for processing.

[0101] Assume that the machine learning model of the first subcomponent is a simple neural network with an input layer, a hidden layer, and an output layer. The input layer receives feature vectors from the knowledge templates, and the output layer produces scheduling decisions. Assume that the hidden layer has 100 nodes, each representing an agent parameter. Each computing unit will update these parameters based on the subset of knowledge templates it processes.

[0102] For example, the first computational unit may have updated the parameters w1, w2, ..., w100. These updated parameters are then shared among all computational units to ensure consistency and accuracy across the entire agent.

[0103] Assume that the knowledge template processed by the first computing unit contains the following feature vector: [0, 60, 4], which represents a CPU-intensive task with an estimated execution time of 60 seconds and requires 4 CPU cores. Assume that the hidden layer has 100 nodes, each node represents an agent parameter. Each computing unit will update these parameters according to the subset of knowledge templates it processes.

[0104] Assume that the first subcomponent uses a simple linear model to process the knowledge template. The model can be expressed as: ;in, is the output of the model, x1, x2 and x3 are the feature vector elements of the knowledge template, w1, w2 and w3 are the agent parameters. For the above feature vector [0, 60, 4], assuming that the initial agent parameters are w1=0.1, w2=0.01, w3=0.05, then the output of the model is: This means that the first computation unit generates an output value of 0.8 based on the input feature vector [0, 60, 4], which is the first sub-implicit representation.

[0105] In this way, the computer system can effectively use multiple computing units to process knowledge templates, generate sub-implicit representations, and finally form a complete implicit representation. This distributed processing method improves the training efficiency of load-balanced scheduling agents, thereby improving the performance of agents on heterogeneous supercomputing platforms.

[0106] Step S33: merge the a sub-implicit representations corresponding to the A knowledge templates to obtain the first result implicit representation corresponding to the A knowledge templates.

[0107] In step S33, the computer system merges the a sub-implicit representations corresponding to each of the A knowledge templates to obtain the first result implicit representation corresponding to each of the A knowledge templates. This process is to aggregate the results of each computing unit during the training of the load balancing scheduling agent to form a higher-level representation for further processing or decision-making.

[0108] Assume that the first component has been divided into 10 subcomponents, each of which handles a specific type of computing task. The computer system shares the agent parameters of these 10 subcomponents to 10 computing units. The first computing unit is responsible for processing the first subcomponent, the second computing unit is responsible for processing the second subcomponent, and so on. In the previous step, the computer system has processed A knowledge templates, each of which was processed by multiple computing units. Each computing unit is responsible for processing a part of the knowledge template and generating a sub-implicit representation. For example, the first computing unit is responsible for processing the knowledge template related to the first subcomponent and generating the first sub-implicit representation; the second computing unit is responsible for processing the knowledge template related to the second subcomponent and generating the second sub-implicit representation, and so on. Now, the computer system needs to merge these sub-implicit representations to obtain a complete representation of each knowledge template. Assume that each knowledge template has 10 sub-implicit representations because a total of 10 computing units are involved in the processing. The computer system will merge these 10 sub-implicit representations for each knowledge template.

[0109] The merging method can be to simply stitch together the sub-implicit representations, or to use more complex fusion techniques, such as weighted averaging or other machine learning methods. For example, assuming that each sub-implicit representation is a vector of length 10, the first result implicit representation after merging will be a vector of length 100. In this way, the computer system can effectively merge the sub-implicit representations of the knowledge templates processed by each computing unit into a complete representation. This merging operation helps to retain the information processed by each sub-component and provides a more comprehensive and detailed data basis for subsequent decision-making processes. This distributed processing method improves the training efficiency and accuracy of the load balancing scheduling agent, thereby improving the performance of the agent on heterogeneous supercomputing platforms.

[0110] Step S34: For the second component, the agent parameter variables of the second component are shared to b computing units, and A knowledge templates are divided into b template sets, each template set includes one or more knowledge templates, and the f-th computing unit among the b computing units is used to process the f-th template set among the b template sets, b≥2, 1≤f≤b.

[0111] In step S34, the computer system shares the agent parameter variables of the second component to b computing units, and divides the A knowledge templates into b template sets. Each template set contains one or more knowledge templates, and each of the b computing units is responsible for processing one of the template sets. This process ensures load balancing and enables the system to efficiently utilize resources to process different types of computing tasks.

[0112] Assume that the second component has been divided into 5 subcomponents, each of which handles a specific type of computing task. The computer system shares the agent parameters of these 5 subcomponents to 5 computing units. The first computing unit is responsible for processing the first subcomponent, the second computing unit is responsible for processing the second subcomponent, and so on. The computer system needs to divide A knowledge templates into b template sets. For example, if A is equal to 100 and b is set to 5, each template set will contain 20 knowledge templates. This allocation method ensures that each computing unit can process a set of related knowledge templates, thereby improving processing efficiency.

[0113] Next, the computer system assigns these template sets to the corresponding computing units. For example, the first template set contains the 1st to 20th knowledge templates, which will be assigned to the first computing unit for processing; the second template set contains the 21st to 40th knowledge templates, which will be assigned to the second computing unit for processing; and so on, until all knowledge templates have been assigned.

[0114] The computer system also shares the agent parameter variables of the second component with each computing unit. The purpose of this is to allow each computing unit to access the necessary parameters to correctly process the knowledge template assigned to it. The agent parameter variables may include information such as model weights and hyperparameter settings. Assume that the agent parameter variables of the second component include a weight matrix W and a bias vector b of a neural network model. These parameters will be copied and sent to each computing unit. For example, the first computing unit will receive a copy of W and b and use these parameters to process the knowledge templates in the first template set.

[0115] Taking the first computing unit as an example, the computer system allocates the 1st to 20th knowledge templates to the first computing unit. At the same time, the computer system also shares the agent parameters of the second component, including the weight matrix W and the bias vector b, with the first computing unit.

[0116] Assume that the knowledge template that the first computing unit needs to process includes the following information:

[0117] The first knowledge template: [1, 200, 50] represents a task of type 1, which requires 200 computing units of resources and is expected to take 50 seconds to complete.

[0118] The second knowledge template: [2, 300, 60] represents a task of type 2, which requires 300 computing units of resources and is expected to take 60 seconds to complete.

[0119] …

[0120] The 20th knowledge template: [20, 150, 45] represents a task of type 20, which requires 150 computing units of resources and is expected to take 45 seconds to complete.

[0121] The first computing unit will use these knowledge templates and the agent parameters shared from the computer system, including the weight matrix W and the bias vector b, for processing.

[0122] In this way, the computer system can effectively distribute A knowledge templates to b computing units and ensure that each computing unit can access the necessary agent parameters. This distributed processing method not only improves the training efficiency of the load balancing scheduling agent, but also ensures the relevance and consistency of the processing tasks of each computing unit, thereby improving the performance of the entire system.

[0123] Step S35: For the fth computing unit, the second loaded implicit representation corresponding to each knowledge template in the fth template set is processed based on the second component by the fth computing unit to obtain the second result implicit representation corresponding to each knowledge template in the fth template set.

[0124] In step S35, the computer system processes the second loaded implicit representation corresponding to each knowledge template in the fth template set according to the fth computing unit based on the second component, so as to obtain the second result implicit representation corresponding to each knowledge template in the fth template set. This process ensures that each computing unit can independently process the knowledge template assigned to it and generate the corresponding implicit representation, providing a basis for subsequent merging and decision-making.

[0125] Assume that the second component has been divided into 5 subcomponents, each of which handles a specific type of computing task. The computer system shares the agent parameters of these 5 subcomponents to 5 computing units. The first computing unit is responsible for processing the first subcomponent, the second computing unit is responsible for processing the second subcomponent, and so on. The computer system has divided the 100 knowledge templates into 5 template sets, each template set contains 20 knowledge templates. For example, the first template set contains the 1st to 20th knowledge templates, which will be assigned to the first computing unit for processing; the second template set contains the 21st to 40th knowledge templates, which will be assigned to the second computing unit for processing; and so on, until all knowledge templates have been assigned.

[0126] Taking the first computing unit as an example, the computer system assigns the 1st to 20th knowledge templates to the first computing unit for processing. These knowledge templates contain the following information:

[0127] The first knowledge template: [1, 200, 50] represents a task of type 1, which requires 200 computing units of resources and is expected to take 50 seconds to complete.

[0128] The second knowledge template: [2, 300, 60] represents a task of type 2, which requires 300 computing units of resources and is expected to take 60 seconds to complete.

[0129] …

[0130] The 20th knowledge template: [20, 150, 45] represents a task of type 20, which requires 150 computing units of resources and is expected to take 45 seconds to complete.

[0131] The first computing unit will use these knowledge templates and the agent parameter variables shared from the computer system for processing.

[0132] The first computing unit processes the second loaded implicit representation corresponding to each knowledge template in the first template set based on the second component to obtain the second result implicit representation corresponding to each knowledge template in the first template set. The second loaded implicit representation here refers to the feature vector of each knowledge template.

[0133] Assume that the knowledge template that the first computing unit needs to process includes the following information:

[0134] The first knowledge template: [1, 200, 50] represents a task of type 1, which requires 200 computing units of resources and is expected to take 50 seconds to complete.

[0135] The second knowledge template: [2, 300, 60] represents a task of type 2, which requires 300 computing units of resources and is expected to take 60 seconds to complete.

[0136] …

[0137] The 20th knowledge template: [20, 150, 45] represents a task of type 20, which requires 150 computing units of resources and is expected to take 45 seconds to complete.

[0138] The first computing unit will use the feature vectors of these knowledge templates and the agent parameters shared from the computer system, including the weight matrix W and the bias vector b, to generate the second result implicit representation.

[0139] Taking the first knowledge template as an example, assume that the knowledge template that the first computing unit needs to process is [1, 200, 50]. Assume that the second component uses a simple neural network model with an input layer, a hidden layer, and an output layer. The input layer receives feature vectors from the knowledge template, and the output layer generates scheduling decisions. Assume that the hidden layer has 100 nodes, each node represents an agent parameter. Each computing unit will update these parameters according to the subset of knowledge templates it processes.

[0140] Assume that the first computation unit has updated the parameters w1, w2, ..., w100. These updated parameters are then shared among all computation units to ensure consistency and accuracy across the entire agent.

[0141] Assume that the knowledge template processed by the first computing unit contains the following feature vector: [1, 200, 50], which represents a type 1 task that requires 200 computing units of resources and is expected to take 50 seconds to complete. Assume that the hidden layer has 100 nodes, each node represents an agent parameter. Each computing unit will update these parameters according to the subset of knowledge templates it processes.

[0142] In this way, the computer system can effectively allow each computing unit to independently process the knowledge template assigned to it and generate the corresponding second result implicit representation. This distributed processing method not only improves the training efficiency of the load balancing scheduling agent, but also ensures the relevance and consistency of the processing tasks of each computing unit, thereby improving the performance of the entire system.

[0143] Step S36: merging the implicit representations of the second results corresponding to the respective knowledge templates in the b template sets to obtain the implicit representations of the second results corresponding to the A knowledge templates.

[0144] In step S36, the computer system merges the implicit representations of the second results corresponding to each knowledge template in the b template sets to obtain the implicit representations of the second results corresponding to each knowledge template in A. This process ensures that the results of the knowledge templates processed by all computing units can be integrated together to provide comprehensive information for the next decision.

[0145] The computer system merges the second result implicit representations of the knowledge templates processed by the first to fifth computing units. Each computing unit has generated a second result implicit representation based on the assigned knowledge template subset. These second result implicit representations can be feature vectors, probability distributions, or other forms of data representations obtained after processing by the computing units.

[0146] Taking the first computing unit as an example, it processes the first to 20th knowledge templates. Assume that the first computing unit has generated the following second result implicit representation:

[0147] The first knowledge template: [1, 200, 50] is processed and the second result is implicitly represented as [1.1,205, 52].

[0148] The second result of the second knowledge template: [2, 300, 60] after processing is implicitly expressed as [2.1,310, 65].

[0149] …

[0150] The second result of the 20th knowledge template: [20, 150, 45] after processing is implicitly expressed as [20.1, 155, 48].

[0151] Similarly, the 2nd to 5th computing units also processed the 21st to 40th, 41st to 60th, 61st to 80th, and 81st to 100th knowledge templates, respectively, and generated corresponding second result implicit representations.

[0152] The computer system merges the implicit representations of the second results of the knowledge templates processed by all the computing units. This means that the results of the 20 knowledge templates processed by the first computing unit, the results of the 20 knowledge templates processed by the second computing unit, and so on are all merged into a whole set for further processing. For example, the computer system merges the results of the 20 knowledge templates processed by the first computing unit with the results of the knowledge templates processed by the second to fifth computing units. After the merger, the system will obtain the implicit representations of the second results of all 100 knowledge templates.

[0153] Assume that the merged result is as follows:

[0154] The first knowledge template: [1.1, 205, 52]

[0155] The second knowledge template: [2.1, 310, 65]

[0156] …

[0157] The 100th knowledge template: [100.1, 250, 70]

[0158] In this way, the computer system can effectively merge the implicit representations of the results of the knowledge templates processed by all computing units into a unified set. This merger not only ensures that the contributions of all computing units are taken into account, but also provides comprehensive and consistent information for subsequent decision-making. Ultimately, the computer system can make more optimized scheduling decisions based on these merged implicit representations, improving the load balancing and overall performance of the heterogeneous supercomputing platform.

[0159] As an implementation method, the agent parameter variables of the first component include multiple agent parameter variables that implicitly represent the corresponding agents. Based on this, step S31, splitting the first component into a sub-components, and sharing the agent parameter variables of the a sub-components to a computing units, may specifically include:

[0160] Step S311: Processing the agent parameter variables corresponding to the multiple implicit representations to obtain the parameter solutions corresponding to the multiple implicit representations;

[0161] Step S312: performing remainder calculations on the parameter solutions corresponding to the multiple implicit representations and a respectively, to obtain the remainders corresponding to the multiple implicit representations;

[0162] Step S313: adding the intelligent agent parameter variables of the implicit representation corresponding to the same remainder to the same subcomponent to obtain the intelligent agent parameter variables of a subcomponents;

[0163] Step S314: Share the intelligent agent parameter variables of a sub-components to a computing units.

[0164] In step S31, the computer system divides the first component into a subcomponents and shares the agent parameters of these subcomponents to a computing units. This process ensures that computing tasks can be efficiently load-balanced and scheduled on a heterogeneous supercomputing platform.

[0165] Assume that the computer system is managing a heterogeneous supercomputing platform, which consists of a different computing units. Each computing unit has different computing capabilities and resources. The first component that the computer system needs to process contains n implicit representations, each of which has its corresponding agent parameter variables. These agent parameter variables include the characteristic values ​​of the task, such as the required computing resources, expected running time, and priority.

[0166] In step S311, the computer system processes the agent parameter variables corresponding to the n implicit representations to obtain parameter solutions corresponding to the implicit representations. These parameter solutions can be represented as feature values ​​(feature_value).

[0167] For example, assuming n is 100 and a is 5, the first component processed by the computer system contains 100 implicit representations. Each implicitly represented agent parameter can be represented as a feature vector. For example, the feature vector of the first implicit representation is [10, 20, 30], where 10 represents the number of CPU cores required, 20 represents the estimated running time, and 30 represents the priority.

[0168] In step S312, the computer system performs remainder calculations on the above parameter solutions and a respectively, and obtains the remainders corresponding to each implicit representation. This step is to determine to which subcomponent each implicit representation should be assigned.

[0169] For example, continuing with the previous example, the computer system will take the remainder of each element in the eigenvector of each implicit representation and a. Taking the first implicit representation as an example, its eigenvector is [10, 20, 30], then the remainders after taking the remainder of a are [0, 0, 0].

[0170] In step S313, the computer system adds the agent parameter variables corresponding to the implicit representation of the same remainder to the same subcomponent. This is done to assign tasks with similar characteristics to the same subcomponent, so that these tasks can better utilize the capabilities of specific computing units.

[0171] For example, continuing with the previous example, assuming that the remainder of the first element of all implicitly represented agent parameters is 0, then these implicit representations will be added to the first subcomponent. If the remainder of the second element is 1, the corresponding implicit representation will be added to the second subcomponent, and so on.

[0172] In step S314, the computer system shares the agent parameter variables of each subcomponent to the corresponding computing unit, so that each computing unit can process the tasks belonging to the subcomponent.

[0173] For example, if the first subcomponent contains the 1st to 20th implicit representations, then the agent parameters of these 20 implicit representations will be shared with the first computational unit. Similarly, the second subcomponent contains the 21st to 40th implicit representations, and their agent parameters are shared with the second computational unit, and so on.

[0174] Through the above steps S311 to S314, the computer system can effectively divide the first component into a subcomponents and share the agent parameters of these subcomponents to a computing units. This process not only ensures that computing tasks can be efficiently load-balanced and scheduled on heterogeneous supercomputing platforms, but also further optimizes the task allocation strategy by using machine learning models. Ultimately, the computer system can achieve better resource utilization and higher overall performance.

[0175] As another implementation of step S31, that is, dividing the first component into a sub-components, and sharing the agent parameter variables of the a sub-components to a computing units, specifically may include:

[0176] Step S31A: determining the implicit representation classification corresponding to each agent parameter variable of the first component;

[0177] Step S31B: adding the agent parameter variables belonging to the same implicit representation classification to the same subcomponent to obtain the agent parameter variables of a subcomponents;

[0178] Step S31C: Share the intelligent agent parameter variables of a sub-components to a computing units.

[0179] In the above another implementation of step S31, the computer system divides the first component into a subcomponents, and shares the agent parameters of these subcomponents to a computing units. This implementation performs the division by determining the implicit representation classification of the agent parameters, thereby achieving more effective load balancing scheduling.

[0180] In step S31A, the computer system determines the implicit representation classification corresponding to each agent parameter of the first component. This process can be completed by analyzing the properties of the agent parameters, such as task type, resource requirements, priority, etc., to determine the categories of these parameters.

[0181] For example, assuming n is 100 and a is 5, the first component processed by the computer system contains 100 implicit representations. The agent parameter variables of each implicit representation can be represented as a feature vector. For example, the feature vector of the first implicit representation is [10, 20, 30], where 10 represents the required number of CPU cores, 20 represents the estimated running time, and 30 represents the priority. The computer system can classify each implicit representation based on these feature vectors. For example, the implicit representations can be divided into three categories: high, medium, and low according to the required number of CPU cores.

[0182] In step S31B, the computer system adds agent parameter variables belonging to the same implicit representation classification to the same subcomponent. This is done to assign tasks with similar characteristics to the same subcomponent, so that these tasks can better utilize the capabilities of specific computing units.

[0183] For example, continuing with the previous example, suppose the implicit representations are classified into three categories based on the number of CPU cores: high, medium, and low. If the first implicitly represented agent parameter variable is classified as the "high" category, it will be added to the first subcomponent. If the second implicitly represented agent parameter variable is classified as the "medium" category, it will be added to the second subcomponent. And so on, until all implicit representations are correctly classified and added to the corresponding subcomponents.

[0184] In step S31C, the computer system shares the agent parameter variables of each subcomponent to the corresponding computing unit, so that each computing unit can process the tasks belonging to the subcomponent.

[0185] For example, if the first subcomponent contains the 1st to 20th implicit representations, then the agent parameters of these 20 implicit representations will be shared with the first computational unit. Similarly, the second subcomponent contains the 21st to 40th implicit representations, and their agent parameters are shared with the second computational unit, and so on.

[0186] In this process, the computer system can also use machine learning models to further optimize the division of subcomponents and the selection of computing units. For example, a decision tree model can be used to predict the best computing unit for each implicit representation. The input of the model can be the agent parameter variable of each implicit representation, and the output is the index of the computing unit. For example, suppose a decision tree model is used to predict the best computing unit for each implicit representation. The agent parameter variable of each implicit representation can be represented as a feature vector, such as [10, 20, 30]. The decision tree model determines which computing unit each implicit representation should be assigned to by analyzing the numerical values ​​in the feature vector. For example, for the first implicit representation, the model may predict that its best computing unit is the first computing unit.

[0187] To improve the prediction accuracy of the model, the computer system can also perform feature engineering, that is, creating new features by transforming the original data. For example, a new feature can be created to represent the ratio of the running time of a task to the number of CPU cores required, which helps the model better capture the characteristics of the task.

[0188] For example, suppose the first implicitly represented agent parameter variable is [10, 20, 30], that is, the number of CPU cores required is 10, the estimated running time is 20 seconds, and the priority is 30. The computer system can create a new feature that represents the ratio of the running time to the number of CPU cores required, that is, 20 / 10 = 2. This new feature can be used to help the decision tree model better understand the requirements of the task.

[0189] Through the above steps S31A to S31C, the computer system can effectively divide the first component into a subcomponents and share the agent parameters of these subcomponents to a computing units. This process not only ensures that the computing tasks can be efficiently load-balanced and scheduled on the heterogeneous supercomputing platform, but also further optimizes the task allocation strategy by using the machine learning model. Ultimately, the computer system can achieve better resource utilization and higher overall performance.

[0190] In an optional embodiment, the agent parameter variables of the first component include multiple agent parameter variables that implicitly represent the corresponding agents. Based on this, as another implementation of step S31, the first component is divided into a subcomponents, and the agent parameter variables of the a subcomponents are shared to a computing units, which may specifically include:

[0191] Step S31a: In response to the number of agent parameters corresponding to the plurality of implicit representations being less than the first reference number of agent parameters, the agent parameters are segmented based on the implicit representation classification corresponding to the agent parameters to obtain first sub-agent parameters corresponding to a sub-components;

[0192] Step S31b: In response to the agent parameters whose number of parameters is not less than the first reference number among the agent parameters corresponding to the plurality of implicit representations, determining the parameter solution of the agent parameters; performing remainder calculation on the parameter solution of the agent parameters and a to obtain the remainder of the agent parameters; and obtaining the second sub-agent parameters corresponding to each of the a sub-components based on the remainder of the agent parameters;

[0193] Step S31c: based on the first sub-agent parameter variables corresponding to each of the a sub-components and the second sub-agent parameter variables corresponding to each of the a sub-components, obtaining the agent parameter variables of the a sub-components;

[0194] Step S31d: Share the intelligent agent parameter variables of a sub-components to a computing units.

[0195] In another embodiment of step S31, the computer system divides the first component into a subcomponents, and shares the agent parameters of these subcomponents to a computing units. This embodiment divides by analyzing the number and parameter solutions of the agent parameters to achieve more effective load balancing scheduling. Steps S31a to S31d will be described in detail below, and will be explained in conjunction with specific examples.

[0196] In step S31, the computer system checks whether the number of parameters in each implicitly represented agent parameter is less than the first reference number. If so, the computer system will segment the agent parameter based on the implicitly represented classification corresponding to the agent parameter to obtain the first sub-agent parameter corresponding to each of the a sub-components.

[0197] For example, suppose n is 100, a is 5, and the first reference quantity is set to 10. The first component processed by the computer system contains 100 implicit representations. Each implicitly represented agent parameter variable can be represented as a feature vector. For example, the feature vector of the first implicit representation is [10, 20, 30], where 10 represents the number of CPU cores required, 20 represents the estimated running time, and 30 represents the priority.

[0198] If the number of parameters of the first implicitly represented agent parameter is 3, which is less than the first reference number of 10, then the computer system will split it into a subcomponent based on the classification of this implicit representation. For example, assuming that the implicit representation is divided into three categories of high, medium, and low based on the number of CPU cores required, and the first implicitly represented agent parameter is classified as "high", it will be added to the first subcomponent and become part of the first sub-agent parameter.

[0199] In step S31b, for the agent parameters whose number of parameters is not less than the first reference number, the computer system will determine the parameter solutions of these agent parameters and perform remainder calculations on them. In this way, the second sub-agent parameters corresponding to each of the a sub-components can be obtained.

[0200] For example, continuing with the previous example, assume that the second implicitly represented agent parameter is [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110], that is, the number of parameters is 11, which is greater than the first reference number 10. The computer system first needs to determine the parameter solution of this agent parameter. The parameter solution can be the result of the modulo of the number of parameters and a, that is, 11%5=1. This means that the second implicitly represented agent parameter will be assigned to the first sub-component and become part of the second sub-agent parameter. After completing steps S31a and S31b, the computer system will combine the first sub-agent parameter and the second sub-agent parameter to form an agent parameter of a sub-component.

[0201] For example, assume that after steps S31a and S31b, the first subcomponent includes the first sub-agent parameter variable from step S31a and the second sub-agent parameter variable from step S31b. For example, the first subcomponent may include the first implicitly represented agent parameter variable [10, 20, 30] and the second implicitly represented agent parameter variable [10, 20, 30,40, 50, 60, 70, 80, 90, 100, 110]. These two agent parameter variables now constitute the agent parameter variables of the first subcomponent.

[0202] In step S31d, the computer system shares the agent parameter variables of each subcomponent to the corresponding computing unit, so that each computing unit can process the tasks belonging to the subcomponent.

[0203] For example, if the first subcomponent contains the 1st to 20th implicit representations, then the agent parameters of these 20 implicit representations will be shared with the first computational unit. Similarly, the second subcomponent contains the 21st to 40th implicit representations, and their agent parameters are shared with the second computational unit, and so on.

[0204] In this process, the computer system can also use machine learning models to further optimize the division of subcomponents and the selection of computing units. For example, a decision tree model can be used to predict the best computing unit for each implicit representation. The input of the model can be the agent parameter variable of each implicit representation, and the output is the index of the computing unit. For example, suppose a decision tree model is used to predict the best computing unit for each implicit representation. The agent parameter variable of each implicit representation can be represented as a feature vector, such as [10, 20, 30]. The decision tree model determines which computing unit each implicit representation should be assigned to by analyzing the numerical values ​​in the feature vector. For example, for the first implicit representation, the model may predict that its best computing unit is the first computing unit.

[0205] To improve the prediction accuracy of the model, the computer system can also perform feature engineering, that is, creating new features by transforming the original data. For example, a new feature can be created to represent the ratio of the running time of a task to the number of CPU cores required, which helps the model better capture the characteristics of the task.

[0206] For example, suppose the first implicitly represented agent parameter variable is [10, 20, 30], that is, the number of CPU cores required is 10, the estimated running time is 20 seconds, and the priority is 30. The computer system can create a new feature that represents the ratio of the running time to the number of CPU cores required, that is, 20 / 10 = 2. This new feature can be used to help the decision tree model better understand the requirements of the task.

[0207] Through the above steps S31a to S31d, the computer system can effectively divide the first component into a subcomponents, and share the agent parameters of these subcomponents to a computing units. This process not only ensures that the computing tasks can be efficiently load-balanced and scheduled on the heterogeneous supercomputing platform, but also further optimizes the task allocation strategy by using the machine learning model. Ultimately, the computer system can achieve better resource utilization and higher overall performance. In this way, the computer system can intelligently manage and schedule computing tasks on the heterogeneous supercomputing platform, ensuring that each computing unit can efficiently run the tasks assigned to it while reducing resource waste and waiting time. This method is particularly suitable for large-scale parallel computing environments, such as high-performance computing clusters, cloud computing data centers, etc., and can significantly improve the throughput and response speed of the system.

[0208] As an implementation manner, step S35, for the f-th computing unit, after processing the second loaded implicit representation corresponding to each knowledge template in the f-th template set based on the second component according to the f-th computing unit and obtaining the second result implicit representation corresponding to each knowledge template in the f-th template set, may also include:

[0209] Step S351: for the fth computing unit, based on the implicit representation of the second result corresponding to each knowledge template in the fth template set, the agent parameter variables of the fth computing unit are optimized to obtain the optimized agent parameter variables of the fth computing unit;

[0210] Step S352: sharing the optimized intelligent agent parameter variables corresponding to the b computing units to obtain the optimized intelligent agent parameter variables of the second component;

[0211] Step S353: Optimize the agent parameters of a computing units based on the implicit representation of the second results corresponding to each of the A knowledge templates to obtain the optimized agent parameters corresponding to each of the a computing units.

[0212] In step S351, after the fth computing unit completes the implicit representation processing of the second results corresponding to each knowledge template in the fth template set, the computer system will optimize the intelligent agent parameter variables of the fth computing unit based on these implicit representations of the results, thereby obtaining optimized intelligent agent parameter variables.

[0213] For example, suppose that the computer system assigns each knowledge template in the fth template set to the fth computing unit for processing. These knowledge templates contain various types of computing tasks, such as matrix multiplication, image recognition, etc. The second result implicit representation of each knowledge template can be represented as a vector, which contains information such as the time to complete the task and the resources consumed.

[0214] For example, the implicit representation of the second result of the first knowledge template can be [50s, 2GB], which means that the task takes 50 seconds and consumes 2GB of memory. The computer system will optimize the agent parameters of the fth computing unit based on these implicit representations of the results. The agent parameters can include the load threshold and priority setting of the computing unit to guide the scheduling of subsequent tasks.

[0215] After completing step S351, the computer system will share the optimized intelligent agent parameter variables corresponding to each of the b computing units to obtain the optimized intelligent agent parameter variables of the second component.

[0216] For example, assuming that b is 5, it means that the knowledge templates in the second component are distributed to 5 computing units for processing. Each computing unit has optimized the agent parameters through step S351. For example, the optimized agent parameters of the first computing unit can be [0.7, 1], indicating that the maximum load threshold of the computing unit is 0.7 and the priority is 1. The computer system will aggregate the optimized agent parameters of each of the five computing units to form the optimized agent parameters of the second component. These optimized agent parameters will be used to guide the scheduling of subsequent tasks.

[0217] In step S353, the computer system optimizes the intelligent agent parameter variables of a computing units based on the implicit representation of the second results corresponding to each of the A knowledge templates to obtain the optimized intelligent agent parameter variables corresponding to each of the a computing units.

[0218] For example, suppose there are A knowledge templates in the second component, and these knowledge templates are assigned to some or all of a computing units for processing. The second result implicit representation of each knowledge template provides key information about task execution, such as running time, resource consumption, etc.

[0219] In this process, the computer system can also use machine learning models to further optimize the agent parameters. For example, a neural network model can be used to predict the optimal agent parameter settings for each computing unit. The input of the model can be the implicit representation of the second result of each knowledge template, and the output is the optimized agent parameter. For example, suppose a multi-layer perceptron (MLP) model is used to predict the optimal agent parameter settings for each computing unit. The implicit representation of the second result of each knowledge template can be represented as a feature vector, such as [50s, 2GB]. The MLP model predicts the optimal agent parameter settings for each computing unit by analyzing these feature vectors, such as [0.7, 1], which means that the maximum load threshold is 0.7 and the priority is 1. In order to train such a machine learning model, the computer system may use a loss function to evaluate the prediction quality of the model. Assuming that the loss function used is the mean square error loss function, it can be expressed as:

[0220] ;

[0221] Among them, y i is the actual optimal agent parameter setting for the ith computational unit, is the agent parameter variable setting predicted by the model, and n is the number of all computing units.

[0222] In order to improve the prediction accuracy of the model, the computer system can also perform feature engineering, that is, create new features by transforming the original data. For example, a new feature can be created to represent the ratio of the running time of the task to the required resources, which helps the model better capture the characteristics of the task. For example, suppose the second result of the first knowledge template is implicitly represented as [50s, 2GB], which means it takes 50 seconds and consumes 2GB of memory. The computer system can create a new feature that represents the ratio of the running time to the required resources, that is, 50s / 2GB = 25s / GB. This new feature can be used to help the MLP model better understand the requirements of the task.

[0223] During the training process, the computer system also monitors the changes in the training error. For example, the cross-validation method can be used to estimate the performance of the model on unseen data. The training error can be obtained by calculating the difference between the model's predicted results and the actual results. Commonly used metrics include mean square error (MSE), mean absolute error (MAE), etc. For example, suppose that during the training of the MLP model, the computer system used a cross-validation method to evaluate the performance of the model. In a cross-validation, the model obtained a mean square error of 0.8 on the training set and a mean square error of 1.2 on the validation set. These errors can help the computer system understand whether the model has an overfitting problem and adjust the model parameters or structure accordingly.

[0224] Through the above steps S351 to S353, the computer system can effectively optimize the agent parameters of each computing unit to achieve better load balancing. This process not only ensures that computing tasks can be efficiently scheduled on heterogeneous supercomputing platforms, but also further improves the accuracy of task allocation by using machine learning models. Ultimately, the computer system can achieve higher resource utilization and faster response speed.

[0225] In this way, the computer system can intelligently manage and schedule computing tasks on heterogeneous supercomputing platforms, ensuring that each computing unit can efficiently run the tasks assigned to it while reducing resource waste and waiting time. This method is particularly suitable for large-scale parallel computing environments, such as high-performance computing clusters, cloud computing data centers, etc., and can significantly improve the system's throughput and response speed.

[0226] As an implementation of step S40, that is, adjusting the load balancing scheduling agent based on the second distributed adjustment method, it may specifically include:

[0227] Step S41: Share the agent parameter variables of the load balancing scheduling agent to c computing units, and divide the B knowledge templates of the load balancing scheduling agent into c template sets, each template set includes one or more knowledge templates, and the g-th computing unit among the c computing units is used to process the g-th template set among the c template sets, c≥2, 1≤g≤c.

[0228] In step S41, the computer system is responsible for sharing the agent parameters of the load balancing scheduling agent to c computing units, and dividing the B knowledge templates of the load balancing scheduling agent into c template sets so that each computing unit processes a template set. First, the computer system shares the agent parameters of the load balancing scheduling agent to c computing units. These agent parameters control the behavior of the load balancing scheduling agent, such as deciding when to assign tasks, how to select the best computing unit, etc. These parameters are shared so that each computing unit can access these parameters and optimize them in subsequent steps. For example, assume that the agent parameters include the load threshold of the computing unit, the task priority, etc. For example, the agent parameters can be represented as a vector [0.5, 0.7], where 0.5 represents the load threshold at which the computing unit starts to reject new tasks, and 0.7 represents the task priority. The computer system shares this vector [0.5, 0.7] to c computing units. Then, the computer system divides the B knowledge templates of the load balancing scheduling agent into c template sets. Each template set contains one or more knowledge templates, and each knowledge template represents a load balancing strategy or a set of load balancing decision instances. By distributing knowledge templates into different template sets, each computing unit can independently process the template set to which it is assigned, thereby improving processing efficiency. The computer system assigns the gth computing unit to process the gth template set. This means that the first computing unit will process the first template set, the second computing unit will process the second template set, and so on. Each computing unit simulates load balancing decisions based on the knowledge templates in the template set to which it is assigned, and evaluates the effectiveness of these decisions. For example, the first computing unit receives the first template set containing 3 knowledge templates. Each knowledge template can be represented as a set of feature vectors. For example, the first knowledge template can be represented as [50s, 2GB, 0.6], where 50s represents the expected running time of the task, 2GB represents the memory required for the task, and 0.6 represents the priority of the task. The first computing unit will make simulated decisions based on these knowledge templates and record the decision results. In this process, the computer system can use machine learning models to further optimize the agent parameters. For example, a neural network model can be used to predict the optimal agent parameter settings for each computing unit. The input of the model can be the feature vectors of each knowledge template, and the output is the optimized agent parameter. For example, suppose a multi-layer perceptron (MLP) model is used to predict the optimal agent parameter settings for each computing unit. The feature vector of each knowledge template can be represented as a vector, such as [50s, 2GB, 0.6]. The MLP model predicts the optimal agent parameter settings for each computing unit by analyzing these feature vectors, such as [0.5, 0.7], which means that the load threshold is 0.5 and the priority is 0.7.

[0229] Through step S41, the computer system can effectively distribute the agent parameters and knowledge templates of the load balancing scheduling agent to each computing unit for processing. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0230] Step S42: For the g-th computing unit, each knowledge template in the g-th template set is processed separately according to the load balancing scheduling agent of the g-th computing unit to obtain the inference results corresponding to each knowledge template in the g-th template set; based on the inference results corresponding to each knowledge template in the g-th template set, the parameter optimization bias vector determined based on the g-th computing unit is obtained.

[0231] In step S42, the computer system processes each knowledge template in the g-th template set based on the load balancing scheduling agent according to the g-th computing unit, obtains the reasoning results corresponding to each knowledge template in the g-th template set, and obtains the parameter optimization bias vector determined by the g-th computing unit based on these reasoning results. This process helps to optimize the agent parameters of the load balancing scheduling agent, thereby improving the performance of the entire system. For the g-th computing unit, each knowledge template in the g-th template set is processed based on the load balancing scheduling agent according to the computing unit. Each knowledge template represents an instance of a load balancing strategy or a set of load balancing decisions. By processing these knowledge templates, the g-th computing unit can simulate load balancing decisions and evaluate the effectiveness of these decisions. Based on the reasoning results corresponding to each knowledge template in the g-th template set, the parameter optimization bias vector determined by the g-th computing unit is obtained. This bias vector, i.e., the gradient, indicates the update direction of the agent parameters so as to better optimize the behavior of the load balancing scheduling agent.

[0232] For example, the computer system calculates the parameter optimization bias vector of the first computing unit based on the inference results of each knowledge template in the first template set. Assume that the optimization bias vector is [-0.1, 0.3], which means that the agent parameters need to be updated in this direction to improve the load balancing effect.

[0233] Through step S42, the computer system can process the knowledge template set assigned to each computing unit, and calculate the parameter optimization bias vector based on the processing results. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using machine learning models, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0234] Step S43: Merge the parameter optimization bias vectors respectively determined by the c computing units to obtain the parameter optimization bias vector of the load balancing scheduling agent.

[0235] Step S44: Optimizing the bias vector based on the parameters of the load balancing scheduling agent, optimizing the agent parameters of the load balancing scheduling agent, and obtaining a calibrated load balancing scheduling agent.

[0236] In steps S43 and S44, the computer system combines the parameter optimization bias vectors determined by the c computing units to obtain the parameter optimization bias vector of the load balancing scheduling agent, and optimizes the agent parameters of the load balancing scheduling agent based on the bias vector, thereby obtaining the adjusted load balancing scheduling agent. This process helps to further optimize the behavior of the load balancing scheduling agent and improve the performance of the entire system.

[0237] The computer system combines the parameter optimization bias vectors determined by the c computing units to obtain the parameter optimization bias vector of the load balancing scheduling agent. This process ensures that the contributions of all computing units are taken into account to obtain a global optimal agent parameter update direction. The computer system optimizes the agent parameters of the load balancing scheduling agent based on the parameter optimization bias vector of the load balancing scheduling agent to obtain the adjusted load balancing scheduling agent. This process helps to improve the behavior of the agent so that it can better cope with future load balancing tasks.

[0238] Through steps S43 and S44, the parameter optimization bias vectors determined by the c computing units can be effectively combined to obtain the parameter optimization bias vector of the load balancing scheduling agent, and the agent parameters are optimized based on the bias vector. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform.

[0239] As another implementation of step S40, that is, adjusting the load balancing scheduling agent based on the second distributed adjustment method, it may specifically include:

[0240] Step S40A: Share the agent parameters of the load balancing scheduling agent to c computing units, and divide the C knowledge templates of the load balancing scheduling agent into d template sets, each template set includes one or more knowledge templates, where d / c=x, the hth computing unit among the c computing units is used to process x template sets among the d template sets, c≥2, d≥2, 1≤h≤c, x≥2.

[0241] In step S40A, the computer system is responsible for sharing the agent parameters of the load balancing scheduling agent to c computing units, and dividing the C knowledge templates of the load balancing scheduling agent into d template sets, each template set containing one or more knowledge templates. This process ensures that each computing unit can process a certain number of template sets, thereby realizing the distributed calibration of the load balancing scheduling agent.

[0242] The computer system first shares the agent parameters of the load balancing scheduling agent to c computing units. These agent parameters control the behavior of the load balancing scheduling agent, such as deciding when to assign tasks and how to select the best computing unit. Sharing these parameters allows each computing unit to access these parameters and optimize them in subsequent steps.

[0243] For example, assume that the agent parameter variables include the load threshold of the computing unit, the task priority, etc. For example, the agent parameter variables can be represented as a vector [0.5, 0.7], where 0.5 represents the load threshold at which the computing unit begins to reject new tasks, and 0.7 represents the task priority. The computer system shares this vector [0.5, 0.7] to c computing units.

[0244] Next, the computer system divides the C knowledge templates of the load balancing scheduling agent into d template sets. Each template set contains one or more knowledge templates, and each knowledge template represents a load balancing strategy or a set of load balancing decision instances. By distributing the knowledge templates into different template sets, each computing unit can independently process the template set to which it is assigned, thereby improving processing efficiency.

[0245] The computer system assigns the hth computing unit to process the x template sets corresponding to the hth computing unit. This means that the first computing unit will process the first and second template sets, the second computing unit will process the third and fourth template sets, and so on. Each computing unit simulates load balancing decisions based on the knowledge templates in the template set to which it is assigned and evaluates the effectiveness of these decisions.

[0246] Through step S40A, the computer system can effectively distribute the agent parameters and knowledge templates of the load balancing scheduling agent to each computing unit for processing. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0247] Step S40B: For the h-th computing unit, each knowledge template in the x template sets is processed separately according to the load balancing scheduling agent of the h-th computing unit to obtain the inference results corresponding to each knowledge template in the x template sets; based on the inference results corresponding to each knowledge template in the x template sets, the x sub-parameter variable optimization bias vector determined based on the h-th computing unit is obtained.

[0248] In step S40B, the computer system processes each knowledge template in the x template sets based on the load balancing scheduling agent for the hth computing unit, obtains the inference results corresponding to each knowledge template in the x template sets, and obtains the x sub-parameter variable optimization bias vector determined based on the hth computing unit based on these inference results. This process helps to optimize the agent parameter variables of the load balancing scheduling agent, thereby improving the performance of the entire system.

[0249] The computer system processes each knowledge template in the set of x templates processed by the h-th computing unit based on the load balancing scheduling agent of the computing unit. Each knowledge template represents an instance of a load balancing strategy or a set of load balancing decisions. By processing these knowledge templates, the h-th computing unit can simulate load balancing decisions and evaluate the effectiveness of these decisions.

[0250] The computer system obtains the x sub-parameter optimization bias indicators determined by the h-th computing unit based on the inference results corresponding to each knowledge template in the h-th template set. These bias indicators indicate the update direction of the agent parameters to better optimize the behavior of the load balancing scheduling agent.

[0251] For example, continuing with the above example, the computer system calculates the two sub-parameter optimization bias vectors of the first computing unit based on the inference results of each knowledge template in the first template set. Assume that the optimization bias vectors are [-0.1, 0.3] and [-0.2, 0.1], which means that the agent parameters need to be updated in these two directions to improve the load balancing effect.

[0252] Through step S40B, the computer system can process the knowledge template set assigned to each computing unit, and calculate the sub-parameter optimization bias vector based on the processing results. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using machine learning models, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0253] Step S40C: If the number of template sets processed by the hth computing unit is less than the second reference number, the x sub-parameter optimization bias vectors determined by the hth computing unit are summed to obtain the parameter optimization bias vector determined based on the hth computing unit.

[0254] In step S40C, the computer system determines whether to sum the x sub-parameter optimization bias vectors determined by the h-th computing unit according to whether the number of template sets processed by the h-th computing unit is less than the second reference number, so as to obtain the parameter optimization bias vector determined by the h-th computing unit. This process helps to ensure that when the amount of tasks processed by the computing unit is appropriate, the parameter optimization bias vector can be effectively merged, thereby better optimizing the agent parameters of the load balancing scheduling agent.

[0255] The computer system determines whether the number of template sets processed by the h-th computing unit is less than the second reference number. If it is less than the second reference number, the next step of summation is performed; otherwise, the summation operation is skipped. For example, assume that the first computing unit processes the first and second template sets, and these two template sets contain 3 and 4 knowledge templates respectively. Assume that the second reference number is 4, that is, if the number of template sets processed by the h-th computing unit is less than 4, a summation operation is performed. Since the number of template sets processed by the first computing unit is 2, which is less than the second reference number 4, a summation operation will be performed. If the number of template sets processed by the h-th computing unit is less than the second reference number, the computer system sums the x sub-parameter optimization bias vectors determined by the computing unit to obtain the parameter optimization bias vector determined based on the h-th computing unit.

[0256] For example, assume that the number of template sets processed by the first computing unit is 2, which is less than the second reference number 4. The two sub-parameter optimization bias vectors determined by the first computing unit are [-0.1, 0.3] and [-0.2, 0.1]. The computer system sums these two vectors and obtains the parameter optimization bias vector [-0.1-0.2, 0.3+0.1]=[-0.3, 0.4].

[0257] Through step S40C, the computer system can decide whether to sum the x sub-parameter optimization bias vectors determined by the computing unit according to whether the number of template sets processed by the h-th computing unit is less than the second reference number. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0258] Step S40D: If the number of template sets processed by the hth computing unit is not less than the second reference number, the parameter optimization bias vectors determined by the c computing units are merged to obtain the parameter optimization bias vector of the load balancing scheduling agent.

[0259] In step S40D, the computer system determines whether to merge the parameter optimization bias vectors determined by the c computing units respectively according to whether the number of template sets processed by the h-th computing unit is not less than the second reference number, so as to obtain the parameter optimization bias vector of the load balancing scheduling agent. This process helps to ensure that when the amount of tasks processed by the computing unit is large enough, the parameter optimization bias vector can be effectively merged, thereby better optimizing the agent parameters of the load balancing scheduling agent. The computer system determines whether the number of template sets processed by the h-th computing unit is not less than the second reference number. If it is not less than the second reference number, the next step of merging is performed.

[0260] For example, suppose the second computing unit processes the third and fourth template sets, which contain 4 and 3 knowledge templates respectively. Assume that the second reference number is 4, that is, if the number of template sets processed by the hth computing unit is not less than 4, a merge operation is performed. Since the number of template sets processed by the second computing unit is 2, plus the number of template sets processed before, a total of 4 template sets are processed, which is not less than the second reference number 4, so a merge operation will be performed.

[0261] If the number of template sets processed by the hth computing unit is not less than the second reference number, the computer system will merge the parameter optimization bias vectors determined by the c computing units to obtain the parameter optimization bias vector of the load balancing scheduling agent.

[0262] Through step S40D, the computer system can decide whether to merge the parameter optimization bias vectors determined by the c computing units respectively according to whether the number of template sets processed by the hth computing unit is not less than the second reference number. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0263] Step S40E: Optimize the bias vector according to the parameters of the load balancing scheduling agent, optimize the agent parameters of the load balancing scheduling agent, and obtain the adjusted load balancing scheduling agent.

[0264] In step S40E, the computer system optimizes the agent parameters of the load balancing scheduling agent according to the load balancing scheduling agent parameter optimization bias vector to obtain the adjusted load balancing scheduling agent. This process is the last step of the load balancing scheduling agent optimization, which aims to update the agent parameters based on the optimization direction obtained in the previous step, thereby improving the performance of the entire system.

[0265] The computer system optimizes the agent parameters of the load balancing scheduling agent based on the parameter optimization bias vector of the load balancing scheduling agent. This process usually involves updating the value of the agent parameter to reflect the optimization direction obtained in the previous step. All processes of updating the agent parameter mentioned in this application can be optimized by using the obtained parameter optimization bias vector and using the gradient descent algorithm.

[0266] Through step S40E, the computer system can optimize the agent parameters according to the load balancing scheduling agent's parameter optimization bias vector to obtain a calibrated load balancing scheduling agent. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0267] As an implementation method, the agent characteristics include the component architecture of the load balancing scheduling agent. Then, step S20, based on the agent characteristics, identifies the agent type of the load balancing scheduling agent, which may specifically include:

[0268] Step S21: Determine the number of parameters of the load balancing scheduling agent based on the component architecture of the load balancing scheduling agent;

[0269] Step S22: if the number of parameters of the load balancing scheduling agent is not less than the third reference number, the agent type of the load balancing scheduling agent is set as the agent type Net1;

[0270] Step S23: if the number of parameters of the load balancing scheduling agent is less than the third reference number, the agent type of the load balancing scheduling agent is set as the agent type Net2;

[0271] Alternatively, in other feasible manners, the agent characteristics include the execution load environment of the load balancing scheduling agent; in this case, step S20, identifying the agent type of the load balancing scheduling agent based on the agent characteristics, may include:

[0272] Step S20A: if the execution load environment of the load balancing scheduling agent corresponds to the first load environment, the agent type of the load balancing scheduling agent is set as the agent type Net1;

[0273] Step S20B: If the execution load environment of the load balancing scheduling agent corresponds to the second load environment, the agent type of the load balancing scheduling agent is set as agent type Net2; the first load environment is different from the second load environment.

[0274] In the above two implementations of step S20, the computer system identifies the agent type of the load balancing scheduling agent based on the agent characteristics. One implementation is to determine the agent type based on the component architecture of the load balancing scheduling agent, and the other implementation is to determine the agent type based on the execution load environment of the load balancing scheduling agent.

[0275] Implementation method 1: Determine the type of agent based on component architecture.

[0276] In step S21, the computer system determines the number of parameters of the load balancing scheduling agent based on the component architecture of the load balancing scheduling agent. These parameters control the behavior of the agent, such as deciding when to assign tasks, how to select the best computing unit, etc. For example, assume that the component architecture of the load balancing scheduling agent contains several modules, each module is responsible for different functions, such as a task assignment module, a resource monitoring module, etc. The computer system analyzes these modules and their configuration parameters to determine the number of parameters. For example, the parameters may include the load threshold of the computing unit, the task priority, etc. Assume that the number of agent parameters is 10.

[0277] In step S22, if the number of parameters of the load balancing scheduling agent is not less than the third reference number, the agent type of the load balancing scheduling agent is set as the agent type Net1.

[0278] For example, assuming that the third reference number is 8, that is, if the number of agent parameters is not less than 8, the agent type is Net1. Since the number of agent parameters is 10, which is greater than the third reference number 8, the computer system determines the agent type of the load balancing scheduling agent to be Net1.

[0279] In step S23, if the number of parameters of the load balancing scheduling agent is less than the third reference number, the agent type of the load balancing scheduling agent is determined as agent type Net2. For example, assuming that the third reference number is 8, and the number of agent parameters is 6, which is less than the third reference number 8, the computer system determines the agent type of the load balancing scheduling agent as Net2.

[0280] Implementation method 2: Determine the agent type based on the execution load environment.

[0281] In step S20A, if the execution load environment of the load balancing scheduling agent corresponds to the first load environment, the agent type of the load balancing scheduling agent is set as the agent type Net1.

[0282] For example, assuming that the first load environment corresponds to a large parallel computing task set, which includes a large number of intensive computing tasks, the computer system analyzes the execution load environment of the load balancing scheduling agent and finds that it corresponds to the first load environment, so the agent type is determined to be Net1.

[0283] In step S20B, if the execution load environment of the load balancing scheduling agent corresponds to the second load environment, the agent type of the load balancing scheduling agent is set as agent type Net2. The second load environment is different from the first load environment. For example, assume that the second load environment corresponds to a series of small, fast-response tasks, such as data analysis tasks. The computer system analyzes the execution load environment of the load balancing scheduling agent and finds that it corresponds to the second load environment, so the agent type is determined to be Net2.

[0284] Through steps S21 to S23 and steps S20A and S20B, the computer system can effectively identify the type of agent based on the component architecture or execution load environment of the load balancing scheduling agent. This process not only helps to improve processing efficiency, but also further optimizes the agent parameters by using a machine learning model, so that the load balancing scheduling agent can make decisions more accurately and improve the performance of the entire heterogeneous supercomputing platform. In this way, the computer system can achieve more efficient load balancing, thereby maximizing the utilization efficiency of computing resources.

[0285] The present application also provides a computer system, such as Figure 2 As shown, the computer system 100 includes: a processor 101 and a memory 103. The processor 101 and the memory 103 are connected, such as through a bus 102. Optionally, the computer system 100 may also include a transceiver 104. It should be noted that in actual applications, the transceiver 104 is not limited to one, and the structure of the computer system 100 does not constitute a limitation on the embodiments of the present application.

[0286] An embodiment of the present application provides a computer system. The computer system in the embodiment of the present application includes: one or more processors; a memory; and one or more computer programs, wherein the one or more computer programs are stored in the memory and configured to be executed by the one or more processors, and when the one or more programs are executed by the processor, the above method is implemented.

Claims

1. A method for load balancing and scheduling of a heterogeneous supercomputing platform, characterized in that: The method comprises: Obtaining implicit representation of the load situation of the target heterogeneous supercomputing platform and implicit representation of multiple scheduling strategies; Determine the policy matching degree of each of the scheduling strategies according to the implicit representation of the load situation of the target heterogeneous supercomputing platform and the implicit representation of the policy of each of the scheduling strategies by the load balancing scheduling agent; Based on the policy matching degree of each of the scheduling policies, determining a target scheduling policy adapted to the current load environment of the target heterogeneous supercomputing platform from the multiple scheduling policies; Execute the target scheduling strategy to perform load balancing scheduling; The load balancing scheduling agent calibration process includes the following steps: Obtain the agent characteristics of the initialized load balancing scheduling agent; Identify the agent type of the load balancing scheduling agent based on the agent characteristics; If the load balancing scheduling agent corresponds to agent type Net1, the load balancing scheduling agent is calibrated based on a first distributed calibration method, wherein the first distributed calibration method represents a fusion calibration method of architecture distribution calibration and sample distribution calibration; If the load balancing scheduling agent corresponds to agent type Net2, the load balancing scheduling agent is calibrated based on a second distributed calibration method, where the second distributed calibration method represents a calibration method of sample distribution calibration; The architecture distribution calibration refers to a mechanism for dividing the components of the load balancing scheduling agent into multiple computing units for calibration, and the sample distribution calibration refers to a mechanism for distributing the knowledge template of the load balancing scheduling agent to multiple computing units for calibration; if the load balancing scheduling agent is a high-load environment scheduling agent, the load balancing scheduling agent is calibrated based on the first distributed calibration method; if the load balancing scheduling agent is a low-load environment scheduling agent, the load balancing scheduling agent is calibrated based on the second distributed calibration method; The agent characteristics include the component architecture of the load balancing scheduling agent; and the agent type of the load balancing scheduling agent identified based on the agent characteristics includes: Determining the number of parameters of the load balancing scheduling agent based on the component architecture of the load balancing scheduling agent; If the number of parameters of the load balancing scheduling agent is not less than the third reference number, the agent type of the load balancing scheduling agent is used as the agent type Net1; If the number of parameters of the load balancing scheduling agent is less than the third reference number, the agent type of the load balancing scheduling agent is used as the agent type Net2; Alternatively, the agent characteristics include the execution load environment of the load balancing scheduling agent; and the identifying the agent type of the load balancing scheduling agent based on the agent characteristics includes: If the execution load environment of the load balancing scheduling agent corresponds to the first load environment, the agent type of the load balancing scheduling agent is used as the agent type Net1; If the execution load environment of the load balancing scheduling agent corresponds to the second load environment, the agent type of the load balancing scheduling agent is used as the agent type Net2; the first load environment is different from the second load environment.

2. The method according to claim 1, characterized in that The load balancing scheduling agent includes a first component obtained based on the architecture distribution adjustment, and a second component obtained based on the sample distribution adjustment; wherein the execution information of the first component includes a first loading implicit representation corresponding to each of the A knowledge templates, the output of the first component includes a first result implicit representation corresponding to each of the A knowledge templates, the execution information of the second component includes a second loading implicit representation corresponding to each of the A knowledge templates, the output of the second component includes a second result implicit representation corresponding to each of the A knowledge templates, and A≥2; The step of adjusting the load balancing scheduling agent based on the first distributed adjustment method includes: For the first component, the first component is divided into a subcomponents, and the intelligent agent parameter variables of the a subcomponents are shared to a computing units, and the e-th computing unit among the a computing units stores the intelligent agent parameter variables of the e-th subcomponent among the a subcomponents, a≥2, 1≤e≤a; For the e-th computing unit, the first loaded implicit representations corresponding to the A knowledge templates are processed respectively according to the e-th subcomponent to obtain the e-th sub-implicit representations corresponding to the A knowledge templates, A≥2; Merging the a sub-implicit representations corresponding to the A knowledge templates to obtain the first result implicit representation corresponding to the A knowledge templates; For the second component, the agent parameter variables of the second component are shared to b computing units, and the A knowledge templates are divided into b template sets, each template set includes one or more knowledge templates, and the f-th computing unit among the b computing units is used to process the f-th template set among the b template sets, b≥2, 1≤f≤b; For the f-th calculation unit, the second loaded implicit representation corresponding to each knowledge template in the f-th template set is processed by the f-th calculation unit based on the second component to obtain the second result implicit representation corresponding to each knowledge template in the f-th template set; The second result implicit representations corresponding to each knowledge template in the b template sets are merged to obtain the second result implicit representations corresponding to each of the A knowledge templates.

3. The method according to claim 2, characterized in that The intelligent agent parameter variables of the first component include a plurality of implicitly representing corresponding intelligent agent parameter variables; dividing the first component into a subcomponents, and sharing the intelligent agent parameter variables of the a subcomponents to a computing units, including: Processing the agent parameter variables corresponding to the plurality of implicit representations to obtain parameter solutions corresponding to the plurality of implicit representations; Performing remainder calculations on the parameter solutions corresponding to the plurality of implicit representations and a respectively, to obtain remainders corresponding to the plurality of implicit representations; Adding the implicitly represented intelligent agent parameter variables corresponding to the same remainder to the same subcomponent to obtain the intelligent agent parameter variables of the a subcomponents; Share the intelligent agent parameter variables of the a subcomponents to the a computing units.

4. The method according to claim 2, characterized in that The step of dividing the first component into a sub-components, and sharing the agent parameter variables of the a sub-components to a computing units includes: Determine the implicit representation classification corresponding to each agent parameter variable of the first component; Adding agent parameter variables belonging to the same implicit representation classification to the same subcomponent to obtain agent parameter variables of the a subcomponents; Share the intelligent agent parameter variables of the a subcomponents to the a computing units.

5. The method according to claim 2, characterized in that The intelligent agent parameter variables of the first component include a plurality of implicitly representing corresponding intelligent agent parameter variables; dividing the first component into a subcomponents, and sharing the intelligent agent parameter variables of the a subcomponents to a computing units, including: In response to the number of agent parameters among the agent parameters corresponding to the plurality of implicit representations being less than a first reference number of agent parameters, the agent parameters are segmented based on implicit representation classifications corresponding to the agent parameters to obtain first sub-agent parameters corresponding to the a sub-components; In response to the agent parameters whose number of parameters is not less than the first reference number among the agent parameters corresponding to the plurality of implicit representations, determining the parameter solution of the agent parameters; performing remainder calculation on the parameter solution of the agent parameters and a to obtain the remainder of the agent parameters; and obtaining the second sub-agent parameters corresponding to each of the a subcomponents based on the remainder of the agent parameters; Based on the first sub-agent parameter variables corresponding to each of the a sub-components and the second sub-agent parameter variables corresponding to each of the a sub-components, obtaining the agent parameter variables of the a sub-components; Share the intelligent agent parameter variables of the a subcomponents to the a computing units.

6. The method according to claim 2, characterized in that The method further includes: processing the second loaded implicit representation corresponding to each knowledge template in the f-th template set according to the f-th computing unit based on the second component to obtain the second result implicit representation corresponding to each knowledge template in the f-th template set; For the f-th computing unit, based on the implicit representation of the second result corresponding to each knowledge template in the f-th template set, the agent parameter variables of the f-th computing unit are optimized to obtain the optimized agent parameter variables of the f-th computing unit; The optimized intelligent agent parameter variables corresponding to each of the b computing units are shared to obtain the optimized intelligent agent parameter variables of the second component; Based on the implicit representation of the second results corresponding to each of the A knowledge templates, the intelligent agent parameter variables of the a computing units are optimized to obtain the optimized intelligent agent parameter variables corresponding to each of the a computing units.

7. The method according to claim 1, characterized in that The step of adjusting the load balancing scheduling agent based on the second distributed adjustment method includes: The agent parameter variables of the load balancing scheduling agent are shared to c computing units, and the B knowledge templates of the load balancing scheduling agent are divided into c template sets, each template set includes one or more knowledge templates, and the g-th computing unit of the c computing units is used to process the g-th template set of the c template sets, c≥2, 1≤g≤c; For the g-th computing unit, the g-th computing unit processes each knowledge template in the g-th template set based on the load balancing scheduling agent to obtain the reasoning results corresponding to each knowledge template in the g-th template set; based on the reasoning results corresponding to each knowledge template in the g-th template set, obtain the parameter optimization bias vector determined by the g-th computing unit; Merging the parameter optimization bias vectors determined by the c computing units respectively to obtain the parameter optimization bias vector of the load balancing scheduling agent; Based on the parameter optimization bias vector of the load balancing scheduling agent, the agent parameters of the load balancing scheduling agent are optimized to obtain the adjusted load balancing scheduling agent.

8. The method according to claim 1, characterized in that The step of adjusting the load balancing scheduling agent based on the second distributed adjustment method includes: The agent parameter variables of the load balancing scheduling agent are shared to c computing units, and the C knowledge templates of the load balancing scheduling agent are divided into d template sets, each template set includes one or more knowledge templates, wherein d / c=x, and the hth computing unit among the c computing units is used to process x template sets among the d template sets, c≥2, d≥2, 1≤h≤c, x≥2; For the h-th computing unit, the h-th computing unit processes each knowledge template in the x template sets based on the load balancing scheduling agent to obtain the inference results corresponding to each knowledge template in the x template sets; based on the inference results corresponding to each knowledge template in the x template sets, obtain the x sub-parameter variable optimization bias vector determined based on the h-th computing unit; If the number of template sets processed by the h-th computing unit is less than the second reference number, summing the x sub-parameter optimization bias vectors determined by the h-th computing unit to obtain the parameter optimization bias vector determined based on the h-th computing unit; If the number of template sets processed by the h-th computing unit is not less than the second reference number, merging the parameter optimization bias vectors respectively determined by the c computing units to obtain the parameter optimization bias vector of the load balancing scheduling agent; The bias vector is optimized according to the parameter variables of the load balancing scheduling agent, and the agent parameter variables of the load balancing scheduling agent are optimized to obtain the adjusted load balancing scheduling agent.

9. A computer system, characterized in that: include: one or more processors; Memory; one or more computer programs; The one or more computer programs are stored in the memory and configured to be executed by the one or more processors, and when the one or more computer programs are executed by the processors, the method according to any one of claims 1 to 8 is implemented.