Computing power resource allocation method, system and product based on multi-dimensional dynamic evaluation

Abstract

The invention relates to the technical field of computing power resource allocation, and particularly discloses a computing power resource allocation method and system based on multi-dimensional dynamic evaluation and a product. The method comprises the steps of obtaining evaluation index data of a to-be-scheduled task in multiple dimensions; dynamically configuring a weight value of each evaluation index according to a task attribute and a system state; the evaluation index data is fuzzified by using a preset membership function, a fuzzy evaluation matrix is constructed in combination with the weight value, and comprehensive calculation is performed through a fuzzy inference rule to obtain fuzzy comprehensive evaluation data of the task, so that an accurate evaluation result is generated; modeling a task execution process by adopting a multi-layer perceptron model, and predicting the execution performance of the task; and based on the evaluation result and the prediction result, dynamically selecting a proper strategy from a plurality of predefined task scheduling strategies, and scheduling the tasks to optimize computing power resource allocation. According to the method, the resource utilization efficiency is remarkably improved through multi-dimensional evaluation and a dynamic scheduling mechanism.

Description

Technical Field

[0001] This invention relates to the field of computing resource allocation technology, and in particular to a computing resource allocation method, system and product based on multi-dimensional dynamic evaluation. Background Technology

[0002] With the rapid development of technologies such as cloud computing, big data analytics, and artificial intelligence, the efficient allocation of computing resources has become a core issue in distributed computing systems. Traditional methods of allocating computing resources typically use a single performance metric, such as computational performance, as the evaluation basis. While this approach can meet basic computing needs in certain scenarios, its limitations become increasingly apparent as task types and system complexity increase.

[0003] In existing technologies, computing resource allocation primarily focuses on computing performance metrics. For example, tasks are assigned to higher-performance nodes by monitoring the CPU utilization or floating-point operation capability of computing nodes. However, this single-dimensional evaluation method has significant drawbacks. First, it has a narrow perspective, focusing only on computing performance while ignoring other key factors such as storage capacity, network bandwidth, and energy consumption. For instance, a computing node may have a high-performance CPU, but if its storage capacity is insufficient, for tasks requiring the processing of large amounts of data, the data read speed cannot match the computing speed, resulting in low task execution efficiency and a performance bottleneck.

[0004] Secondly, existing technologies are poorly adapted to the diversity of tasks. Different types of tasks have significantly different requirements for computing resources. For example, compute-intensive tasks mainly rely on computing performance, while I / O-intensive tasks rely more on storage read / write speed and network bandwidth. Traditional methods typically cannot dynamically adjust resource allocation strategies based on task characteristics and system status. For instance, when handling tasks with frequent file read / write operations, even if high-performance computing nodes are allocated, task execution efficiency will still be low if storage or network resources are insufficient. This single-dimensional allocation approach cannot effectively meet the needs of diverse tasks, leading to low resource utilization and prolonged task execution time.

[0005] Furthermore, existing technologies rarely consider the dynamic changes in task priority and system operating status when allocating resources. For example, high-priority tasks may fail to complete in a timely manner due to improper resource allocation, affecting business efficiency. At the same time, energy consumption, as an increasingly important consideration in distributed systems, is often overlooked in traditional methods, leading to the overuse of energy-intensive nodes and increasing system operating costs.

[0006] In summary, the shortcomings of existing computing resource allocation methods in terms of multi-dimensional evaluation, task adaptability, and dynamic adjustment limit their application effectiveness in complex computing environments. Therefore, there is an urgent need for a computing resource allocation method that can comprehensively consider multi-dimensional indicators and dynamically adapt to task requirements and system states to improve resource utilization efficiency and task execution performance. Summary of the Invention

[0007] The purpose of this invention is to address the shortcomings of existing technologies by proposing a computing resource allocation method, system, and product based on multi-dimensional dynamic evaluation. To achieve the above objective, the embodiments of this invention employ the following technical solutions:

[0008] In a first aspect, embodiments of the present invention propose a method for allocating computing resources based on multi-dimensional dynamic evaluation, comprising the following steps:

[0009] Obtain evaluation metrics data for the tasks to be scheduled across multiple dimensions;

[0010] The weight values ​​of the evaluation index data are dynamically configured based on task attributes and system status.

[0011] The evaluation index data is fuzzified according to the preset membership function, and a fuzzy evaluation matrix is ​​constructed using the weight values; the fuzzy evaluation matrix is ​​comprehensively calculated according to the fuzzy inference rules to obtain the fuzzy comprehensive evaluation data of the task; and the evaluation result of the task is obtained based on the fuzzy comprehensive evaluation data.

[0012] The execution process of the task is modeled using a multilayer perceptron model to obtain prediction results for the task.

[0013] Based on the evaluation results and the prediction results, a task scheduling strategy is selected from a variety of predefined task scheduling strategies to schedule the task and allocate computing resources.

[0014] Preferably, the evaluation index data across the multiple dimensions includes: task priority, the amount of computing resources required for the task, the task deadline, and the current system resource utilization rate.

[0015] Preferably, the step of dynamically configuring the weight values ​​of the evaluation index data according to task attributes and system status includes:

[0016] The system is dynamically adjusted based on changes in task load and system performance, so that different weight values ​​are assigned to different evaluation metrics under different operating conditions.

[0017] Preferably, the multilayer perceptron model is trained based on historical task data and is used to predict the execution time of the task according to the evaluation index data. The predicted execution time is used to guide the allocation of computing resources.

[0018] Preferably, the predefined multiple task scheduling strategies include a priority scheduling strategy and a load balancing scheduling strategy. When the evaluation result of the task indicates that the urgency of the task exceeds a predetermined threshold, the priority scheduling strategy is selected; otherwise, the load balancing scheduling strategy is selected.

[0019] Preferably, when there are multiple tasks to be scheduled, the multiple tasks are sorted according to the evaluation results of each task, and the tasks are scheduled in sequence according to the sorting priority to allocate computing resources.

[0020] Preferably, the method further includes adjusting the weight values ​​of the evaluation index data based on the difference between the actual execution result of the task and the evaluation result after the task is completed, so as to optimize the evaluation process of subsequent tasks.

[0021] Preferably, the multilayer perceptron model is periodically updated and trained based on the latest actual execution results of completed tasks to improve the accuracy of the multilayer perceptron model in predicting subsequent tasks.

[0022] Secondly, embodiments of the present invention propose a computing resource allocation system based on multi-dimensional dynamic evaluation for executing the computing resource allocation method based on multi-dimensional dynamic evaluation proposed in the foregoing embodiments, comprising an evaluation module, a weight dynamic configuration module, a modeling module, and a scheduling module:

[0023] The evaluation module is used to acquire evaluation index data of the task to be scheduled in multiple dimensions, fuzzify the evaluation index data according to a preset membership function, and construct a fuzzy evaluation matrix using the weight values; perform comprehensive calculation on the fuzzy evaluation matrix according to fuzzy inference rules to obtain the fuzzy comprehensive evaluation data of the task; and obtain the evaluation result of the task based on the fuzzy comprehensive evaluation data.

[0024] The weight dynamic configuration module is used to dynamically configure the weight values ​​of the evaluation index data according to the task attributes and system status;

[0025] The modeling module is used to model the execution process of the task using a multilayer perceptron model to obtain a prediction result for the task.

[0026] The scheduling module is used to select a task scheduling strategy from a variety of predefined task scheduling strategies based on the evaluation results and the prediction results, and to schedule the task to allocate computing resources.

[0027] Thirdly, embodiments of the present invention provide a computer program product, preferably comprising a non-transitory computer-readable storage medium storing computer-executable instructions, wherein when the instructions are executed by a processor, the processor performs the computing resource allocation method based on multi-dimensional dynamic evaluation proposed in the foregoing embodiments.

[0028] Beneficial effects:

[0029] By acquiring multi-dimensional evaluation index data and dynamically configuring weight values ​​based on task attributes and system status, the evaluation process comprehensively reflects task requirements and system resource status, thereby improving the targeting and efficiency of resource allocation. Secondly, a fuzzy comprehensive evaluation method is adopted. By pre-setting membership functions to fuzzify the index data and combining them with weight values ​​to construct a fuzzy evaluation matrix, the comprehensive performance of computing nodes can be accurately quantified. Compared with traditional evaluation methods based on fixed thresholds, the fuzzy evaluation method can better handle the complexity and uncertainty of index data, thus generating more reliable task evaluation results. Furthermore, a multilayer perceptron model is used to model the task execution process, predicting task execution time based on historical data, providing a basis for resource allocation decisions. Compared with traditional methods that rely on static rules or experience for allocation, the prediction model can dynamically adapt to different task types, significantly improving allocation efficiency. By combining evaluation and prediction results, a suitable strategy is dynamically selected from various task scheduling strategies, such as priority scheduling or load balancing scheduling, further optimizing resource utilization and task execution efficiency. Attached Figure Description

[0030] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings:

[0031] Figure 1 This is a flowchart illustrating a computing resource allocation method based on multi-dimensional dynamic evaluation, provided in an embodiment of the present invention.

[0032] Figure 2 This is a schematic diagram of the structure of a computing resource allocation system based on multi-dimensional dynamic evaluation, provided in an embodiment of the present invention. Detailed Implementation

[0033] Embodiments of the present invention are described in detail below, examples of which are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention. It should be noted that similar reference numerals and letters in the following drawings denote similar items; therefore, once an item is defined in one drawing, it does not need to be further defined and explained in subsequent drawings.

[0034] Example 1, the first aspect, please refer to Figure 1 This invention proposes a computing resource allocation method based on multi-dimensional dynamic evaluation, applicable to a computing resource allocation system based on multi-dimensional dynamic evaluation. The system can be, but is not limited to, executed by computer devices with certain computing resources, such as personal computers (PCs, which are multi-purpose computers suitable for personal use in terms of size, price, and performance; desktops, laptops, mini-laptops, tablets, and ultrabooks all fall under this category), smartphones, personal digital assistants (PADs), or platform servers. This embodiment provides a computing resource allocation method based on multi-dimensional dynamic evaluation, aiming to solve the problems of narrow single-dimensional evaluation perspective and poor adaptability to task diversity in traditional computing resource allocation methods.

[0035] This method achieves dynamic optimization allocation of computing resources through a multi-dimensional evaluation index system, dynamic weight configuration, fuzzy comprehensive evaluation, and multilayer perceptron (MLP) neural network prediction, combined with task scheduling strategies. The specific implementation steps of this embodiment are described in detail below, covering steps S1 to S5 listed in claim 1:

[0036] Step S1: Obtain evaluation index data of the task to be scheduled in multiple dimensions;

[0037] In this embodiment, the evaluation metrics data for the tasks to be scheduled are obtained from multiple dimensions, including computing performance, storage capacity, network bandwidth, energy consumption, and task priority. Specifically, computing performance metrics include CPU utilization (range 0% to 100%), multithreaded processing capability (measured by thread concurrency and thread switching overhead), and vectorized computation capability; storage capacity metrics include disk sequential read / write speed, random read / write speed, storage capacity availability (ratio of remaining storage space to total storage space), and cache hit rate; network bandwidth metrics include network interface bandwidth capacity, network latency, and packet loss rate; energy consumption metrics include energy consumption of CPU, memory, disk, and network devices, as well as the energy consumption to performance ratio; and task priority metrics are divided into high, medium, and low levels based on the urgency of the task (measured by deadline requirements) and importance (measured by the degree of impact on business).

[0038] For example, for a distributed deep learning training task, the system uses monitoring tools (such as the `top` command on Linux or dedicated resource monitoring software) to collect real-time data on the current computing node, including CPU utilization (85%), thread concurrency (16), disk sequential read / write speed (500MB / s), network latency (2ms), packet loss rate (0.1%), energy consumption (0.5 FLOPS / W per watt of computing power), and task priority (high, deadline 2 hours). This data is collected and stored as structured data through the system interface for use in subsequent steps.

[0039] Step S2: Dynamically configure the weight values ​​of the evaluation index data according to the task attributes and system status;

[0040] The weight values ​​of each evaluation indicator are dynamically determined based on the task type, priority, and current system resource utilization. In this embodiment, task types are categorized into compute-intensive (e.g., scientific computing), I / O-intensive (e.g., big data analytics), and hybrid (e.g., distributed training). System status includes the current resource utilization of computing nodes (e.g., CPU utilization, memory utilization) and network load.

[0041] Taking a distributed deep learning training task as an example, this task has high requirements for network bandwidth and computing performance, while the requirements for storage capacity are relatively low. For instance, the system assigns a weight of 0.4 to the computing performance metric (0.25 for multithreaded processing capability and 0.15 for vectorization capability), 0.3 to the network bandwidth metric (0.2 for network latency and 0.1 for bandwidth capacity), 0.2 to the storage capacity metric (0.15 for sequential read / write speed and 0.05 for storage availability), 0.1 to the energy consumption metric, and 0.2 to the task priority metric (with a weight coefficient of 1.5 for high-priority tasks). These weight values ​​are generated through a predefined rule table, which is established based on historical task execution data and system performance analysis, and dynamically adjusted according to the current system load. For example, when the system detects network congestion, the weight of network latency will be dynamically increased to 0.25 to prioritize the allocation of nodes with better network performance.

[0042] The specific implementation of weight configuration is accomplished through a dynamic weight configuration module. This module queries the rule table based on task attributes (extracted from the task description file) and system status (obtained through real-time monitoring), outputs the weight vector of each indicator, such as `[0.4,0.3,0.2,0.1,0.2]`, and stores it as input for subsequent fuzzy evaluation.

[0043] Step S3: Fuzzify the evaluation index data according to the preset membership function, and construct a fuzzy evaluation matrix using the weight values; perform comprehensive calculation on the fuzzy evaluation matrix according to the fuzzy inference rules to obtain the fuzzy comprehensive evaluation data of the task; and obtain the evaluation result of the task based on the fuzzy comprehensive evaluation data.

[0044] In this step, the data for each evaluation metric is first fuzzified according to a predefined membership function. Taking CPU utilization as an example, its value ranges from 0% to 100%, divided into three fuzzy subsets: "Low" (0%–30%), "Medium" (30%–70%), and "High" (70%–100%). A triangular membership function is used; for example, for a CPU utilization of 85%, the membership degree is 0.9 for the "High" subset, 0.1 for the "Medium" subset, and 0 for the "Low" subset. Other metrics, such as network latency and storage read / write speed, are also fuzzified based on predefined membership functions.

[0045] Subsequently, using the weight values ​​`[0.4,0.3,0.2,0.1,0.2]` determined in S2 and the membership degrees of each indicator, a fuzzy evaluation matrix is ​​constructed. Assume the membership degree matrix obtained after fuzzification of the evaluation indicator data for a certain computing node is as follows:

[0046] R = [

[0047] [0.1,0.8,0.1], / / Computational performance (low, medium, high)

[0048] [0.2,0.7,0.1], / / Network bandwidth

[0049] [0.3,0.6,0.1], / / Storage capacity

[0050] [0.4,0.5,0.1], / / Energy consumption

[0051] [0.0, 0.2, 0.8] / / Task priority ]

[0053] Fuzzy operations are performed on the fuzzy evaluation matrix and weight vector, and a weighted average method is used to calculate the comprehensive evaluation score.

[0054] B = R * W = [b1, b2, b3]

[0055] Where `W` is the weight vector `[0.4,0.3,0.2,0.1,0.2]`, and `b1,b2,b3` represent the membership degrees of the comprehensive evaluation results belonging to "low", "medium", and "high" performance, respectively. The subset with the largest membership degree is selected as the evaluation result based on the principle of maximum membership degree. For example, if `B = [0.15,0.65,0.20]`, then the performance evaluation of this computing node is "medium".

[0056] Step S4: Use a multilayer perceptron model to model the execution process of the task and obtain the prediction results for the task.

[0057] This step uses a multilayer perceptron (MLP) neural network to predict the task's execution time to guide computing resource allocation. The MLP model takes as input the evaluation metrics data obtained in S1 (such as CPU utilization, thread concurrency, etc.) and outputs the predicted execution time of the task. The model structure includes 5 input neurons (corresponding to 5 evaluation metrics), 2 hidden layers (10 neurons per layer), and 1 output neuron (predicting execution time). The ReLU activation function is used, and the output layer uses a linear activation function.

[0058] The model is trained on historical task data, which includes past task metrics and actual execution times. For example, a historical data sample might be `(x1,x2,x3,x4,x5,y)`, where `x1-x5` are the evaluation metrics and `y` is the actual execution time. The training process uses a cross-entropy loss function and the Adam optimizer, with a learning rate of 0.001, a batch size of 32, and 100 epochs. After training, the model performs forward propagation on the current task's metrics data and outputs the predicted execution time. For example, for the distributed deep learning task described above, after inputting the metrics data, the MLP predicts its execution time to be 1.5 hours.

[0059] Step S5: Based on the evaluation and prediction results, select a task scheduling strategy from a variety of predefined task scheduling strategies to schedule tasks and allocate computing resources.

[0060] Based on the evaluation results of S3 (compute node performance level) and the prediction results of S4 (execution time), the system selects one of two scheduling strategies: priority scheduling and load balancing scheduling. If the S3 evaluation results show that the task priority is "high" and the urgency exceeds a predetermined threshold (e.g., the deadline is less than 2 hours), the priority scheduling strategy is selected, and the task is assigned to the compute node with the highest overall performance; otherwise, the load balancing scheduling strategy is selected, and the task is assigned to the node with the lowest current load to optimize resource utilization.

[0061] In this embodiment, the distributed deep learning task has a "high" priority, the S3 evaluation result is "medium," the S4 predicted execution time is 1.5 hours, and the deadline is 2 hours, meeting the priority scheduling conditions. Therefore, the system selects the computing node with the highest performance level (such as a node with low CPU utilization and low network latency) to allocate the task. The scheduling process is implemented through a task scheduler, which sorts nodes according to their performance and prioritizes allocating resources to high-priority tasks.

[0062] Through the steps described above, this embodiment achieves multi-dimensional dynamic evaluation and computing resource allocation, overcoming the limitations of traditional single-dimensional evaluation methods. Dynamic weight configuration adapts to task diversity and system state changes, fuzzy comprehensive evaluation improves the accuracy of evaluation, and MLP prediction optimizes resource allocation efficiency.

[0063] Example 2, in a second aspect, builds upon Example 1 above by further optimizing the computing resource allocation method based on multi-dimensional dynamic evaluation. It provides a more specific implementation by combining an evaluation index system, a dynamic evaluation algorithm, and a task allocation strategy. Through the selection of multi-dimensional evaluation indicators, dynamic weight adjustment, training and updating of the multilayer perceptron (MLP) model, selection and sorting of task scheduling strategies, and a dynamic feedback mechanism for weight optimization, more efficient computing resource allocation is achieved.

[0064] Step S1: Obtain evaluation index data of the task to be scheduled in multiple dimensions;

[0065] Similar to Example 1, this example obtains evaluation index data of the task to be scheduled across multiple dimensions through a system interface. Preferably, the evaluation index data includes task priority, the amount of computing resources required by the task, the task deadline, and the current system resource utilization rate. These indicators directly correspond to task priority (high, medium, and low levels), computing performance (measured by the amount of computing resources required), task urgency (measured by the deadline), and system status (measured by resource utilization rate). In addition, other relevant indicators can also be included, such as multi-threaded processing capability (thread concurrency, thread switching overhead) in computing performance, sequential read / write speed and random read / write speed in storage capacity, network latency and packet loss rate in network bandwidth, and the energy consumption to performance ratio in energy consumption.

[0066] In this embodiment, it is assumed that the task to be scheduled is a big data analysis task. The system collects the following metrics: task priority is "medium" (weight coefficient 1.0), required computing resources are 10 TFLOPS, deadline is 4 hours, and current system resource utilization (including CPU utilization 80%, memory utilization 70%, and network bandwidth utilization 60%). Additional metrics collected include: disk sequential read / write speed of 600 MB / s, random read / write speed of 200 MB / s, network latency of 3 ms, packet loss rate of 0.2%, and energy consumption to performance ratio of 0.4 FLOPS / W. This data is collected using real-time monitoring tools (such as Prometheus or custom monitoring scripts) and stored in structured JSON format for subsequent processing.

[0067] Step S2: Dynamically configure the weight values ​​of the evaluation index data according to the task attributes and system status;

[0068] Preferably, this step dynamically adjusts the weight values ​​of the evaluation indicator data based on changes in task load and system performance to adapt to the varying degrees of importance of the indicators under different operating conditions. The weight values ​​are dynamically configured based on task type (e.g., compute-intensive, I / O-intensive) and system status (e.g., resource utilization, network congestion). For example, for big data analytics tasks, storage capacity indicators (e.g., sequential read / write speed) have a higher weight, while for distributed deep learning tasks, network bandwidth indicators (e.g., latency) have a higher weight.

[0069] In its implementation, the system maintains a dynamic weight rule table, generated based on historical task execution data and system performance analysis. For example, the weight configuration for a big data analysis task is as follows: task priority weight 0.2, required computing resources weight 0.25, task deadline weight 0.15, system resource utilization weight 0.2, storage capacity indicator (sequential read / write speed) weight 0.4, network bandwidth indicator (latency) weight 0.15, and energy consumption indicator weight 0.1. The weight adjustment algorithm dynamically updates according to the current system state. For example, when the system detects storage resource scarcity (storage availability below 20%), the weight of sequential read / write speed is increased to 0.45, and the task priority weight is decreased to 0.15 to prioritize meeting storage needs. The weight vector is calculated by the dynamic weight configuration module, outputting `[0.2,0.25,0.15,0.2,0.4,0.15,0.1]`, which is then passed to subsequent steps.

[0070] Step S3: Fuzzify the evaluation index data according to the preset membership function, and construct a fuzzy evaluation matrix using the weight values; perform comprehensive calculation on the fuzzy evaluation matrix according to the fuzzy inference rules to obtain the fuzzy comprehensive evaluation data of the task; and obtain the evaluation result of the task based on the fuzzy comprehensive evaluation data.

[0071] This step is the same as in Example 1. The evaluation index data is fuzzified using a preset membership function, and a fuzzy evaluation matrix is ​​constructed using the weight values ​​determined in S2. The fuzzy comprehensive evaluation score of the task is calculated, and the final evaluation result is obtained. Preferably, a triangular membership function is used, and the index, such as system resource utilization, is divided into three fuzzy subsets: "low" (0%–30%), "medium" (30%–70%), and "high" (70%–100%). For example, the membership degree of the current CPU utilization of 80% is "high" 0.8, "medium" 0.2, and "low" 0.0; the membership degree of the sequential read / write speed of 600MB / s is "high" 0.7, "medium" 0.3, and "low" 0.0.

[0072] The fuzzy evaluation matrix `R` is constructed based on the membership degrees of all indicators, combined with the weight vector.

[0073] `W=[0.2,0.25,0.15,0.2,0.4,0.15,0.1]`

[0074] Fuzzy computation is performed to obtain a comprehensive evaluation score `B`. For example, if `B = [0.2, 0.6, 0.2]`, the evaluation result is "Medium". This step ensures that the evaluation result reflects the matching degree between task requirements and system status, providing a basis for task scheduling.

[0075] Step S4: Use a multilayer perceptron model to model the execution process of the task and obtain the prediction results for the task.

[0076] Preferably, the MLP model is trained based on historical task data and is used to predict the execution time of tasks based on evaluation metric data. The prediction results guide the allocation of computing resources. In this embodiment, the MLP model structure is as follows: an input layer with 7 neurons (corresponding to task priority, computing resource quantity, deadline, system resource utilization, storage read / write speed, network latency, and energy efficiency ratio), 2 hidden layers (12 neurons per layer), and an output layer with 1 neuron (predicting execution time). The model uses the ReLU activation function, the output layer uses a linear activation function, the loss function is mean squared error (MSE), the optimizer is Adam, and the learning rate is 0.001.

[0077] For example, the training data contains 10,000 historical task records, each including metric data and actual execution time. The data is divided into training and validation sets in an 8:2 ratio, trained for 100 epochs, and uses an early stopping mechanism to prevent overfitting. For example, for a big data analysis task, after inputting the metric data, the MLP predicts an execution time of 3.2 hours. Combined with the evaluation result of S3 (“medium”), this provides a scheduling basis for S5.

[0078] Step S5: Based on the evaluation and prediction results, select a task scheduling strategy from a variety of predefined task scheduling strategies to schedule tasks and allocate computing resources.

[0079] Preferably, the predefined task scheduling strategies include priority scheduling and load balancing scheduling. When the evaluation results of a task indicate that its urgency exceeds a predetermined threshold (e.g., a deadline of less than 3 hours), the priority scheduling strategy is selected; otherwise, the load balancing scheduling strategy is selected. For a big data analysis task with a deadline of 4 hours, which does not exceed the threshold, the load balancing scheduling strategy is selected, allocating the task to the computing node with the lowest current resource utilization (e.g., a node with 50% CPU utilization and 80% storage availability).

[0080] Preferably, when there are multiple tasks to be scheduled, the system sorts the tasks according to the evaluation results of S3. For example, if there are three tasks with evaluation scores of 0.6 (medium), 0.8 (high), and 0.4 (low), they are sorted by score as Task 2, Task 1, and Task 3, and resources are allocated accordingly. The priority scheduling strategy prioritizes allocating high-scoring tasks to the best-performing node, while the load balancing strategy optimizes overall resource utilization.

[0081] Preferably, after the task is completed, the weight values ​​are adjusted based on the difference between the actual execution result and the S3 evaluation result. For example, if the actual execution time of the big data analysis task is 3.5 hours, while the prediction is 3.2 hours, it indicates that the impact of storage read / write speed is underestimated. The system will increase the weight of sequential read / write speed from 0.4 to 0.42, and decrease the weight of task priority from 0.2 to 0.18. The weight adjustment is achieved through the gradient descent algorithm to minimize the prediction error.

[0082] Preferably, the MLP model training is updated periodically (e.g., every 1000 tasks or weekly) based on the latest actual execution results of completed tasks. New task data is added to the training set, and the model is retrained to improve prediction accuracy.

[0083] This embodiment achieves efficient allocation of computing resources through optimized evaluation metrics, dynamic weight adjustment, MLP prediction, and task scheduling strategies. Compared to traditional methods, this method improves resource utilization in big data analysis tasks, fully demonstrating the advantages of multi-dimensional dynamic evaluation.

[0084] Example 3, the third aspect, please refer to Figure 2 This embodiment provides a system for implementing a computing resource allocation method based on multi-dimensional dynamic evaluation, aiming to solve the problems of narrow perspective and poor adaptability to task diversity in traditional computing resource allocation methods with single-dimensional evaluation. The system includes an evaluation module, a dynamic weight configuration module, a modeling module, and a scheduling module. It achieves dynamic optimization allocation of computing resources through multi-dimensional evaluation indicators, dynamic weight configuration, fuzzy comprehensive evaluation, and multilayer perceptron (MLP) neural network prediction. The functions and implementation methods of each module are described in detail below:

[0085] The evaluation module acquires evaluation index data for the task to be scheduled across multiple dimensions. It fuzzifies the evaluation index data according to a preset membership function and constructs a fuzzy evaluation matrix using weight values. The fuzzy evaluation matrix is ​​then comprehensively calculated according to fuzzy inference rules to obtain the task's fuzzy comprehensive evaluation data. Finally, the evaluation result of the task is obtained based on this fuzzy comprehensive evaluation data. The evaluation module collects the task's evaluation index data in real time through system monitoring interfaces (such as top, iostat, or Prometheus tools on Linux systems).

[0086] Evaluation metrics include computing performance (CPU utilization, multithreaded processing capability, vectorized operation capability), storage capacity (sequential read / write speed, random read / write speed, storage availability, cache hit rate), network bandwidth (network interface bandwidth capacity, network latency, packet loss rate), energy consumption (energy consumption of each component, energy consumption to performance ratio), and task priority (high, medium, and low levels). In this embodiment, assuming the task to be scheduled is a distributed deep learning training task, the evaluation module collects the following metrics: CPU utilization 85%, thread concurrency 16, sequential read / write speed 500MB / s, network latency 2ms, packet loss rate 0.1%, energy consumption to performance ratio 0.5 FLOPS / W, and task priority "high" (weight coefficient 1.5).

[0087] Subsequently, the evaluation module fuzzifies the indicator data according to the preset membership function. The membership function uses a triangular membership function; for example, CPU utilization (0%–100%) is divided into three fuzzy subsets: "Low" (0%–30%), "Medium" (30%–70%), and "High" (70%–100%). For a CPU utilization of 85%, the membership degree is 0.9 for "High," 0.1 for "Medium," and 0.0 for "Low." Other indicators such as network latency and storage read / write speed are processed similarly. The evaluation module uses the weight values ​​provided by the weight dynamic configuration module (e.g., [0.4, 0.3, 0.2, 0.1, 0.2], corresponding to computing performance, network bandwidth, storage capacity, energy consumption, and task priority) to construct a fuzzy evaluation matrix R.

[0088] R = [

[0089] [0.1,0.8,0.1], / / Computational performance (low, medium, high)

[0090] [0.2,0.7,0.1], / / Network bandwidth

[0091] [0.3,0.6,0.1], / / Storage capacity

[0092] [0.4,0.5,0.1], / / Energy consumption

[0093] [0.0, 0.2, 0.8] / / Task priority ]

[0095] The evaluation module calculates the comprehensive evaluation score B = R * W using fuzzy computation (weighted average method), for example...

[0096] B = [0.15, 0.65, 0.20], and the evaluation result is determined as "Medium" based on the principle of maximum membership. This result is stored in JSON format for use by the scheduling module.

[0097] The dynamic weight configuration module is used to dynamically configure the weight values ​​of evaluation index data based on task attributes and system status, adapting to the needs of different task types and system operating states. The weight values ​​are dynamically adjusted based on task type (computation-intensive, I / O-intensive, hybrid), task priority (high, medium, low), and system status (resource utilization, network congestion, etc.). In this embodiment, the dynamic weight configuration module maintains a rule table, generated based on historical task execution data and system performance analysis. For example, for a distributed deep learning task, the module assigns the following weights: computational performance 0.4 (multi-threaded processing capability 0.25, vectorization operation capability 0.15), network bandwidth 0.3 (network latency 0.2, bandwidth capacity 0.1), storage capacity 0.2 (sequential read / write speed 0.15, storage availability 0.05), energy consumption 0.1, and task priority 0.2 (high priority coefficient 1.5).

[0098] The weight adjustment algorithm is dynamically updated based on system status. For example, when network latency exceeds 5ms, the network latency weight is increased to 0.25, and the computational performance weight is decreased to 0.35. The module obtains the current resource utilization by monitoring the system status in real time (using netstat or a custom network monitoring tool) and queries the rule table based on task attributes (extracted from the task description file), outputting a weight vector W. This weight vector is passed to the evaluation module via API for constructing the fuzzy evaluation matrix.

[0099] The modeling module uses a Multilayer Perceptron (MLP) model to model the task execution process and obtain a prediction result for the task, typically the task execution time. In this embodiment, the MLP model contains 5 input neurons (corresponding to computational performance, network bandwidth, storage capacity, energy consumption, and task priority), 2 hidden layers (10 neurons per layer), and 1 output neuron (predicting execution time). The activation function is ReLU, the output layer uses a linear activation function, the loss function is mean squared error (MSE), the optimizer is Adam, and the learning rate is 0.001.

[0100] The modeling module is trained based on historical task data. For example, the data includes 10,000 records, each containing evaluation metrics and actual execution time. The data is divided into training and validation sets in an 8:2 ratio, trained for 100 epochs, and an early stopping mechanism is used to prevent overfitting. For example, for a distributed deep learning task, after inputting metric data (CPU utilization 85%, network latency 2ms, etc.), the MLP predicts an execution time of 1.5 hours. The prediction results are passed to the scheduling module via API to guide resource allocation.

[0101] The scheduling module selects one of several predefined task scheduling strategies based on the evaluation results from the assessment module and the prediction results from the modeling module to schedule tasks and allocate computing resources. The task allocation strategy is based on the comprehensive performance evaluation of the computing nodes and the task requirements. In this embodiment, the scheduling module supports priority scheduling and load balancing scheduling strategies. When the evaluation results show that the task priority is "high" and the deadline is less than 2 hours, the priority scheduling strategy is selected, and the task is assigned to the best-performing computing node (e.g., a node with low CPU utilization and low network latency); otherwise, the load balancing scheduling strategy is selected, and the task is assigned to the node with the lowest current load.

[0102] For example, a distributed deep learning task might have an evaluation result of "medium," a predicted execution time of 1.5 hours, and a deadline of 2 hours, meeting the priority scheduling criteria. The scheduling module sorts nodes based on their performance (based on the comprehensive score from the evaluation module) and selects the node with the highest performance (e.g., 50% CPU utilization, 1ms network latency) to allocate the task. The scheduling module is implemented through a task scheduler, which maintains a pool of node resources, dynamically updates node status, and performs task allocation.

[0103] The system in this embodiment achieves multi-dimensional dynamic evaluation and computing resource allocation through fuzzy comprehensive evaluation in the evaluation module, dynamic adjustment in the weight dynamic configuration module, MLP prediction in the modeling module, and strategy selection in the scheduling module. Compared with traditional methods, this system improves resource utilization, shortens task completion time, and reduces energy consumption in distributed deep learning tasks, significantly outperforming allocation methods based on single-dimensional evaluation.

[0104] Fourthly, embodiments of the present invention provide a computer program product including a non-transitory computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, cause the processor to perform the method proposed in the above embodiments.

[0105] The present invention also discloses a computer program product, including a computer program / instruction, which, when executed by a processor, implements the steps of the above-mentioned computing resource allocation method based on multi-dimensional dynamic evaluation provided by the present invention. The computer program product should be understood as a software product that mainly implements its solution through a computer program, such as a program product integrated in the cloud or a software library.

[0106] In the description of this specification, the references to terms such as "an embodiment," "some embodiments," "example," "specific example," "a implementation," "a preferred implementation," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0107] Although embodiments of the invention have been shown and described, those skilled in the art will understand that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the claims and their equivalents.

Claims

1. A method for allocating computing resources based on multi-dimensional dynamic evaluation, characterized in that, Includes the following steps: Obtain evaluation metrics data for the tasks to be scheduled across multiple dimensions; The weight values ​​of the evaluation index data are dynamically configured based on task attributes and system status. The evaluation index data is fuzzified according to the preset membership function, and a fuzzy evaluation matrix is ​​constructed using the weight values. The fuzzy evaluation matrix is ​​comprehensively calculated according to the fuzzy inference rules to obtain the fuzzy comprehensive evaluation data of the task; The evaluation result of the task is obtained based on the fuzzy comprehensive evaluation data; The execution process of the task is modeled using a multilayer perceptron model to obtain prediction results for the task. Based on the evaluation results and the prediction results, a task scheduling strategy is selected from a variety of predefined task scheduling strategies to schedule the task and allocate computing resources.

2. The method according to claim 1, characterized in that, The evaluation metrics across multiple dimensions include: task priority, the amount of computing resources required for the task, the task deadline, and the current system resource utilization rate.

3. The method according to claim 1, characterized in that, The step of dynamically configuring the weight values ​​of the evaluation index data based on task attributes and system status includes: The system is dynamically adjusted based on changes in task load and system performance, so that different weight values ​​are assigned to different evaluation metrics under different operating conditions.

4. The method according to claim 1, characterized in that, The multilayer perceptron model is trained based on historical task data and is used to predict the execution time of the task according to the evaluation index data. The predicted execution time is used to guide the allocation of computing resources.

5. The method according to claim 4, characterized in that, The predefined multiple task scheduling strategies include priority scheduling strategy and load balancing scheduling strategy. When the evaluation result of the task indicates that the urgency of the task exceeds a predetermined threshold, the priority scheduling strategy is selected; otherwise, the load balancing scheduling strategy is selected.

6. The method according to claim 5, characterized in that, When there are multiple tasks to be scheduled, the multiple tasks are sorted according to their respective evaluation results, and the tasks are scheduled in order of priority to allocate computing resources.

7. The method according to claim 6, characterized in that, It also includes adjusting the weight values ​​of the evaluation index data based on the difference between the actual execution result of the task and the evaluation result after the task is completed, so as to optimize the evaluation process of subsequent tasks.

8. The method according to claim 7, characterized in that, The multilayer perceptron model is periodically updated and trained based on the latest actual execution results of completed tasks to improve the accuracy of the multilayer perceptron model in predicting results for subsequent tasks.

9. A computing resource allocation system based on multi-dimensional dynamic evaluation for executing the computing resource allocation method based on multi-dimensional dynamic evaluation as described in any one of claims 1 to 8, comprising an evaluation module, a weight dynamic configuration module, a modeling module, and a scheduling module, characterized in that: The evaluation module is used to acquire evaluation index data of the task to be scheduled in multiple dimensions, fuzzify the evaluation index data according to a preset membership function, and construct a fuzzy evaluation matrix using the weight values. The fuzzy evaluation matrix is ​​comprehensively calculated according to the fuzzy inference rules to obtain the fuzzy comprehensive evaluation data of the task; The evaluation result of the task is obtained based on the fuzzy comprehensive evaluation data; The weight dynamic configuration module is used to dynamically configure the weight values ​​of the evaluation index data according to the task attributes and system status; The modeling module is used to model the execution process of the task using a multilayer perceptron model to obtain a prediction result for the task. The scheduling module is used to select a task scheduling strategy from a variety of predefined task scheduling strategies based on the evaluation results and the prediction results, and to schedule the task to allocate computing resources.

10. A computer program product, characterized in that, The method includes a non-transitory computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, cause the processor to perform the computing resource allocation method based on multi-dimensional dynamic evaluation as described in any one of claims 1 to 8.

Images