Lightweight deep learning enabled heterogeneous computing system task scheduling method, scheduling server and heterogeneous computing system

Abstract

The invention discloses a lightweight deep learning enabling heterogeneous computing system task scheduling method, a scheduling server and a heterogeneous computing system, and the method comprises the steps: receiving and analyzing a task request, and obtaining historical execution data of similar tasks from a system log; according to an analysis result and historical execution data, respectively evaluating a calculation complexity index, a data transmission demand index and an AI operator proportion index of the current task, and further constructing a multi-dimensional feature vector for eliminating scale deviation; inputting the multi-dimensional feature vector into a pre-constructed MLP model to predict a task type to which the current task belongs; matching a target device cluster corresponding to the prediction result according to a preset rule; and distributing the current task to the matched equipment in the target equipment cluster according to a load balancing distribution principle. According to the method, accurate judgment of task types is realized through'multi-dimensional feature engineering + shallow neural network ', and reasonable resource allocation of the system during task scheduling is realized.

Description

Technical Field

[0001] This invention relates to the field of heterogeneous computing, and in particular to a lightweight deep learning-enabled task scheduling method, scheduling server, and heterogeneous computing system for heterogeneous computing systems. Background Technology

[0002] Traditional heterogeneous cluster scheduling relies on manually preset fixed rules (such as "AI tasks are assigned to GPUs"), without dynamically determining the type based on the core characteristics of the task. This leads to mismatch problems such as "computation-intensive tasks are assigned to CPUs" and "low-latency tasks are assigned to GPUs", resulting in low resource utilization and high task execution latency.

[0003] Typical task types include compute-intensive tasks and communication-intensive tasks. Understanding task types helps the system allocate resources rationally during task scheduling. For compute-intensive tasks, time is mainly consumed by the processor's computation, with most time spent performing arithmetic operations and logical judgments. There is little data exchange during the computation process, resulting in low data movement requirements. In contrast, the time for communication-intensive tasks is mainly consumed by data transmission, synchronization, or I / O operations between nodes or processes.

[0004] The determination of task type (computation-intensive / communication-intensive) often relies on "single feature manual thresholds" (such as judging it as computation-intensive solely based on "computational cost > 100 GFLOPs"), without comprehensively considering the multi-dimensional attributes of the task. This leads to insufficient accuracy in task type determination, and for example, it easily overlooks the following two factors: First, ignore the "communication-computation correlation characteristics" of tasks: For example, although a certain task has a high computational load, it needs to frequently transmit data with the preceding task, and the communication volume accounts for more than 40%. If it is judged as "computation-intensive" according to the traditional rules and allocated to the GPU, the data transmission latency will be too high due to insufficient bandwidth between the GPU and other nodes. Second, there is a lack of time-series feature references: for example, if the task type is determined by the proportion of a single "computation-communication" without combining it with historical execution data of similar tasks (such as the average communication volume and computation time fluctuations in recent executions), the accuracy of task type determination will be too low, which will lead to a mismatch between task and node characteristics.

[0005] In addition to the aforementioned problem of insufficient accuracy in task type identification, there is also the issue of poor adaptability due to the lack of dynamism in task priority calculation: existing solutions mostly use "fixed mathematical formulas" to calculate task priorities, and parameters (such as calculation time weight and communication overhead weight) need to be preset manually and remain unchanged for a long time, which cannot adapt to the dynamic load changes of computing nodes; while ignoring the "historical adaptability" of computing nodes further exacerbates the problem of resource waste of "highly adaptable nodes being idle and high-load nodes being overloaded".

[0006] In addition, traditional task scheduling iteration optimization often adopts a crude mechanism of "fixed rounds for the whole scheme" without distinguishing between task importance and node state changes: regardless of whether the task is a critical task or whether the node state is stable, all task allocation schemes are executed for several rounds of iteration. The scheduling delay of small and medium-sized clusters may even exceed the execution time of the task itself, resulting in excessively high computing costs and delayed risk avoidance.

[0007] In summary, existing task scheduling schemes for heterogeneous computing systems have shortcomings in three core aspects: accurate task type identification, dynamic priority adaptation, and iterative optimization efficiency.

[0008] The disclosure of the above background technical content is only for the purpose of assisting in understanding the concept and technical solution of this application, and does not necessarily provide technical instruction. Summary of the Invention

[0009] The purpose of this invention is to provide a task scheduling method for heterogeneous computing systems by introducing a lightweight deep learning model into the scheduling link, thereby achieving dynamic adaptation and scheduling of tasks and heterogeneous computing nodes, and improving the overall resource utilization, task completion efficiency and service stability of the system.

[0010] To achieve the above objectives, the technical solution adopted by the present invention is as follows: A lightweight deep learning-enabled task scheduling method for heterogeneous computing systems includes the following steps: Receive task requests, including task configuration information and task dependency information; The task configuration information is parsed to obtain the task computation volume, data scale, input and output data volume, task parallelism, and latency requirements; the task dependency information is parsed to obtain the task communication volume; and historical execution data of similar tasks are obtained from the system's task execution log. Based on the parsing results of the task configuration information and task dependency information, as well as historical execution data, the computational complexity index, data transmission requirement index, and AI operator ratio index of the current task are evaluated respectively. Construct a multidimensional feature vector, which should at least include the task computation volume, task communication volume, computational complexity index, data transmission requirement index, and AI operator ratio index, with unified numerical expression and elimination of scale bias. The multidimensional feature vector is input into a pre-built MLP model to predict the task type of the current task, which includes computationally intensive and communication-intensive tasks. Based on the prediction results of the MLP model, the target device cluster is matched according to preset rules; According to the load balancing principle, the current task is assigned to the device in the matched target device cluster.

[0011] Furthermore, based on any one or a combination of the aforementioned technical solutions, the computational and / or communication workloads of the task can be obtained by achieving a unified numerical expression and eliminating scale bias in the following ways: Obtain historical execution data of similar tasks from the system's task execution logs, including historical data on computational and / or communication volume; Determine the range of historical data for a preset time period or a preset number of tasks; Min-Max normalization is applied to the computational and / or communication load of the current task: D norm =(D cur -D min ) / (D max -D min ), where D norm To standardize numerical representation and eliminate scaling bias in data, D cur D represents the computational or communication volume of the current task. min D represents the lower limit of the corresponding historical data range. max This represents the upper limit of the corresponding historical data range.

[0012] Furthermore, based on any one or a combination of the aforementioned technical solutions, a computational complexity index with a unified numerical expression and elimination of scale bias can be obtained through any of the following methods: Method 1: Obtain historical execution data for similar tasks, including three types of data: historical computational load, historical parallelism, and historical communication load; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the current task's computational load, parallelism, and communication load, and use the normalization result as the computational complexity index. Method 2: Obtain the minimum and maximum reference values ​​for computational complexity, parallelism, and communication volume preset by the system; perform Min-Max normalization on the sum of the current task's computational complexity, parallelism, and communication volume, and use the normalization result as the computational complexity index.

[0013] Furthermore, based on any one or a combination of the aforementioned technical solutions, a data transmission requirement index with a unified numerical expression and eliminating scale bias can be obtained through any of the following methods: Method 1: Obtain historical execution data for similar tasks, including three types of data: historical data scale, historical input / output data volume, and historical latency requirements; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the data scale, input / output data volume, and latency requirements of the current task, and use the normalization result as the data transmission requirement indicator; Method 2: Obtain the minimum and maximum reference values ​​for the system's preset data scale, input / output data volume, and delay requirements; perform Min-Max normalization on the sum of the current task's data scale, input / output data volume, and delay requirements, and use the normalization result as the data transmission requirement indicator.

[0014] Furthermore, based on any one or a combination of the aforementioned technical solutions, an AI operator scaling index with a unified numerical expression and elimination of scale bias can be obtained through any of the following methods: Method 1: Obtain historical execution data for similar tasks, including three types of data: historical computational load, historical parallelism, and historical execution time; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks, and calculate the average value of the historical execution time; perform Min-Max normalization on the sum of the current task's task computational load, task parallelism, and historical execution time average, and use the normalization result as the AI ​​operator ratio index. Method 2: Obtain the minimum and maximum reference values ​​for computational load, parallelism, and execution time preset by the system; calculate the average historical execution time of similar tasks within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the current task's computational load, parallelism, and historical execution time average, and use the normalization result as the AI ​​operator ratio index.

[0015] Furthermore, following any one or a combination of the aforementioned technical solutions, the multidimensional feature vector also includes feature data that uniformly expresses and eliminates scale bias in relation to the data scale, input and output data volume, task parallelism, and latency requirements of the current task. And / or, the multidimensional feature vector further includes time-series execution data, which includes one or more of the following types: Historical average execution time is defined as the average execution time of the last i similar tasks obtained from the system's task execution logs. Historical execution time variance is defined as the variance calculated based on the execution times of the j most recent similar tasks in the system's task execution log. The device's real-time remaining memory is the available memory of the current computing device obtained through the system's device resource monitoring tools; Historical device adaptation rate is defined as the proportion of successful executions of a computing device to the total number of executions, obtained by statistical analysis of the system's device scheduling logs. Real-time device load is defined as the proportion of time a computing device spends executing non-idle tasks out of the total time, as obtained through the system's device resource monitoring tools.

[0016] Furthermore, following any one or a combination of the aforementioned technical solutions, the process of eliminating scale bias in the time-series execution data includes: The historical average execution time, historical execution time variance, and real-time remaining memory of the device are each processed using their respective historical data and then subjected to Min-Max normalization. The historical device adaptation rate and real-time device load are uniformly expressed as decimals corresponding to percentage characteristics.

[0017] Furthermore, based on any one or a combination of the aforementioned technical solutions, the MLP model is constructed with the following configuration: An input layer is configured to receive the multidimensional feature vector and perform format validation. The first hidden layer is configured to extract the correlation information between a single feature in the multidimensional feature vector and the performance of the computing device. The second hidden layer is configured to extract the correlation information between multiple feature combinations in the multidimensional feature vector and the performance of the computing device. The output layer is configured to output the probability distributions corresponding to various task types.

[0018] Furthermore, following any one or a combination of the aforementioned technical solutions, the MLP model is trained through the following steps: Constructing a training dataset includes: collecting historical scheduling data from a heterogeneous computing system cluster; selecting effective samples based on a balanced coverage of both compute-intensive and communication-intensive task types, wherein the historical scheduling data of the effective samples includes historical task feature data and historical time-series execution data; automatically labeling the effective samples as compute-intensive or communication-intensive based on the task execution efficiency in the historical time-series execution data, and sampling and verifying the results of the automatic task type labeling; dividing the verified labeled effective samples into a training set, a validation set, and a test set, with a balanced number of samples of each task type in each set; Configure training parameters, including: setting the optimizer to Adam, setting the learning rate, batch size, and training epochs, and setting the loss function to the cross-entropy loss function; After each training epoch of training the model using the training set, the model's performance on the validation set is calculated. The training effect of the model is verified on the test set after training, and the generalization ability of the model is evaluated.

[0019] Furthermore, following any one or a combination of the aforementioned technical solutions, the number of neurons in the first hidden layer is configured to be 16. The N-dimensional feature vector input to the first hidden layer is multiplied by an N×16 weight matrix, and after adding a bias, it is activated by the ReLU function, thereby the first hidden layer outputs a 16-dimensional vector. The second hidden layer has 8 neurons. The 16-dimensional vector output by the first hidden layer is multiplied by a 16×8 weight matrix, biased, and then activated by the ReLU function. The second hidden layer then outputs an 8-dimensional vector. The number of neurons in the output layer is configured to be 2. The 8-dimensional vector output by the second hidden layer is multiplied by an 8×M weight matrix, and after adding a bias, it is activated by the Softmax function. Then, the output layer outputs an M-dimensional probability vector, where M is the number of types of the task.

[0020] Furthermore, following any one or a combination of the aforementioned technical solutions, the output layer of the MLP model outputs a two-dimensional probability vector, which represents the probability of computationally intensive operation and the probability of communication-intensive operation, respectively. The heterogeneous computing system's computing device cluster includes CPUs, GPUs, NPUs, and FPGAs; matching the target device cluster according to preset rules includes: If the probability of the MLP model predicting a computationally intensive task is greater than 0.5, then the target device cluster is matched as a GPU or NPU. If the probability of the MLP model predicting a communication-intensive task is greater than 0.5, and the latency requirement data of the current task meets the preset low latency requirement, then the target device cluster is matched as FPGA. If the probability of the MLP model predicting a communication-intensive task is greater than 0.5, and the latency requirement data of the current task does not meet the preset low latency requirement, then the target device cluster is matched as CPU.

[0021] Furthermore, following any one or a combination of the aforementioned technical solutions, after matching the target device cluster, real-time load data and concurrent data of the devices are extracted from the time-series execution data of each target device in the target device cluster. Assign the current task to the target device with the lowest real-time load and that has not reached its concurrency limit.

[0022] According to another aspect of the present invention, a task scheduling server is provided, comprising the following modules: The task receiving module is configured to receive task requests, including task configuration information and task dependency information. The task parsing module is configured to parse the task configuration information to obtain the task computation amount, data size, input and output data volume, task parallelism, and latency requirements; and to parse the task dependency information to obtain the task communication volume. The task execution log module is configured to allow querying historical execution data for similar tasks; The indicator evaluation module is configured to evaluate the computational complexity indicator, data transmission requirement indicator, and AI operator ratio indicator of the current task based on the parsing results output by the task parsing module and the query results output by the task execution log module, respectively. The feature vector module is configured to construct multi-dimensional feature vectors, which include at least the task computation volume, task communication volume, computational complexity index, data transmission requirement index, and AI operator ratio index, which unify numerical expression and eliminate scale bias. The MLP module is configured to analyze the multidimensional feature vector using a pre-built MLP model to predict the task type of the current task, which includes computationally intensive and communication-intensive tasks. The matching module is configured to match the target device cluster according to preset rules based on the prediction results of the MLP model. The load balancing module is configured to distribute the current task to devices in the matched target device cluster according to the load balancing distribution principle.

[0023] Furthermore, following any one or a combination of the aforementioned technical solutions, the task scheduling server further includes a preprocessing module configured to perform scale bias removal processing on the features to be constructed into a multidimensional feature vector, including: Obtain historical computation volume of similar tasks from the system's task execution log, determine the upper and lower limits of computation volume within a preset time period or preset number of tasks, and perform Min-Max normalization on the current task's computation volume. Obtain historical communication volume of similar tasks from the system's task execution log, determine the upper and lower limits of communication volume within a preset time period or preset number of tasks; perform Min-Max normalization on the task computation volume of the current task. The sum of the task computation, task parallelism, and task communication of the current task is normalized by Min-Max to obtain a computational complexity index that eliminates scale bias. The sum of the data size, input and output data volume, and latency requirements of the current task is normalized using Min-Max to obtain the data transmission requirement index that eliminates scale bias. The sum of the current task's computational load, task parallelism, and historical average execution time is normalized using Min-Max to obtain an AI operator ratio index that eliminates scale bias.

[0024] According to another aspect of the present invention, a heterogeneous computing system is provided, including a scheduling server and various types of computing device clusters, wherein the scheduling server uses the task scheduling method described above to allocate tasks to devices in the corresponding device clusters.

[0025] The beneficial effects of the technical solution provided by this invention are as follows: a. For heterogeneous computing resources such as CPU / GPU / FPGA / NPU, a lightweight deep learning model is introduced into the task scheduling link to achieve dynamic adaptation and scheduling of tasks and heterogeneous computing nodes, reduce task completion latency, and improve the overall resource utilization and service stability of the system. b. By using "multi-dimensional feature engineering + shallow neural network", the system can accurately identify task types and allocate resources reasonably during task scheduling. c. Simplify the self-attention mechanism to dynamically calculate priorities and trigger key task iterations based on load prediction. While ensuring scheduling accuracy, reduce model complexity and computational cost to meet the deployment needs of small and medium-sized heterogeneous clusters. Attached Figure Description

[0026] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0027] Figure 1 A flowchart illustrating a lightweight deep learning-enabled heterogeneous computing system task scheduling method provided as an exemplary embodiment of the present invention. Figure 2 This is a schematic diagram of the architecture of a heterogeneous computing system provided as an exemplary embodiment of the present invention. Detailed Implementation

[0028] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0029] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, apparatus, product, or device that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or devices.

[0030] In one embodiment of the present invention, a lightweight deep learning-enabled task scheduling method for heterogeneous computing systems is provided, such as... Figure 1 As shown, it includes the following steps: S100: Receives task requests, including task configuration information and task dependency information; S200: Parse the task configuration information to obtain the task computation volume, data scale, input and output data volume, task parallelism, and latency requirements; parse the task dependency information to obtain the task communication volume; and obtain historical execution data of similar tasks from the system's task execution log. The computational load is defined as the total number of computational operations required to complete a specific task, typically expressed in floating-point operations (FLOPS). Data size is defined, for example, the image size in image processing. Input and output data volume is defined as the total amount of data involved in the processing; input data volume represents the total amount of data to be read at the start of the task, and output data volume represents the total amount of data to be written at the end of the task. Task parallelism is defined as the degree to which a task can be decomposed into multiple independent subtasks that can be executed in parallel, typically expressed as the number of concurrent threads, processes, or processing units. Latency requirement is defined as the maximum time limit required to complete the task.

[0031] S300: Based on the parsing results of the task configuration information and task dependency information, as well as historical execution data, evaluate the computational complexity index, data transmission requirement index, and AI operator ratio index of the current task respectively. Regarding the evaluation of the computational complexity of the current task: the sum of the task's computational load, parallelism, and communication load is subjected to Min-Max normalization. The normalized result is used as a unified numerical expression for computational complexity that eliminates scale bias. The normalization formula is as follows: R1=[(x1+x4+x7)-(x 1min +x 4min +x7min )] / [(x 1max +x 4max +x 7max )-(x 1min +x 4min +x 7min ], where R1 represents the computational complexity index for eliminating scale bias, x1 represents the computational cost of the current task, x4 represents the parallelism of the current task, x7 represents the communication cost of the current task, and x 1min x 1max Indicates the lower and upper limits of computational complexity, x 4min x 4max Indicates the lower and upper limits of parallelism, x 7min x 7max This represents the lower and upper limits of the communication volume; these upper and lower limits can be obtained in any of the following ways: Method 1 involves obtaining historical execution data for similar tasks, including historical computation volume, historical parallelism, and historical communication volume; determining the historical data range of each of the above three types of data within a preset time period or preset number of tasks, that is, determining the lower limit and upper limit of each of the computation volume, parallelism, and communication volume. Method 2 involves pre-setting minimum and maximum reference values ​​for computational load, parallelism, and communication load, which serve as their respective lower and upper limits.

[0032] Similarly, the two methods for assessing the data transmission requirements of the current task are as follows: Method 1: Obtain historical execution data for similar tasks, including historical data size, historical input and output data volume, and historical latency requirements; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the data size, input and output data volume, and latency requirements of the current task, and use the normalization result as a data transmission requirement indicator with a unified numerical expression and to eliminate scale bias. Method 2: Obtain the minimum and maximum reference values ​​for the system's preset data scale, input / output data volume, and delay requirements; perform Min-Max normalization on the sum of the current task's data scale, input / output data volume, and delay requirements, and use the normalization result as a unified numerical expression for data transmission requirements that eliminates scale bias.

[0033] Similarly, the two methods for evaluating the proportion of AI operators in the current task are as follows: Method 1: Obtain historical execution data of similar tasks, including historical computation volume, historical parallelism, and historical execution time; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks, and calculate the average value of the historical execution time; perform Min-Max normalization on the sum of the average historical execution time of the current task, including task computation volume, task parallelism, and historical execution time, and use the normalization result as a unified numerical expression and AI operator ratio index to eliminate scale bias. Method 2: Obtain the minimum and maximum reference values ​​for computational load, parallelism, and execution time preset by the system; calculate the average historical execution time of similar tasks within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the current task's computational load, parallelism, and historical execution time averages, and use the normalization result as a unified numerical expression and AI operator ratio index to eliminate scale bias.

[0034] S400: Construct a multidimensional feature vector, which includes at least the task computation volume, task communication volume, computational complexity index, data transmission requirement index, and AI operator ratio index, all of which have a unified numerical expression and eliminate scale bias. The preprocessing flow in this embodiment includes three progressive steps: feature quantification, standardization to eliminate scale bias, and feature vector concatenation. Each step is logically closed-loop and reproducible. Step 1: Feature Numericalization. This involves unifying the numerical representation of heterogeneous features. Original features, due to their different sources, exhibit multiple formats (floating-point numbers, percentages, category attributes, etc.). They must first be converted into a numerical form that can participate in mathematical operations to ensure the neural network can parse them. Differentiated transformation rules are designed for different feature types, covering all extracted features and adapting to engineering practices. Among them, task computation volume is defined as the number of floating-point operations (FLOPs) that the task needs to perform, which is extracted from the metadata (such as task configuration file) when the task is submitted; task communication volume is defined as the total amount of data transmission between the task and its predecessor / follower tasks (GB), which is calculated from the task dependency table (such as workflow configuration). Timing execution data includes one or more of the following types: Historical average execution time is defined as the average execution time of the last i similar tasks obtained from the system's task execution logs. Historical execution time variance is defined as the variance calculated based on the execution times of the j most recent similar tasks in the system's task execution log. The device's real-time remaining memory is the available memory of the current computing device obtained through the system's device resource monitoring tools; Historical device adaptation rate is defined as the proportion of successful executions of a computing device to the total number of executions, obtained by statistical analysis of the system's device scheduling logs. Real-time device load is defined as the proportion of time a computing device spends executing non-idle tasks out of the total time, as obtained through the system's device resource monitoring tools.

[0035] Among the above characteristics, computational cost (FLOPs), communication cost (GB), historical average execution time (s), and execution time variance (s) are also important. 2 The device's real-time remaining memory is characterized by continuous floating-point / integer values. The original numerical attributes are directly preserved, and the data is uniformly converted to float32 format for storage to avoid precision loss. Example: An image classification task has a computational cost of 600 GFLOPs, which is directly converted to 600.0 in float32 format. Among the above features, the historical device fit rate (%) and real-time device load (%) are percentage features, which are converted to decimals in the range [0,1]. If the historical fit rate is already in the form of "number of successes / total number of successes" (e.g., 0.96), the decimal is directly retained. Example: CPU real-time load 42% → 0.42 (float32 format); NPU historical fit rate 96% → 0.96.

[0036] After extracting the core features and temporal features of the task, the heterogeneous original features need to be transformed into fixed-length numerical vectors adapted to the shallow MLP model through standardization preprocessing, thereby eliminating the interference of data format differences and scale bias on model inference, as described below: Step 2: Standardize the unified numerical representation to eliminate scale bias. Different features have vastly different original value ranges (e.g., computational cost 10-1000 GFLOPs, load 0-100%). Directly inputting these values ​​into the model would cause it to be overly biased towards large-scale features. A hierarchical normalization strategy is designed according to feature type to ensure that all feature scales are uniform and their distribution is stable.

[0037] In this embodiment, the standardization process to eliminate scale bias in the unified numerical representation of task feature data (i.e., the computational and communication volume of the task) and time-series execution data includes: The computational load, communication load, historical average execution time, historical execution time variance, and real-time remaining memory of the device, after being expressed in a unified numerical form, are each subjected to Min-Max normalization using their respective historical data, so that the processed data are all values ​​within the range of [0,1]. The normalization calculation formula is as follows: f norm =( f - f min ) / ( f max -f min ),in f min , f max For this feature f Historical statistical extreme values ​​(the 99th percentile of system operation data over the most recent few days (e.g., the last 30 days), excluding outliers) are pre-stored in the system configuration library and updated monthly. Example: The historical computational load ranges from 10 to 1000 GFLOPs. For a task with a computational load of 600 GFLOPs, normalization is applied: (600-10) / (1000-10)≈0.596. Communication volume, historical average execution time, historical execution time variance, and real-time remaining device memory are normalized based on their respective historical statistical data, which will not be elaborated further.

[0038] Historical device compatibility rates and real-time device loads are uniformly expressed as percentages in decimal form and directly reused during the standardization process.

[0039] For the unified numerical expression of the indicator characteristics (computational complexity indicator, data transmission requirement indicator, and AI operator proportion indicator) and the method to eliminate scale bias, please refer to step S300, which will not be repeated here.

[0040] In one embodiment, the task feature data also includes the current task's data size, input and output data volume, task parallelism, and latency requirements. The unified numerical expression and scale bias elimination method is the same as the normalization calculation method of the above-mentioned computational volume, that is, using the corresponding historical upper and lower limits for Min-Max normalization processing.

[0041] Step 3: Concatenate the standardized feature data into a feature vector of a preset length in a preset order.

[0042] The 2D task feature data vector (current task computation and communication volume), the 5D time-series execution data vector (historical average execution time, historical execution time variance, device real-time remaining memory, historical device adaptation rate, device real-time load), and the 3D indicator feature vector (computation complexity indicator, data transmission requirement indicator, and AI operator ratio indicator) are concatenated to obtain a 10-dimensional input vector. The input features here cover all dimensions of task computation, communication, historical execution, node adaptation, etc., so that the prediction results of the MLP model can accurately identify the task type and complete task scheduling in a precise and adaptive manner.

[0043] In one embodiment, a 6-dimensional task feature data vector (current task's computational volume, communication volume, data size, input and output data volume, task parallelism, and latency requirements) and a 3-dimensional indicator feature vector (computational complexity indicator, data transmission requirement indicator, and AI operator ratio indicator) can be concatenated to obtain a 9-dimensional input vector. In one embodiment, a 6-dimensional task feature data vector (current task's computational load, communication load, data size, input / output data volume, task parallelism, and latency requirements), a 5-dimensional time-series execution data vector (historical average execution time, historical execution time variance, device real-time remaining memory, historical device adaptability, and device real-time load), and a 3-dimensional indicator feature vector (computational complexity indicator, data transmission requirement indicator, and AI operator ratio indicator) can be concatenated to obtain a 14-dimensional input vector.

[0044] S500: Input the multidimensional feature vector into a pre-built MLP model to predict the task type of the current task, which includes computationally intensive and communication-intensive tasks; The MLP model is built as a lightweight 4-layer model with the following configuration: An input layer is configured to receive the multidimensional feature vector and perform format validation. The first hidden layer is configured to extract the correlation information between a single feature in the multidimensional feature vector and the performance of the computing device. The second hidden layer is configured to extract the correlation information between multiple feature combinations in the multidimensional feature vector and the performance of the computing device. The output layer is configured to output the probability distributions corresponding to various task types.

[0045] The MLP model is trained through the following steps: Constructing a training dataset includes: collecting historical scheduling data from a heterogeneous computing system cluster; selecting effective samples based on a balanced coverage of both compute-intensive and communication-intensive task types, wherein the historical scheduling data of the effective samples includes historical task feature data and historical time-series execution data; automatically labeling the effective samples as compute-intensive or communication-intensive based on the task execution efficiency in the historical time-series execution data, and sampling and verifying the results of the automatic task type labeling; dividing the verified labeled effective samples into a training set, a validation set, and a test set, with a balanced number of samples of each task type in each set; Configure training parameters, including: setting the optimizer to Adam, setting the learning rate, batch size, and training epochs, and setting the loss function to the cross-entropy loss function; After each training epoch of training the model using the training set, the model's performance on the validation set is calculated. The training effect of the model is verified on the test set after training, and the generalization ability of the model is evaluated.

[0046] In one embodiment of the present invention, during the construction of the training dataset, computing device performance data is also added to the effective samples, including: parallel computing capability, low latency capability, and AI adaptability. Parallel computing capability is defined as the ability of a device to process multiple computing tasks simultaneously (e.g., a GPU can process thousands of data points at a time, demonstrating strong parallel capability), corresponding to a computational complexity index. Low latency capability is defined as the time it takes for a device to process a single task from start to finish (e.g., an FPGA processes sensor data with latency often below 1ms, demonstrating strong low latency capability), corresponding to a data transmission requirement index. AI adaptability is defined as the degree to which a device optimizes for AI tasks (e.g., image inference, model training) (e.g., an NPU is specifically designed for AI, demonstrating strong adaptability), corresponding to an AI operator ratio index.

[0047] Based on the hardware characteristics and business features of different types of computing devices, the parallel computing capability, low latency capability, and AI adaptability of different types of computing devices are quantified into values ​​within the range of [0,1]. The higher the value, the stronger the performance of the corresponding computing device. In the standardization process, the performance data of the computing device is quantized into values ​​within the range of [0,1] for direct reuse.

[0048] In this embodiment, the computing device cluster of the heterogeneous computing system includes CPU, GPU, NPU, and FPGA. In a specific numerical embodiment, the computing device performance data settings of CPU, GPU, NPU, and FPGA are shown in Table 1: Table 1. Performance data of computing devices and their setting basis Table 1 shows the 3D embedding vectors of computing device performance data for various computing device cluster types after standardization: CPU type computing device performance data vector is [0.3, 0.6, 0.4], GPU type computing device performance data vector is [0.9, 0.2, 0.8], NPU type computing device performance data vector is [0.8, 0.3, 0.9], and FPGA type computing device performance data vector is [0.2, 0.9, 0.3].

[0049] After labeling the effective samples as either compute-intensive or communication-intensive, the corresponding device type is determined, and the performance data vector corresponding to that type of device is added to the effective sample.

[0050] This invention is not limited to the performance data values ​​recorded in Table 1. The technical solution of this invention can also be achieved by appropriately adjusting the performance data values ​​in Table 1 under the following conditions: the quantified values ​​of the parallel computing capabilities of GPU and NPU are higher than those of CPU and FPGA; the quantified values ​​of the AI ​​adaptation degree of GPU and NPU are higher than those of CPU and FPGA; the low latency capability of FPGA is higher than that of CPU; and the low latency capability of CPU is higher than that of GPU and NPU.

[0051] In one specific embodiment, the number of neurons in the first hidden layer is configured to be 16. The N-dimensional feature vector input to the first hidden layer is multiplied by an N×16 weight matrix, and after adding a bias, it is activated by the ReLU function, and then the first hidden layer outputs a 16-dimensional vector. The first hidden layer adopts a He normal initialization strategy. The second hidden layer has 8 neurons. The 16-dimensional vector output by the first hidden layer is multiplied by a 16×8 weight matrix, and after adding a bias, it is activated by the ReLU function, and then the second hidden layer outputs an 8-dimensional vector. The second hidden layer adopts the He normal initialization strategy. The number of neurons in the output layer is configured to be 2. The 8-dimensional vector output by the second hidden layer is multiplied by an 8×M weight matrix, and after adding a bias, it is activated by the Softmax function. Then, the output layer outputs an M-dimensional probability vector, where M is the number of task types. The output layer adopts the Xavier normal initialization strategy.

[0052] The parameter configurations and functional positioning of each layer of the MLP model described above are clearly defined and have been verified and optimized through extensive experiments, as demonstrated in the following aspects: First, the ReLU activation function is used for the first and second hidden layers to solve the gradient vanishing problem while reducing computational complexity (about 40% less computation than the Sigmoid function); the Softmax activation function is used for the output layer to convert the model output into a probability distribution, making it easier to intuitively determine the task type.

[0053] Secondly, the number of neurons was determined through experiments using the "controlled variable method": the first hidden layer was tested from 8 to 32 neurons, and the highest accuracy (around 92%) was found when 16 neurons were found, with moderate parameters; the second hidden layer was tested from 4 to 16 neurons, and more than 90% of the key feature information was retained when 8 neurons were found, while reducing the risk of overfitting.

[0054] Third, considering the limited sample size in the scheduling scenario (approximately 1,000 labeled samples initially), the model did not introduce a complex regularization mechanism. Instead, it achieved overfit control through "simplified network structure + batch normalization (BN layer)"—adding a BN layer after the first and second hidden layers to stabilize the standard deviation of the feature distribution in the range of 0.1-0.3, reducing the model's generalization error by about 15%.

[0055] The MLP model in this embodiment is designed with "low computational overhead, high inference accuracy, and easy deployment" as its core design principles. By simplifying the network structure, optimizing parameter configuration, and clarifying the inference process, it adapts to the real-time scheduling requirements of heterogeneous computing clusters. Specific design details and inference logic are as follows: Addressing the characteristics of heterogeneous computing scheduling scenarios, the model design abandons complex deep network architectures, focusing on efficient learning of the core feature of "task-device adaptation." The core design philosophy includes three points: The first is lightweight priority: by controlling the number of network layers and neurons, the total number of model parameters is ≤1000, and the single inference time is ≤1ms, meeting the requirements... The first requirement is real-time "millisecond-level response" for cluster scheduling; the second is targeted feature adaptation: for the semantic characteristics (task features + temporal features + computing power features) of the 10-dimensional input vector, the activation function of the hidden layer and the parameter initialization strategy are optimized to enhance the learning of key feature combinations such as "computational load - parallel capability" and "communication load - device bandwidth"; the third is engineering deployment friendliness: the model is developed using the mainstream framework of PyTorch / TensorFlow, supports export in ONNX format, and can be directly deployed on the CPU node of the cluster scheduling server without relying on dedicated computing resources such as GPU / NPU.

[0056] Regarding model training, with the goal of "rapid convergence with small samples," the training process was designed based on the characteristics of labeled data in the scheduling scenario to ensure that the trained model can be directly deployed and applied. First, regarding the construction of the training dataset for model training: Historical scheduling data from the cluster over the past 3 months was collected, and a total of 1200 valid samples were selected, covering two types of tasks: computationally intensive (e.g., 600 samples of AI inference and matrix operations) and communication-intensive (e.g., 600 samples of data preprocessing and cross-node transmission). The sample labeling method of "automatic labeling + manual verification" was adopted: the type was automatically labeled according to the task execution efficiency (e.g., the execution efficiency of computationally intensive tasks on GPU is ≥ 3 times that of CPU), and then 10% of the samples were verified by engineers, with a labeling accuracy of ≥ 99%. The dataset was divided into a training set (840 samples), a validation set (240 samples), and a test set (120 samples) in a 7:2:1 ratio to ensure that the sample type distribution of each set is consistent (the ratio of computationally intensive to communication-intensive samples is 1:1).

[0057] Secondly, the training parameter configurations are shown in Table 2: Table 2 Training parameter configuration and its basis After training, the performance was validated on the test set. The key metrics are as follows: Task type discrimination accuracy: 92.5% (93% accuracy for computationally intensive tasks and 92% accuracy for communication-intensive tasks); Single-sample inference time: 0.8ms (tested on an Intel Xeon 8375C CPU); Overfitting: 93% accuracy on the training set and 92% accuracy on the validation set, with a difference of ≤1%, indicating excellent generalization ability.

[0058] After the model is trained, it is exported in ONNX format (size ≤ 500KB), deployed on the CPU node of the cluster scheduling server, and encapsulated as an inference interface using Python Flask. The call time is ≤ 1ms, supporting 1000+ concurrent inferences per second, meeting the real-time requirements of cluster multi-task scheduling.

[0059] After model deployment, a lightweight iteration mechanism is designed to adapt to dynamic changes in cluster task types (such as adding new AI training tasks): 1. Collect new scheduling data (approximately 200 records) quarterly to supplement the training set; 2. Perform incremental training based on the original model parameters (training for only 5 epochs) to avoid full retraining; 3. After iteration, verify the model using a validation set (update and deploy if accuracy ≥ 90%) to ensure model adaptation to new scenarios. Through the above design, the shallow MLP model achieves the goals of "high accuracy, low overhead, and easy deployment," and the inference results can directly support the subsequent dynamic priority calculation module, forming a technical closed loop of "feature preprocessing - model inference - scheduling decision."

[0060] S600: Based on the prediction results of the MLP model, match the target device cluster according to preset rules; As mentioned above, the computing device cluster of the heterogeneous computing system includes CPU, GPU, NPU, and FPGA; the N-dimensional feature vector input to the first hidden layer is a ten-dimensional feature vector, including the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptation rate, real-time load of the device, computational complexity index, data transmission requirement index, and AI operator ratio index. The output layer outputs a two-dimensional probability vector, which represents the probability of computationally intensive and the probability of communication-intensive operations, respectively.

[0061] If the probability of the prediction result of the MLP model being computationally intensive is greater than 0.5, then the target device cluster is matched as a GPU or an NPU. These two types of devices have high parallel computing capabilities (GPUs have thousands of CUDA computing cores, and NPUs have AI-specific operators), and are suitable for tasks such as matrix operations and AI inference. If the probability of the prediction result of the MLP model being communication-intensive is greater than 0.5, and the latency requirement data of the current task meets the preset low latency requirement, then the target device cluster is matched as FPGA, which is suitable for low latency requirements such as real-time detection of equipment faults and industrial control signal processing. If the probability of the predicted result of the MLP model being communication-intensive is greater than 0.5, and the latency requirement of the current task does not meet the preset low latency requirement, then the target device cluster is matched as a CPU that supports high-bandwidth data transmission (Intel Xeon supports 400G Ethernet) and is suitable for tasks such as sensor data preprocessing and cross-node data forwarding.

[0062] The model inference process includes: Input preparation: Read the 10-dimensional vector of feature preprocessing, denoted as X, and ensure that the values ​​of each dimension are in the range of [0,1]. If they are outside the range, trigger the reprocessing of task feature data, time series execution data, and indicator feature data. Forward propagation computation: The input layer of the MLP model receives a 10-dimensional vector and passes it to the first hidden layer. In the first hidden layer, the 10-dimensional vector X is multiplied by a 10×16 weight matrix, biased, and then activated by ReLU, outputting a 16-dimensional vector. In the second hidden layer, the 16-dimensional vector is multiplied by a 16×8 weight matrix, biased, and then activated by ReLU, outputting an 8-dimensional vector. In the output layer, the 8-dimensional vector is multiplied by an 8×2 weight matrix, biased, and then activated by ReLU, outputting a 2-dimensional vector Y=[P1,P2], where P1 represents the computationally intensive probability and P2 represents the communication-intensive probability. Due to the characteristics of the Softmax function, P1+P2=1. If P1>0.5, the prediction result of the MLP model is computationally intensive; if P2>0.5, the prediction result of the MLP model is communication-intensive.

[0063] In a further subdivided embodiment, if P2 > 0.5 and the indicator feature data meets the preset low latency requirement (e.g., the low latency performance data is quantized to a value of 0.8 in the range of [0,1]), then the prediction result of the MLP model belongs to the low latency type (communication-intensive branch), and the target device cluster is matched as FPGA; if P2 > 0.5 and the low latency performance data is quantized to a value of less than 0.8 in the range of [0,1], then the target device cluster is matched as CPU.

[0064] S700: According to the load balancing distribution principle, the current task is assigned to the device in the matched target device cluster.

[0065] The output prediction results are used for rule-based node matching according to three fixed rules. After matching the target device clusters (GPU / NPU, CPU, and FPGA clusters) for the current task, this provides input for subsequent dynamic priority calculation. Based on the "task type" output by the MLP model, fixed matching rules are formulated in combination with the core characteristics of the device (without the need for self-attention weight calculation), directly associating "task type → target device cluster". The rules are simple and highly interpretable. After matching the target device cluster, the task is assigned to a specific computing device in the target cluster according to the rule of "lowest load" + "not reaching the concurrency limit": extract the real-time load type data of the device from the time-series execution data of each target device in the target device cluster; and assign the current task to the target device with the lowest real-time load.

[0066] Taking three typical tasks of a smart factory cluster as examples, the inference process and results are fully demonstrated to verify the effectiveness of the model: Example 1: Task A1 - Product Image Classification and Reasoning Task with High Parallel Computing Power Requirements Input vector: Preprocessed ten-dimensional vector X=[0.596, 0.04, 0.09, 0.06, 0.19, 0.96, 0.58, 0.9, 0.2, 0.8], representing the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptability, real-time load of the device, parallel computing capability, low latency capability, and AI adaptability, respectively. Forward propagation: First hidden layer output: [0.32, 0.0, 0.85, 0.41, 0.92, 0.0, 0.56, 0.78, 0.21, 0.0, 0.63, 0.89, 0.0, 0.45, 0.72, 0.18]; Second hidden layer output (example): [0.65, 0.0, 0.82, 0.39, 0.91, 0.0, 0.75, 0.88]; Output layer probability: Y=[0.94, 0.06]; Result determination: P1=0.94>0.5, therefore it is determined to be a "computationally intensive task".

[0067] Based on the matching rules, this is mapped to the GPU / NPU device cluster [GPU1, GPU2, NPU1, NPU2]; Tasks are allocated based on the principle of "lowest current load," eliminating the need for priority sorting, simplifying calculations, and avoiding node overload: The real-time load of the three computing devices (GPU1, GPU2, and NPU1) within the device cluster is collected. The device with the lowest load that has not reached its concurrency limit is selected. For example, if GPU1 has a load of 58% and a concurrency of 1 / 3; GPU2 has a load of 65% and a concurrency of 2 / 3; NPU1 has a load of 70% and a concurrency of 1 / 4; and NPU2 has a load of 10% and a concurrency of 6 / 6, it can be seen that although NPU2 has the lowest real-time load, it has reached its concurrency limit. Therefore, GPU1, which has the second highest load and has not reached its concurrency limit, should be selected as the target device from the remaining computing devices, and the current task should be assigned to GPU1.

[0068] Example 2: Task A2 - Product Image Classification Reasoning Task with High Bandwidth Data Transmission Requirements Input vector: Preprocessed ten-dimensional vector X=[0.61, 0.42, 0.37, 0.33, 0.88, 0.79, 0.76, 0.90, 0.85, 0.81], representing the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptability rate, real-time load of the device, computational complexity index, data transmission requirement index, and AI operator ratio index, respectively. Output layer probability: Y=[0.43, 0.57]; Result determination: P2=0.57>0.5, therefore it is determined to be a "communication-intensive task".

[0069] Based on the matching rules, this is mapped to the CPU device cluster.

[0070] Example 3: Task B1 - Preprocessing of workshop sensor data requiring high bandwidth data transmission Input vector: The preprocessed ten-dimensional vector X = [0.015, 0.49, 0.035, 0.025, 0.8, 0.93, 0.42, 0.3, 0.6, 0.4], representing the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptability rate, real-time load of the device, computational complexity index, data transmission requirement index, and AI operator ratio index, respectively. Output layer probability: Y=[0.04, 0.96]; Result determination: P2=0.96>0.5, therefore it is determined to be a "communication-intensive task".

[0071] Based on the matching rules, this is mapped to the CPU device cluster [CPU1, CPU2, CPU3, CPU4]; For example, if CPU1 has a load of 42% and a concurrency of 1 / 3; CPU2 has a load of 55% and a concurrency of 2 / 3; CPU3 has a load of 66% and a concurrency of 1 / 4; and CPU4 has a load of 30% and a concurrency of 6 / 6, then the current task will be assigned to CPU1.

[0072] Example 4: Task B2 - Workshop Sensor Data Preprocessing Task with High Parallel Computing Power Requirements Input vector: The preprocessed ten-dimensional vector X = [0.32, 0.46, 0.28, 0.21, 0.72, 0.64, 0.81, 0.58, 0.43, 0.39] represents the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptability rate, real-time load of the device, computational complexity index, data transmission requirement index, and AI operator ratio index, respectively. Output layer probability: Y=[0.66, 0.34]; Result determination: P1=0.66>0.5, therefore it is determined to be a "computationally intensive task".

[0073] Based on the matching rules, this is mapped to the GPU / NPU device cluster.

[0074] Example 5: Task C1 - Real-time equipment fault detection task requiring ultra-low latency data processing Input vector: The preprocessed ten-dimensional vector X = [0.025, 0.098, 0.02, 0.015, 0.6, 0.98, 0.55, 0.2, 0.9, 0.3], representing the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptability rate, real-time load of the device, computational complexity index, data transmission requirement index, and AI operator ratio index, respectively. Output layer probability: Y=[0.03, 0.97]; Result determination: P2=0.97>0.5, therefore it is determined to be "communication-intensive task (FPGA low-latency branch)"; Based on the matching rules, this is mapped to the FPGA device cluster [FPGA1, FPGA2]; For example, if FPGA1 has a load of 42% and a concurrency of 1 / 2, and FPGA2 has a load of 55% and a concurrency of 0 / 3, then the current task will be assigned to FPGA1.

[0075] Example 6: Task C2 - Real-time equipment fault detection task with extremely high AI processing requirements Input vector: The preprocessed ten-dimensional vector X = [0.41, 0.37, 0.29, 0.25, 0.84, 0.79, 0.73, 0.52, 0.57, 0.72], representing the task's computational load, communication load, historical average execution time, historical execution time variance, real-time remaining memory of the device, historical device adaptability rate, real-time load of the device, computational complexity index, data transmission requirement index, and AI operator ratio index, respectively. Output layer probability: Y=[0.71, 0.29]; Result determination: P1=0.71>0.5, therefore it is determined as a "computation-intensive task". According to the matching rules, it is thus mapped to a GPU / NPU device cluster or an NPU device cluster.

[0076] In one embodiment of the present invention, a task scheduling server is provided, such as... Figure 2 As shown, it includes the following modules: The task receiving module is configured to receive task requests, including task configuration information and task dependency information. The task parsing module is configured to parse the task configuration information to obtain the task computation amount, data size, input and output data volume, task parallelism, and latency requirements; and to parse the task dependency information to obtain the task communication volume. The task execution log module is configured to allow querying historical execution data for similar tasks; The indicator evaluation module is configured to evaluate the computational complexity indicator, data transmission requirement indicator, and AI operator ratio indicator of the current task based on the parsing results output by the task parsing module and the query results output by the task execution log module, respectively. The feature vector module is configured to construct multi-dimensional feature vectors, which include at least the task computation volume, task communication volume, computational complexity index, data transmission requirement index, and AI operator ratio index, which unify numerical expression and eliminate scale bias. The MLP module is configured to analyze the multidimensional feature vector using a pre-built MLP model to predict the task type of the current task, which includes computationally intensive and communication-intensive tasks. The matching module is configured to match the target device cluster according to preset rules based on the prediction results of the MLP model. The load balancing module is configured to distribute the current task to devices in the matched target device cluster according to the load balancing distribution principle.

[0077] The task scheduling server provided in this embodiment also includes a preprocessing module, which is configured to perform scale bias removal processing on the features to be constructed into a multidimensional feature vector, including: Obtain historical computation volume of similar tasks from the system's task execution log, determine the upper and lower limits of computation volume within a preset time period or preset number of tasks, and perform Min-Max normalization on the current task's computation volume. Obtain historical communication volume of similar tasks from the system's task execution log, determine the upper and lower limits of communication volume within a preset time period or preset number of tasks; perform Min-Max normalization on the task computation volume of the current task. The sum of the task computation, task parallelism, and task communication of the current task is normalized by Min-Max to obtain a computational complexity index that eliminates scale bias. The sum of the data size, input and output data volume, and latency requirements of the current task is normalized using Min-Max to obtain the data transmission requirement index that eliminates scale bias. The sum of the current task's computational load, task parallelism, and historical average execution time is normalized using Min-Max to obtain an AI operator ratio index that eliminates scale bias.

[0078] The task scheduling server provided in this embodiment shares the same inventive concept as the lightweight deep learning-enabled heterogeneous computing system task scheduling method provided in the above embodiments. Specifically, the task receiving module refers to step S100, the task parsing module refers to step S200, the task execution log module refers to step S300, the metric evaluation module refers to step S400, the MLP module refers to step S500, the matching module refers to step S600, and the load balancing module refers to step S700, thereby determining the specific computing node in the heterogeneous computing cluster to which the current task is assigned. The entire content of the lightweight deep learning-enabled heterogeneous computing system task scheduling method embodiment is incorporated into this task scheduling server embodiment by reference.

[0079] In one embodiment of the present invention, a heterogeneous computing system is provided, such as... Figure 2 As shown, the system includes a scheduling server and various types of computing device clusters. The scheduling server uses the task scheduling method described above to assign tasks to devices in the corresponding device clusters.

[0080] The heterogeneous computing system provided in this embodiment and the lightweight deep learning-enabled heterogeneous computing system task scheduling method provided in the above embodiment belong to the same inventive concept. Hereinafter, all contents of the embodiment of the lightweight deep learning-enabled heterogeneous computing system task scheduling method are incorporated into this heterogeneous computing system embodiment by reference.

[0081] It should be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0082] The above description is only a specific embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A lightweight deep learning-enabled task scheduling method for heterogeneous computing systems, characterized in that, Includes the following steps: Receive task requests, including task configuration information and task dependency information; The task configuration information is parsed to obtain the task computation volume, data size, input and output data volume, task parallelism, and latency requirements; the task dependency information is parsed to obtain the task communication volume. And retrieve historical execution data of similar tasks from the system's task execution log; Based on the parsing results of the task configuration information and task dependency information, as well as historical execution data, the computational complexity index, data transmission requirement index, and AI operator ratio index of the current task are evaluated respectively. Construct a multidimensional feature vector, which should at least include the task computation volume, task communication volume, computational complexity index, data transmission requirement index, and AI operator ratio index, all of which should be expressed in a unified numerical manner and have scale bias eliminated. The multidimensional feature vector is input into a pre-built MLP model to predict the task type of the current task, which includes computationally intensive and communication-intensive tasks. Based on the prediction results of the MLP model, the target device cluster is matched according to preset rules; According to the load balancing principle, the current task is assigned to the device in the matched target device cluster.

2. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 1, characterized in that, The following methods can be used to obtain a unified numerical representation and eliminate scale bias in terms of task computation and / or task communication: Obtain historical execution data of similar tasks from the system's task execution logs, including historical data on computational and / or communication volume; Determine the range of historical data for a preset time period or a preset number of tasks; Min-Max normalization is applied to the computational and / or communication load of the current task: D norm =(D cur -D min ) / (D max -D min ), where D norm To standardize numerical representation and eliminate scaling bias in data, D cur D represents the computational or communication volume of the current task. min D represents the lower limit of the corresponding historical data range. max This represents the upper limit of the corresponding historical data range.

3. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 1, characterized in that, A computational complexity index that achieves a unified numerical representation and eliminates scale bias can be obtained through any of the following methods: Method 1: Obtain historical execution data for similar tasks, including three types of data: historical computational load, historical parallelism, and historical communication load; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the current task's computational load, parallelism, and communication load, and use the normalization result as the computational complexity index. Method 2: Obtain the minimum and maximum reference values ​​for computational load, parallelism, and communication load preset by the system; The sum of the task's computational complexity, parallelism, and communication complexity is normalized using Min-Max, and the normalization result is used as the computational complexity index.

4. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 1, characterized in that, A data transmission requirement index that achieves a unified numerical representation and eliminates scale bias can be obtained through any of the following methods: Method 1: Obtain historical execution data for similar tasks, including three types of data: historical data scale, historical input / output data volume, and historical latency requirements; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks; perform Min-Max normalization on the sum of the data scale, input / output data volume, and latency requirements of the current task, and use the normalization result as the data transmission requirement indicator; Method 2: Obtain the minimum and maximum reference values ​​for the system's preset data scale, input / output data volume, and delay requirements; perform Min-Max normalization on the sum of the current task's data scale, input / output data volume, and delay requirements, and use the normalization result as the data transmission requirement indicator.

5. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 1, characterized in that, The AI ​​operator scaling index with a unified numerical expression and scale bias elimination can be obtained through any of the following methods: Method 1: Obtain historical execution data for similar tasks, including three types of data: historical computational load, historical parallelism, and historical execution time; determine the historical data range of each of the above three types of data within a preset time period or preset number of tasks, and calculate the average value of the historical execution time; perform Min-Max normalization on the sum of the current task's task computational load, task parallelism, and historical execution time average, and use the normalization result as the AI ​​operator ratio index. Method 2: Obtain the minimum and maximum reference values ​​for computational load, parallelism, and execution time preset by the system; Calculate the average historical execution time of similar tasks within a preset time period or a preset number of tasks; perform Min-Max normalization on the sum of the task computation, task parallelism, and historical execution time average of the current task, and use the normalization result as the AI ​​operator ratio index.

6. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 1, characterized in that, The multidimensional feature vector also includes feature data that provides a unified numerical expression for the data scale, input and output data volume, task parallelism, and latency requirements of the current task, and eliminates scale bias. And / or, the multidimensional feature vector further includes time-series execution data, which includes one or more of the following types: Historical average execution time is defined as the average execution time of the last i similar tasks obtained from the system's task execution logs. Historical execution time variance is defined as the variance calculated based on the execution times of the j most recent similar tasks in the system's task execution log. The device's real-time remaining memory is the available memory of the current computing device obtained through the system's device resource monitoring tools; Historical device adaptation rate is defined as the proportion of successful executions of a computing device to the total number of executions, obtained by statistical analysis of the system's device scheduling logs. Real-time device load is defined as the proportion of time a computing device spends executing non-idle tasks out of the total time, as obtained through the system's device resource monitoring tools.

7. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 6, characterized in that, The process of eliminating scale bias in the time-series execution data includes: The historical average execution time, historical execution time variance, and real-time remaining memory of the device are each processed using their respective historical data and then subjected to Min-Max normalization. The historical device adaptation rate and real-time device load are uniformly expressed as decimals corresponding to percentage characteristics.

8. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 1, characterized in that, The MLP model is constructed with the following configuration: An input layer is configured to receive the multidimensional feature vector and perform format validation. The first hidden layer is configured to extract the correlation information between a single feature in the multidimensional feature vector and the performance of the computing device. The second hidden layer is configured to extract the correlation information between multiple feature combinations in the multidimensional feature vector and the performance of the computing device. The output layer is configured to output the probability distributions corresponding to various task types.

9. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 8, characterized in that, The MLP model is trained through the following steps: Constructing a training dataset includes: collecting historical scheduling data from a heterogeneous computing system cluster; selecting effective samples based on a balanced coverage of both compute-intensive and communication-intensive task types, wherein the historical scheduling data of the effective samples includes historical task feature data and historical time-series execution data; automatically labeling the effective samples as compute-intensive or communication-intensive based on the task execution efficiency in the historical time-series execution data, and sampling and verifying the results of the automatic task type labeling; dividing the verified labeled effective samples into a training set, a validation set, and a test set, with a balanced number of samples of each task type in each set; Configure training parameters, including: setting the optimizer to Adam, setting the learning rate, batch size, and training epochs, and setting the loss function to the cross-entropy loss function; After each training epoch of training the model using the training set, the model's performance on the validation set is calculated. The training effect of the model is verified on the test set after training, and the generalization ability of the model is evaluated.

10. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to claim 8, characterized in that, The number of neurons in the first hidden layer is configured to be 16. The N-dimensional feature vector input to the first hidden layer is multiplied by the N×16 weight matrix, and after adding a bias, it is activated by the ReLU function, and then the first hidden layer outputs a 16-dimensional vector. The second hidden layer has 8 neurons. The 16-dimensional vector output by the first hidden layer is multiplied by a 16×8 weight matrix, biased, and then activated by the ReLU function. The second hidden layer then outputs an 8-dimensional vector. The number of neurons in the output layer is configured to be 2. The 8-dimensional vector output by the second hidden layer is multiplied by an 8×M weight matrix, and after adding a bias, it is activated by the Softmax function. Then, the output layer outputs an M-dimensional probability vector, where M is the number of types of the task.

11. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to any one of claims 1 to 10, characterized in that, The output layer of the MLP model outputs a two-dimensional probability vector, which represents the probability of computationally intensive and the probability of communication-intensive operations, respectively. The computing device cluster of the heterogeneous computing system includes CPU, GPU, NPU, and FPGA; Matching target device clusters according to preset rules includes: If the probability of the MLP model predicting a computationally intensive task is greater than 0.5, then the target device cluster is matched as a GPU or NPU. If the probability of the MLP model predicting a communication-intensive task is greater than 0.5, and the latency requirement data of the current task meets the preset low latency requirement, then the target device cluster is matched as FPGA. If the probability of the MLP model predicting a communication-intensive task is greater than 0.5, and the latency requirement data of the current task does not meet the preset low latency requirement, then the target device cluster is matched as CPU.

12. The lightweight deep learning-enabled heterogeneous computing system task scheduling method according to any one of claims 1 to 10, characterized in that, After matching the target device cluster, real-time load data and device concurrency data are extracted from the time-series execution data of each target device in the target device cluster; Assign the current task to the target device with the lowest real-time load and that has not reached its concurrency limit.

13. A task scheduling server, characterized in that, Includes the following modules: The task receiving module is configured to receive task requests, including task configuration information and task dependency information. The task parsing module is configured to parse the task configuration information to obtain the task computation amount, data size, input and output data volume, task parallelism, and latency requirements; and to parse the task dependency information to obtain the task communication volume. The task execution log module is configured to allow querying historical execution data for similar tasks; The indicator evaluation module is configured to evaluate the computational complexity indicator, data transmission requirement indicator, and AI operator ratio indicator of the current task based on the parsing results output by the task parsing module and the query results output by the task execution log module, respectively. The feature vector module is configured to construct multi-dimensional feature vectors, which include at least the task computation volume, task communication volume, computational complexity index, data transmission requirement index, and AI operator ratio index, which unify numerical expression and eliminate scale bias. The MLP module is configured to analyze the multidimensional feature vector using a pre-built MLP model to predict the task type of the current task, which includes computationally intensive and communication-intensive tasks. The matching module is configured to match the target device cluster according to preset rules based on the prediction results of the MLP model. The load balancing module is configured to distribute the current task to devices in the matched target device cluster according to the load balancing distribution principle.

14. The task scheduling server according to claim 13, characterized in that, It also includes a preprocessing module, which is configured to perform scale-bias-free processing on the features to be used to construct the multidimensional feature vector, including: Obtain historical computation volume of similar tasks from the system's task execution log, determine the upper and lower limits of computation volume within a preset time period or preset number of tasks, and perform Min-Max normalization on the current task's computation volume. Obtain historical communication volume of similar tasks from the system's task execution log, determine the upper and lower limits of communication volume within a preset time period or preset number of tasks; perform Min-Max normalization on the task computation volume of the current task. The sum of the task computation, task parallelism, and task communication of the current task is normalized by Min-Max to obtain a computational complexity index that eliminates scale bias. The sum of the data size, input and output data volume, and latency requirements of the current task is normalized using Min-Max to obtain the data transmission requirement index that eliminates scale bias. The sum of the current task's computational load, task parallelism, and historical average execution time is normalized using Min-Max to obtain an AI operator ratio index that eliminates scale bias.

15. A heterogeneous computing system, characterized in that, It includes a scheduling server and various types of computing device clusters, wherein the scheduling server uses the task scheduling method as described in any one of claims 1 to 12 to assign tasks to devices in the corresponding device cluster.

Images