AI-based computing cluster running efficiency evaluation system

Abstract

The application relates to the field of efficiency evaluation, and discloses an AI-based computing cluster operation efficiency evaluation system, which is used for making the cluster operation efficiency evaluation have both explainability and online decision-making capability. The system comprises the following steps: collecting operation index data of each computing node in the computing cluster; determining node state probability and aggregating to obtain a cluster state probability vector and count an initial transition rate parameter set; calibrating a fluid Petri net model based on an artificial bee colony algorithm, combining a queuing model with a buffer capacity upper limit to calculate a cluster queuing loss index; an index calculation module calculates a system stability index based on the deviation between the current cluster state probability vector and a reference state probability vector, and calculates an effective resource utilization rate; a comprehensive operation efficiency index is obtained, and an efficiency evaluation result and low-efficiency node diagnosis information are output. The application improves the cluster operation efficiency and realizes accurate diagnosis of bottlenecks.

Description

Technical Field

[0001] This invention relates to the field of efficiency evaluation, and more particularly to an AI-based computing cluster operation efficiency evaluation system. Background Technology

[0002] With the continuous growth of workloads such as artificial intelligence training and inference, scientific computing, and big data batch processing, modern computing clusters are rapidly evolving in three directions: ultra-large node size, heterogeneous hardware architecture, and time-varying task load. The number of nodes in a single cluster has expanded from hundreds to tens of thousands, with CPUs, GPUs, NPUs, and high-speed storage and network resources being deployed in a mixed manner within the cluster, and task arrival exhibiting obvious burstiness and long-tail distribution.

[0003] Against this backdrop, a growing gap exists between the nominal computing power and the effective computing power of a cluster: nodes may appear to be busy, but in reality, they may be stuck for extended periods waiting for I / O, queuing, or retrying faults, resulting in the so-called "busy but ineffective" phenomenon. This kind of hidden efficiency loss cannot be directly reflected by traditional resource utilization metrics, but it significantly increases the average task completion time, reduces the effective utilization of accelerators, raises the energy cost per unit of computing power, and weakens the SLA guarantee capability for upper-layer services.

[0004] Therefore, how to conduct real-time, quantitative, and attributable assessments of the operational efficiency of computing clusters has become a core prerequisite for cluster scheduling, capacity planning, and operation and maintenance decisions.

[0005] Existing monitoring systems mostly use processor utilization and memory usage as the main indicators for efficiency evaluation, without incorporating task queue length, input / output latency, task failure count, and resource utilization into a unified indicator system. However, in real clusters, high processor utilization often occurs simultaneously with I / O blocking, queue backlog, and repeated task failures. A single dimension of resource utilization cannot distinguish between effective busy and idle busy.

[0006] The data acquisition process inevitably generates missing data and noise spikes. Current practices typically involve directly discarding missing samples, imputing with the global mean, or using a simple moving average. Discarding samples disrupts the continuity of the time series and causes fluctuations in sample size; imputing with the mean has a large estimation bias for skewed distribution indicators; and simple moving averages are insufficient in suppressing impulsive outliers, which directly contaminate subsequent modeling results.

[0007] Existing assessment systems typically output a health score or rating for the entire cluster, at most ranking individual nodes for specific metrics. As a result, even if operations personnel know the cluster is inefficient, they cannot quickly determine which nodes are dragging down the overall performance, whether the problems are due to frequent failures or idle resources, or what the next steps should be. Failure-driven nodes require repair, isolation, or hardware replacement, while idle-driven nodes require task reallocation or scaling down—the approaches are completely different. Without this attribution, assessment conclusions cannot directly drive operational actions, creating a disconnect between assessment, scheduling, and operations.

[0008] Therefore, we propose an AI-based computing cluster operation efficiency evaluation system to address the above problems. Summary of the Invention

[0009] This invention provides an AI-based computing cluster operation efficiency evaluation system, which enables cluster operation efficiency evaluation to have both interpretability and online decision-making capabilities.

[0010] The first aspect of this invention provides an AI-based computing cluster operation efficiency evaluation system, comprising: a data preprocessing module for collecting operation indicator data of each computing node in the computing cluster within the current time window, and preprocessing the operation indicator data to obtain preprocessed operation indicator data; a parameter statistics module for determining the node state probability of each computing node based on the preprocessed operation indicator data, and aggregating the nodes to obtain a cluster state probability vector for the current time window; and statistically obtaining an initial transfer rate parameter set based on the preprocessed operation indicator data; and a queuing loss module for calibrating the parameters of a preset performance evaluation model based on a preset optimization algorithm and the initial transfer rate parameter set, so that the model state output by the preset performance evaluation model is... The cluster state probability vector is approximated probabilistically to obtain a calibrated set of transfer rate parameters. A queuing model is constructed based on the calibrated set of transfer rate parameters, and a cluster queuing loss index is calculated based on the queuing model. An index calculation module is used to obtain a reference state probability vector corresponding to the cluster state probability vector, and calculate a system stability index based on the deviation between the cluster state probability vector and the reference state probability vector in the current time window. An effective resource utilization rate is calculated based on the calibrated set of transfer rate parameters and the preset performance evaluation model. A comprehensive evaluation module is used to integrate the cluster queuing loss index, the system stability index, and the effective resource utilization rate to calculate a comprehensive operating efficiency index, and output an efficiency evaluation result based on the comprehensive operating efficiency index.

[0011] Optionally, in a first implementation of the first aspect of the present invention, the operational metrics data include processor utilization, task queue length, input / output wait time, and number of task failures. The data preprocessing module is specifically used to: sequentially perform missing value filling and outlier smoothing on the operational indicator data to obtain preprocessed operational indicator data.

[0012] Optionally, in a second implementation of the first aspect of the present invention, when the parameter statistics module determines the node state probability of each computing node based on the preprocessed running index data and aggregates them to obtain the cluster state probability vector for the current time window, it is specifically used for: Based on the preprocessed operational index data, the membership degree of each computing node in various preset state categories is calculated using membership functions. The preset state categories include idle state, running state, blocked state, and fault state. The membership degrees are normalized to obtain the node state probabilities corresponding to each computing node. The node state probabilities of all computing nodes within the current time window are averaged according to the preset state categories to obtain the cluster state probability vector.

[0013] Optionally, in a third implementation of the first aspect of the present invention, the initial transfer rate parameter set includes task arrival rate, service completion rate, blockage transfer rate, blockage release rate, failure rate, and failure recovery rate.

[0014] Optionally, in the fourth implementation of the first aspect of the present invention, the preset optimization algorithm is the artificial bee colony algorithm, the preset performance evaluation model is the fluid Petri net model, and the queuing model is a single queue single server queuing model with a buffer capacity limit. When the queuing loss module calculates the cluster queuing loss index based on the queuing model, it is specifically used for: Calculate the steady-state queue length and blocking probability of each computing node under the queuing model; The cluster queuing loss index is obtained by summing and averaging the ratio of the steady-state queue length of each computing node to the corresponding upper limit of the buffer capacity and the blocking probability.

[0015] Optionally, in the fifth implementation of the first aspect of the present invention, when the index calculation module calculates the system stability index, it is specifically used to: calculate the weighted sum of squares of the offset of the cluster state probability vector in the current time window relative to the reference state probability vector, and perform a negative exponential transformation on the weighted sum of squares of the offset to obtain the Lyapunov stability as the system stability index. When the indicator calculation module calculates the effective resource utilization rate based on the calibrated transfer rate parameter set and the preset performance evaluation model, it is specifically used to: calculate the running state probability and blocking state probability of each computing node based on the calibrated transfer rate parameter set and the preset performance evaluation model; multiply the running state probability and the blocking state probability by a preset discount coefficient and sum them; and calculate the mean of all computing nodes to obtain the effective resource utilization rate.

[0016] Optionally, in a sixth implementation of the first aspect of the present invention, the index calculation module, when obtaining the reference state probability vector corresponding to the cluster state probability vector, is specifically used for: Obtain the historical cluster state probability vectors corresponding to a preset number of consecutive time windows before the current time window, and form a historical state probability vector sequence. Abnormal windows are identified and removed from the historical state probability vector sequence. The historical cluster state probability vectors corresponding to the remaining windows are averaged according to their respective state categories to obtain the reference state probability vector.

[0017] Optionally, in the seventh implementation of the first aspect of the present invention, the specific calculation formula for the Lyapunov stability L_{stab} is as follows: ; Where j represents the state category. These correspond to the idle state, running state, blocked state, and fault state, respectively. This represents the weight corresponding to state category j; This represents the value of the cluster state probability vector in state category j for the current time window; This represents the value of the reference state probability vector in state class j.

[0018] Optionally, in the eighth implementation of the first aspect of the present invention, when the comprehensive evaluation module calculates the comprehensive operating efficiency index by integrating the cluster queuing loss index, the system stability index, and the effective resource utilization rate, it is specifically used for: The queuing loss index of the cluster is transformed by a negative exponential transformation to obtain the queuing efficiency compensation value; The effective resource utilization rate, the system stability index, and the queuing efficiency compensation value are weighted and summed according to the preset dynamic adjustment weight or default weight to obtain the comprehensive operating efficiency index.

[0019] Optionally, in a ninth implementation of the first aspect of the present invention, a node diagnosis module is further included: The failure probability and idle probability of each computing node are calculated based on the preset performance evaluation model, and the node failure risk value and node resource idle value are calculated by combining the historical task failure ratio obtained based on the preprocessed operation index data. The node failure risk value is converted into a node failure risk complement value, and the node failure risk complement value is weighted and summed with the node resource idle value to obtain the node health index; Inefficient nodes are identified based on the node health index of all computing nodes, and the node failure risk value of the inefficient node is compared with the node resource idle value, and inefficient node diagnostic information containing inefficiency type label is output.

[0020] The mechanism of this invention is as follows: it can generate diagnostic information for inefficient nodes based on the probability of failure, the proportion of task failure, and the probability of idle state, thereby realizing an integrated closed loop from indicator perception, probability modeling, parameter self-calibration, joint evaluation of queuing loss and stability to scheduling feedback and operation and maintenance diagnosis. Beneficial effects: The model output is no longer a black box score, but a set of rate parameters with clear physical semantics, making the evaluation results naturally interpretable and verifiable; the parameters are updated online adaptively according to the working conditions, overcoming the infeasibility and time-varying mismatch of manual tuning in multi-node scenarios; Because the fitting target comes from actual statistical data rather than labeled samples, there is no need for large-scale labeled data. New clusters and new heterogeneous nodes can be cold-started directly, and cross-cluster migration has strong generalization. The computing power cost of intelligent optimization is much lower than that of deep learning training / online inference, which meets the real-time online evaluation requirements of seconds to minutes and will not significantly squeeze the computing power resources of the evaluated cluster itself. It provides a sufficiently large search coverage for highly fluctuating parameters such as task arrival rate to prevent the true optimal value from falling outside the search domain; it shrinks the search domain for stable parameters such as fault recovery rate to reduce invalid sampling and significantly accelerate convergence; it combines the triple mechanism of leader bee development, follower bee probability selection, and scout bee escape to achieve a balance between convergence speed and global optimization capability, effectively suppressing premature convergence and local optima. The threshold automatically shifts based on individual node differences and recent operating conditions, eliminating the systematic misjudgment caused by a globally uniform threshold in heterogeneous clusters, where low-load nodes are always considered idle and high-load nodes are always considered busy. The output state probability, rather than hard labels, preserves boundary asymptotic information and judgment uncertainty, providing consistent input for subsequent probabilistic modeling. Explicit modeling of the blocking state allows the state where resources are occupied but there is no effective output to enter the evaluation field for the first time, avoiding its incorrect inclusion in the running state. The primary source of efficiency loss—task blocking / dropping due to buffer fullness—is explicitly quantified, overcoming the systematic underestimation of loss by the infinite buffer assumption. Saturated nodes can still be assigned physically interpretable deterministic values ​​and participate in cluster aggregation, ensuring that the most critical congested nodes do not disappear from the evaluation, thus improving the completeness and robustness of the evaluation. It breaks through the limitations of static snapshot-based assessment, enabling the assessment to have dynamic evolution perception capabilities and sensitivity to gradual degradation and sudden drift; the abnormal window elimination mechanism of the reference baseline ensures that the baseline itself is not contaminated by historical failure periods, avoiding underreporting caused by treating anomalies as normal; negative exponential transformation ensures that the indicators are bounded, monotonic, and dimensionally unified, and can directly participate in weighted fusion. This system allows the utilization rate indicator to revert from resource occupancy rate to effective output rate, eradicating the persistent problem of systematically optimistic evaluation conclusions; the discount coefficient is derived from the node's own history, requiring no manual setting, and automatically adapts to the node's output characteristics; it maintains a balanced evaluation under normal operating conditions, avoiding excessive dominance of queuing items; under congested operating conditions, it automatically amplifies the influence of queuing losses, enabling the comprehensive index to respond immediately to severe queuing deterioration and shortening the lag in scheduling intervention; the evaluation system is condition-adaptive, with a single set of parameters covering both normal and abnormal states. The assessment is advanced from cluster-level scoring to node-level attribution, directly answering which nodes are dragging down the overall performance and where the problem lies; the distinction between fault-driven and idle-driven performance corresponds to completely different handling paths, enabling assessment conclusions to directly guide operation and maintenance actions; the efficiency level feedback scheduler reduces the dispatch of new tasks to nodes with high queuing loss when the performance is medium or poor, realizing an automatic closed loop from assessment to control, and truly transforming the assessment value into cluster efficiency gains. Attached Figure Description

[0021] Figure 1 This is a schematic diagram of one embodiment of the AI-based computing cluster operation efficiency evaluation system in this invention. Figure 2 This is a schematic diagram of another embodiment of the AI-based computing cluster operation efficiency evaluation system of the present invention; Figure 3 This is a schematic diagram illustrating the working method of the queuing loss module for calibrating the transfer rate parameters of a fluid Petri net model using an artificial bee colony algorithm, starting from an initial transfer rate parameter set, in an embodiment of the present invention. Figure 4 This is a schematic diagram of one embodiment of the AI-based computing cluster operation efficiency evaluation device in this invention. Detailed Implementation

[0022] This invention provides an AI-based computing cluster operational efficiency evaluation system, enabling cluster operational efficiency evaluation to possess both interpretability and online decision-making capabilities. The terms first, second, third, fourth, etc. (if present) in the specification, claims, and accompanying drawings 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 described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms include or have, and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus comprising 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 apparatus.

[0023] For ease of understanding, the specific process of the embodiments of the present invention is described below. Please refer to [link / reference]. Figure 1 One embodiment of the AI-based computing cluster operation efficiency evaluation system of the present invention includes: 101. Data preprocessing module, used to collect the operation index data of each computing node in the cluster. The operation index data includes processor utilization, task queue length, input / output waiting time and number of task failures. Missing value imputation and noise smoothing are performed on the operation index data to obtain preprocessed operation index data.

[0024] It is understood that the executing entity of this invention can be an AI-based computing cluster operation efficiency evaluation device, or it can be a terminal or a server; the specific implementation is not limited here. This embodiment of the invention will be described using a server as an example.

[0025] It should be noted that the following is a specific implementation example for a single node (node ​​A) in a certain AI computing cluster: The monitoring system extracts the operating status of the underlying hardware and operating system from the computing nodes at fixed time intervals (once per minute). The system captured raw monitoring snapshots of node A for five consecutive collection cycles (labeled T1 to T5), obtaining the following four metrics: Processor utilization (percentage): 76.0%, 82.0%, data loss: 88.0%, 79.0%.

[0026] Task queue lengths (number of tasks): 14, 17, 15, 210, 14 respectively.

[0027] Input / output wait times (milliseconds): 42.0, data loss, 48.0, 46.0, 45.0 respectively.

[0028] Number of task failures (times): 0, 0, 0, 1, 0.

[0029] Due to network fluctuations, the processor utilization in cycle T3 and the waiting time in cycle T2 could not be successfully collected; the task queue length in cycle T4 exceeded the preset reasonable fluctuation range (210), and was determined to be impulse noise.

[0030] The incomplete data above is filled by linear interpolation between adjacent time points.

[0031] To address the processor utilization missing in cycle T3, the system reads the data from T2 (82.0) and T4 (88.0) and calculates the arithmetic mean, resulting in a filler value of 85.0.

[0032] For the missing input / output waiting time in cycle T2, the system reads the data from T1 (42.0) and T3 (48.0) and averages them to obtain the filling result of 45.0.

[0033] The padded sequence becomes: Processor utilization: 76.0, 82.0, 85.0, 88.0, 79.0.

[0034] Input / output wait times: 42.0, 45.0, 48.0, 46.0, 45.0.

[0035] The system detected that the abnormal jump in the task queue length during period T4 (210) significantly exceeded the reasonable fluctuation range and determined it to be impulse noise. Using the median filtering method, the average of the data from T3 (15) and T5 (14) was taken and rounded off, and T4 was corrected to 15.

[0036] A moving average with a window size of 3 is applied to parameters such as processor utilization. After smoothing out short-term fluctuations, the preprocessed performance metrics output by this node have a clear data structure, and other nodes in the cluster execute this process synchronously.

[0037] 102. The parameter statistics module is used to calculate the membership degree of each node in the idle, running, blocked, and fault states based on the preprocessed operation index data. The membership degree is determined by the adaptive trapezoidal membership function. The node state probability is obtained by normalizing each membership degree and the cluster state probability vector is obtained by averaging the state probabilities of all nodes. At the same time, the module also calculates the task arrival rate, service completion rate, blocking transfer rate, blocking unblocking rate, failure rate, and failure recovery rate of each node based on the preprocessed operation index data to obtain the initial transfer rate parameter set.

[0038] It should be noted that the system uses an adaptive trapezoidal membership function to determine node preference. Take node A's data at a certain moment (processor utilization 85.0%, input / output wait time 48.0 milliseconds, task queue length 15, 0 task failures) as an example.

[0039] After substituting into the function, high utilization sets the running state membership degree to 0.80. A wait time of 48.0 milliseconds indicates slight lag, and the blocked state membership degree is set to 0.40. The idle and faulty membership degrees are 0. Normalizing the membership degrees (dividing by the sum of 1.20), we obtain the running state probability of node A as 0.67, the blocked state probability as 0.33, and the idle and faulty state probabilities as 0.

[0040] Assume the cluster also includes node B and node C. Node B currently has no tasks, and its state is: idle 0.90, running 0.10. Node C is in a queue due to a storage anomaly, and its state is: blocked 0.70, running 0.20, faulty 0.10.

[0041] The system sums the node states by dimension and calculates the arithmetic mean. The running state is calculated by adding 0.67, 0.10, and 0.20 and dividing by 3, while the blocked state is calculated by adding 0.33, 0, and 0.70 and dividing by 3. After rounding and normalization adjustments, the sum of all terms in the cluster state probability vector is ensured to be one, resulting in the following cluster state probability vectors: idle state 0.30, running state 0.32, blocked state 0.34, and fault state 0.04.

[0042] The system extracts logs from node A over the past hour. During this hour, 3600 new tasks were received, with a task arrival rate of 1.0. 4320 tasks were processed (including processing backlogged tasks), with a service completion rate of 1.2. There were 360 ​​instances of I / O suspension, resulting in a blocking transfer rate of 0.1; 432 tasks were recovered from waiting, resulting in a blocking unblocking rate of 0.12. The task interruption error rate translates to a failure rate of 0.0008 and a recovery rate of 0.0005. These values ​​are packaged to form the initial transfer rate parameter set for node A.

[0043] 103. The queuing loss module is used to calibrate the transfer rate parameters of the fluid Petri net model using the artificial bee colony algorithm, starting from the initial transfer rate parameter set. This makes the state probability output by the fluid Petri net model approximate the cluster state probability vector, resulting in a calibrated transfer rate parameter set. Based on the calibrated transfer rate parameter set, a single-queue, single-server queuing model with a buffer capacity limit for each node is established. The steady-state queue length and blocking probability of each node are calculated. The average of the ratio of the queue length to the buffer capacity limit and the sum of the blocking probabilities of each node is then used to obtain the cluster queuing loss index.

[0044] It should be noted that the system uses the cluster state probability vector as a reference target and the initial transition rate of each node as the starting point for the search. During algorithm iteration, the system adjusts the parameters and inputs them into the fluid Petri net model to make its output approximate the true probability.

[0045] Node A initially has an arrival rate of 1.0 and a service rate of 1.2. After calibration, considering the implicit attenuation within the node, Node A's service completion rate is corrected to 1.05 (slightly higher than the arrival rate to maintain system overload), the block transfer rate is corrected to 0.15, and the corresponding block release rate is corrected to 0.16.

[0046] Set the maximum capacity of the task buffer queue for each node to 50.

[0047] Substitute the calibrated parameters into the model. For node A, the service rate of 1.05 is slightly greater than the arrival rate of 1.0, but there is blocking transition. The steady-state solution shows that the steady-state queue length for node A is approximately 15, and the blocking probability of a new task being rejected is close to 0. Node B processes smoothly, with a steady-state queue length of approximately 1, and the blocking probability is close to 0. Node C experiences load backlog, with a steady-state queue length of approximately 45, and the blocking probability is approximately 0.17. The calculated and weighted arithmetic mean is 0.23, which is the cluster queuing loss metric.

[0048] 104. The index calculation module is used to calculate the weighted sum of squares of the current cluster state probability vector relative to the reference state, taking the average value of the cluster state probability vector of the most recent multiple time windows as the reference state. The Lyapunov stability is obtained by performing an exponential transformation on the weighted sum of squares of the offset. Based on the calibrated transfer rate parameter set, the running state probability and the blocked state probability of each node are calculated by the fluid Petri net model. The running state probability and the blocked state probability are multiplied by a preset discount factor and then summed to obtain the effective resource utilization rate.

[0049] It should be noted that the system extracts the vector of the historical window to construct the reference state. Assume that the reference vector is: idle state 0.25, running state 0.50, blocked state 0.20, and fault state 0.05.

[0050] Introduce the current vector from step 102 (idle state 0.30, running state 0.32, blocked state 0.34, fault state 0.04). Set the weights: idle state 0.1, running state 0.2, blocked state 0.4, fault state 0.8.

[0051] The system calculates the weighted sum of squares of the differences: Idle state: The difference between the current 0.30 and the reference 0.25 is 0.05. Multiplying this by 0.1 gives 0.00025.

[0052] Running state: The difference is -0.18, multiplied by itself and then multiplied by 0.2 to get 0.00648.

[0053] Blocked state: The difference is 0.14, which is multiplied by 0.4 to get 0.00784.

[0054] Fault state: The difference is -0.01, which is multiplied by itself and then multiplied by 0.8 to get 0.00008.

[0055] The sum of the above four terms yields a weighted squared offset of 0.01465. Applying a negative exponential transformation to this value with the natural constant as the base, we obtain a Lyapunov stability of approximately 0.985.

[0056] The fluid Petri net model outputs the running probability and blocking probability of each node. The discount factor for physical resource occupancy in the blocking state is set to 0.2. The specific calculation process is shown in Table 1 below: Table 1

[0057] Taking node A as an example, the blocked state utilization of 0.30 multiplied by 0.2 equals 0.06, which is added to the running state utilization of 0.60 to obtain a utilization rate of 0.66. The effective utilization rates of the three nodes are added together to obtain a total of 1.29, which is divided by 3 and averaged to obtain an overall effective resource utilization rate of 0.43 for the cluster.

[0058] 105. The comprehensive evaluation module is used to perform a negative exponential transformation with the natural constant as the base on the cluster queuing loss index to obtain the queuing efficiency compensation value. The effective resource utilization rate, Lyapunov stability and queuing efficiency compensation value are weighted and summed according to preset weights to obtain the comprehensive operating efficiency index. The comprehensive operating efficiency index is compared with the preset threshold to output the efficiency level.

[0059] It should be noted that the cluster queuing loss index of 0.23 calculated in step 103 is extracted. In order to transform the negative congestion index into a positive compensation assessment, the system performs a negative exponential transformation on this value with the natural constant as the base.

[0060] The specific operation involves calculating the natural constant to the power of -0.23. The calculation yields a queuing efficiency compensation value of approximately 0.79; the smaller the queuing loss, the larger the compensation value.

[0061] The system summarizes three core evaluation dimensions: the effective resource utilization rate of 0.43 and Lyapunov stability of 0.985 output from step 104, and the queuing efficiency compensation value of 0.79 just calculated.

[0062] A weighted summation with preset weights is introduced. The effective utilization rate is weighted at 0.5, prioritizing computing power output; stability is weighted at 0.3, while queuing compensation is weighted at 0.2.

[0063] Itemized calculations: Weighted term for effective resource utilization: Multiply 0.43 by 0.5 to get 0.215.

[0064] Stability weighting: Multiply 0.985 by 0.3 to get 0.2955.

[0065] Queue compensation weighting: Multiply 0.79 by 0.2 to get 0.158.

[0066] The sum of the three weighted terms is 0.6685, which is rounded to two decimal places to get 0.67. The value 0.67 is the overall operating efficiency index of the current cluster.

[0067] The system reads the built-in threshold table. The standards are set as follows: a comprehensive index greater than or equal to 0.80 is excellent; between 0.60 and 0.79 is good; between 0.40 and 0.59 is a warning; and less than 0.40 is abnormal.

[0068] The calculated index of 0.67 was compared with the conditions, and 0.67 fell within the range of 0.60 to 0.79. The system determined and output that the efficiency level of the current computing cluster was good, and the evaluation process was completed.

[0069] Please see Figure 2 , Figure 3 Another embodiment of the AI-based computing cluster operation efficiency evaluation system in this invention includes: 201. Data preprocessing module, used to collect the operation index data of each computing node in the cluster. The operation index data includes processor utilization, task queue length, input / output waiting time and number of task failures. Missing value imputation and noise smoothing are performed on the operation index data to obtain preprocessed operation index data.

[0070] Specifically, the task allocation records of each node are obtained from the cluster scheduler, and the hardware resource usage counts of each node are obtained from the node monitoring agent. The task allocation records and hardware resource usage counts are aligned according to the node identifier, and the two are unified to the same timestamp granularity to obtain the aligned raw data of the running metrics. For the aligned raw data of the running metrics, the processor utilization, task queue length, input / output waiting time and number of task failures of each node are checked for missing values ​​in adjacent time windows in chronological order. If there are missing values, the median of the non-missing values ​​of the metric for that node in the previous preset number of time windows is taken and filled into the missing position. The first round of smoothing is performed on the filled data to obtain the preliminary complete metric data. The preliminary complete indicator data is grouped by indicator type. For each group of indicator data, the rolling quartile distance of the most recent preset number of time windows is calculated. Sample points that exceed the sum of the rolling quartile distances of the upper quartile and a preset multiple, and sample points that are lower than the difference between the rolling quartile distances of the lower quartile and a preset multiple, are marked as outliers. The outlier is replaced by the mean of the sample points adjacent to it in the corresponding time window, thus obtaining the preprocessed running indicator data. The preprocessed running indicator data is used to calculate the node state probability and statistically analyze the initial transition rate parameter set, and is used as the state probability observation value of the target fitted by the artificial bee colony algorithm.

[0071] It should be noted that the process mainly consists of three stages: acquisition and alignment of raw data for operational metrics, checking and imputing missing values, and outlier smoothing based on rolling interquartile range. The following example uses an AI computing cluster with three nodes (labeled as node A, node B, and node C) to illustrate the data processing for node A: The system extracts basic operational logs from both the cluster scheduler and the local monitoring agent of node A. The cluster scheduler is responsible for overall coordination, and its logs record changes in the length of the task queue allocated to node A and the number of task execution failures. Meanwhile, the monitoring agent inside node A delves deeper into the underlying hardware, frequently recording hardware-level processor utilization and input / output wait times.

[0072] The system performs a joint query on these two heterogeneous data sets based on the unique identifier of node A, and aligns all sampling points to a timestamp granularity of once per minute. Assuming that within a continuous ten-time window from 10:01 AM to 10:10 AM, the original data of some operational metrics after clock alignment presents the following state: Processor utilization (%): 70.0, 72.0, 75.0, 71.0, 74.0, missing data, 73.0, 76.0, 75.0, 74.0.

[0073] Task queue lengths (number of tasks): 15, 16, 14, 15, 18, 16, 15, 17, 120, 19.

[0074] For the aligned index sequence, the system checks the data integrity of adjacent time windows in ascending chronological order. In this embodiment, the system presets a total of five traceability time windows.

[0075] During the scan, the system detected missing processor utilization data at 10:06, which was suspected to be caused by a momentary restart of the agent process. The system immediately extracted the non-missing utilization data for the five consecutive time windows preceding the missing point (i.e., from 10:01 to 10:05), which were 70.0, 72.0, 75.0, 71.0, and 74.0, respectively.

[0076] The five values ​​are sorted in ascending order of magnitude, resulting in the sorted sequence: 70.0, 71.0, 72.0, 74.0, 75.0. The system extracts the median, 72.0, from the middle position and fills the missing value at 10:06 with this value. After filling in all missing values, the system performs a moving average operation with a window size of three on all the indicator data to filter out glitches caused by minor physical jitter in hardware sampling, thus obtaining preliminary complete indicator data.

[0077] After grouping the preliminary complete indicator data according to types such as task queue length and utilization rate, the system initiates a deep anomaly identification and replacement process. Taking the investigation of task queue length as an example, the number of rolling calculation windows set in this embodiment is eight time windows, and the set control multiple is 1.5 times.

[0078] When the system iterates through the sample point at 10:09, its recorded queue length is 120. The system extracts the queue length data for the eight time windows preceding this point (10:01 to 10:08): 15, 16, 14, 15, 18, 16, 15, 17.

[0079] Arrange these eight historical benchmark data in ascending order: 14, 15, 15, 15, 16, 16, 17, 18.

[0080] Using the quantile calculation logic, the lower quartile (i.e., the 25th percentile of the sequence) is 15, and the upper quartile (i.e., the 75th percentile of the sequence) is 16.5.

[0081] The system calculates the rolling interquartile range, which is the upper quartile minus the lower quartile, and the result is 1.5.

[0082] The system calculates the reasonable upper limit of data for this time point: based on the upper quartile of 16.5, add 1.5 times the rolling interquartile range (1.5 multiplied by 1.5 equals 2.25), and the sum gives an upper limit of 18.75.

[0083] The actual recorded value of 120 at 10:09 far exceeded the reasonable upper limit of 18.75 derived rigorously from historical data. Based on this, the system identified it as an abnormal mutation point (usually caused by a momentary congestion or dirty data in the scheduling log). To fix this, the system extracted the normal values ​​of 17 from 10:08 and 19 from 10:10, calculated their arithmetic mean to be 18, and replaced the original outlier value of 120 with 18.

[0084] 202. The parameter statistics module is used to calculate the membership degree of each node in the idle, running, blocked, and fault states based on the preprocessed operation index data. The membership degree is determined by the adaptive trapezoidal membership function. The node state probability is obtained by normalizing each membership degree and the cluster state probability vector is obtained by averaging the state probabilities of all nodes. At the same time, the module also calculates the task arrival rate, service completion rate, blocking transfer rate, blocking unblocking rate, failure rate, and failure recovery rate of each node based on the preprocessed operation index data to obtain the initial transfer rate parameter set.

[0085] Specifically, the time series of processor utilization, input / output latency, task queue length, and task failure count for each node are extracted from the preprocessed runtime index data. For the processor utilization of each node, the utilization values ​​of the most recent preset number of time windows are sorted in ascending order. The first preset percentile is taken as the first inflection point of the idle state trapezoidal membership function, the second preset percentile is taken as the second inflection point of the idle state trapezoidal membership function, the third preset percentile is taken as the first inflection point of the running state trapezoidal membership function, and the fourth preset percentile is taken as the second inflection point of the running state trapezoidal membership function, thus obtaining the adaptive threshold parameter. The membership degree of each node in the idle and running states is calculated based on the adaptive threshold parameters. The input / output waiting time is divided by the preset waiting time limit and the task queue length is divided by the preset queue length limit, then the sum is taken as the minimum of 1 to obtain the blocking membership degree. The number of task failures is divided by the preset failure number limit and taken as the minimum of 1 to obtain the fault membership degree. Thus, the membership degree values ​​of the four types of node states are obtained. The membership degree values ​​of the four types of node states are normalized to obtain the node state probability. The state probabilities of all nodes in the same time window are averaged according to the state category to obtain the cluster state probability vector. Based on the preprocessed operation index data, the number of newly assigned tasks, the number of completed tasks, the cumulative time in the running state, the cumulative number of times entering the blocking state, the average input / output waiting time, and the average fault recovery time of each node in the sliding time window are statistically analyzed. The task arrival rate, service completion rate, blocking transfer rate, blocking unblocking rate, fault rate, and fault recovery rate are calculated respectively to obtain the initial transfer rate parameter set. Among them, the cluster state probability vector is used as the state probability observation value of the target of the artificial bee colony algorithm, and the initial transfer rate parameter set is used as the search starting point of the artificial bee colony algorithm.

[0086] Furthermore, the adaptive threshold parameters are determined as follows: For the processor utilization time series of each node, the utilization values ​​of the most recent thirty time windows are sorted by numerical value, and then divided into a low-value set and a high-value set with the median as the boundary; the utilization value corresponding to the 10th percentile in the low-value set is taken as the first inflection point of the idle state trapezoidal membership function, the utilization value corresponding to the 75th percentile in the low-value set is taken as the second inflection point of the idle state trapezoidal membership function, the utilization value corresponding to the 10th percentile in the high-value set is taken as the first inflection point of the running state trapezoidal membership function, and the utilization value corresponding to the 90th percentile in the high-value set is taken as the second inflection point of the running state trapezoidal membership function; the four inflection points obtained are used as the adaptive threshold parameters of the node, which are used to calculate the membership degree of the node in the four states in the current time window.

[0087] It should be noted that the system obtains the time series of processor utilization of node A within the most recent thirty time windows, and arranges these thirty specific values ​​in ascending order. Assume the median utilization rate between the fifteenth and sixteenth nodes is 55.0%.

[0088] The system uses the median as the dividing line to split the utilization data into two subsets: a low-value set containing fifteen smaller values ​​and a high-value set containing fifteen larger values.

[0089] In the low-value set, the system calculates and extracts the value corresponding to the 10th percentile (15.0%) as the first inflection point of the idle state trapezoidal membership function; and extracts the value corresponding to the 75th percentile (45.0%) as the second inflection point of the idle state trapezoidal membership function.

[0090] In the high-value set, the system calculates and extracts the value corresponding to the 10th percentile (60.0%) as the first inflection point of the running-state trapezoidal membership function; and extracts the value corresponding to the 90th percentile (85.0%) as the second inflection point of the running-state trapezoidal membership function. These four utilization inflection point values, obtained through historical data mapping, together constitute the adaptive threshold parameter used to evaluate the current state of node A.

[0091] The system reads the preprocessing performance metrics data output by node A in the current time window: processor utilization is 72.0%, input / output wait time is 40.0ms, task queue length is 18, and task failure count is 0.

[0092] Utilization status assessment: The current utilization rate of 72.0% falls exactly in the core high range between the two inflection points of the running state (60.0% and 85.0%). Substituting this into the adaptive trapezoidal function, the membership degree of the running state is relatively high, which is set to 0.80. This value is much higher than the upper limit inflection point of the idle state, so the membership degree of the idle state is 0.

[0093] Next, the blocking status is assessed: The system has a built-in preset maximum waiting time of 100.0ms and a preset maximum queue length of 50. The system divides the current waiting time of 40.0ms by 100.0ms to obtain a scaling factor of 0.40; it also divides the current queue length of 18ms by 50 to obtain a scaling factor of 0.36. These two scaling factors are added together to obtain 0.76. The system compares 0.76 with the value 1 and takes the smaller value, confirming the blocking membership degree as 0.76.

[0094] Final fault status assessment: The system's built-in preset maximum number of failures is 5. The current number of failures is 0, which, when divided by 5, equals 0. Taking the smaller value between this and 1, we obtain a fault membership degree of 0.

[0095] The system sums the membership degrees of the four states of node A (0, 0.80, 0.76, 0), resulting in a total of 1.56. To obtain the standard probability, the system divides each membership degree by 1.56 to perform a normalization operation, yielding the state probability sequence of node A: idle state is 0, running state is approximately 0.51, blocked state is approximately 0.49, and fault state is 0.

[0096] The system processes data from other nodes in the cluster in parallel, and calculates the state probabilities of node B (idle state 0.90, running state 0.10, blocked state 0, fault state 0) and node C (idle state 0, running state 0.20, blocked state 0.59, fault state 0.21).

[0097] The system sums the state probabilities of all three nodes within the same time window according to four categories: idle, running, blocked, and faulty, and then divides the sum by the total number of nodes (3) to calculate the average. The resulting cluster state probability vector is: idle 0.30, running 0.27, blocked 0.36, and faulty 0.07. This macroscopic vector will serve as the target observation for the next stage of the algorithm's approximation.

[0098] The system logs the event frequency of node A within the past sliding time window. Data shows that node A received 3600 new tasks within that window, which, when divided by the time span, yields a task arrival rate of 1.0 task / s. Due to internal resource contention, 3240 tasks were actually completed and exited, resulting in a service completion rate of 0.90 tasks / s.

[0099] During this period, the cumulative physical time the node spent in the running state was 2000 seconds, and the cumulative number of times it entered the blocked state due to input / output bottlenecks was 300. Dividing these two values ​​by 0.15 yields a blockage transfer rate. Based on statistics such as average waiting time, the blockage unblocking rate is calculated to be 0.18. Furthermore, the recorded minor fault interruptions and automatic recovery data yielded a fault rate of 0.001 and a fault recovery rate of 0.01. These six dynamic rate values ​​were packaged together to generate an initial transfer rate parameter set, serving as the starting point for the first generation of the artificial bee colony algorithm's search.

[0100] 203. The queuing loss module is used to calibrate the transfer rate parameters of the fluid Petri net model using the artificial bee colony algorithm, starting from the initial transfer rate parameter set. This makes the state probability output by the fluid Petri net model approximate the cluster state probability vector, resulting in a calibrated transfer rate parameter set. Based on the calibrated transfer rate parameter set, a single-queue, single-server queuing model with a buffer capacity limit for each node is established. The steady-state queue length and blocking probability of each node are calculated. The average of the ratio of the queue length to the buffer capacity limit and the sum of the blocking probabilities of each node is then used to obtain the cluster queuing loss index.

[0101] Specifically, based on the initial transfer rate parameter set, random perturbations are performed within a preset upper and lower fluctuation range of each parameter in the initial transfer rate parameter set to generate multiple sets of candidate transfer rate parameter sets as honey sources. Each honey source corresponds to a set of candidate transfer rate parameters. For each honey source, the candidate transfer rate parameters are substituted into the fluid Petri net model to obtain the steady-state solution of the probability of each node state. The deviation of the steady-state solution from the running state probability vector and the deviation of the blocked state probability vector are calculated. The two deviations are added together according to preset weights to obtain the fitting error. The fitness of each honey source is obtained by mapping the inverse of the fitting error. Based on fitness, the system performs leader bee search, follower bee probability selection, and scout bee reinitialization operations, iteratively updating the nectar source location until a preset number of iterations is reached or the change in optimal fitness is less than a preset threshold. The candidate transfer rate parameters corresponding to the current optimal nectar source are used as the calibrated transfer rate parameter set. The upper limit of the buffer capacity of each node is obtained, which is the value obtained by rounding up the historical maximum value of the task queue length of the node. The node load intensity is determined based on the task arrival rate and service completion rate in the calibrated transfer rate parameter set. The node load intensity is determined, and the steady-state probability formula based on the single-queue single-server queuing model (M / M / 1 / K) with the upper limit of buffer capacity is used to calculate the steady-state queue length and blocking probability of each node. The ratio of the steady-state queue length to the upper limit of buffer capacity of each node is added to the blocking probability, and the average value is taken for all nodes in the cluster to obtain the cluster queuing loss index. Among them, the calibrated transfer rate parameter set is used to calculate the running state probability and blocking state probability of each node, and the cluster queuing loss index is used to calculate the weighted sum to obtain the comprehensive operating efficiency index.

[0102] Furthermore, random perturbations are performed within a preset upper and lower fluctuation range for each parameter in the initial transfer rate parameter set to generate multiple sets of candidate transfer rate parameter sets as honey sources. Specifically, this includes: obtaining the historical estimated value of each parameter in the initial transfer rate parameter set within the most recent thirty time windows, calculating the time series coefficient of variation for each parameter, comparing the coefficient of variation with the first variation threshold of 0.2 and the second variation threshold of 0.1; if the coefficient of variation is greater than 0.2, then the upper and lower fluctuation range of the perturbation of the honey source corresponding to the parameter is set to ±30% of the initial value of the parameter; if the coefficient of variation is between 0.1 and 0.2, then the upper and lower fluctuation range of the perturbation of the honey source corresponding to the parameter is set to ±20% of the initial value of the parameter; if the coefficient of variation is less than 0.1, then the upper and lower fluctuation range of the perturbation of the honey source corresponding to the parameter is set to ±10% of the initial value of the parameter. Based on the perturbation range corresponding to each parameter, a uniform random perturbation is applied to the initial value of each parameter to generate multiple sets of candidate transfer rate parameters. Each set of candidate transfer rate parameters constitutes a nectar source. The perturbation range is used to generate neighborhood solutions and reset nectar source generation when the guiding bee searches and the scout bee re-initializes its operation.

[0103] It should be noted that the system extracts historical data for each parameter in the initial transfer rate parameter set of node A within the most recent thirty time windows. Taking the service completion rate of node A (initial estimate of 0.90 units / s) as an example, the system calculates its historical series standard deviation as 0.135, arithmetic mean as 0.90, and divides the two to obtain the time series coefficient of variation as 0.15.

[0104] According to the mutation constraint rules set by the system, the coefficient of variation of 0.15 is clearly between the first mutation threshold (0.2) and the second mutation threshold (0.1). Therefore, the system strictly limits the upper and lower fluctuation boundaries of this parameter when generating honey sources to within ±20% of its initial value. Based on this calculation, the legal mutation range of the service completion rate of node A in the algorithm search is locked between 0.72 and 1.08.

[0105] The coefficient of variation of the arrival rate of node A (initial value 1.0) is calculated to be 0.08, which is less than the second threshold of 0.1. Its perturbation range is set to ±10%, that is, the legal interval is 0.9 to 1.1. The system applies uniform random perturbation within the legal boundary interval of each parameter to generate a large-scale set of multiple candidate transition rate parameters. Each set constitutes a honey source exploration in the artificial bee colony algorithm space.

[0106] The algorithm begins iterative optimization. For each generated honey source, the system substitutes its candidate transfer rate parameters into the backend fluid Petri net model to solve for the mathematical steady-state solution of the probability of each node's state under that set of parameters.

[0107] The system extracts the cluster observation probabilities (average 0.27 in the running state and average 0.36 in the blocked state) calculated in step 202 as the absolute benchmark that must be approximated. The system calculates the running state deviation and the blocked state deviation between the candidate steady-state solution and the observation benchmark, assigning weights of 0.6 to the running state deviation and 0.4 to the blocked state deviation, and sums these to obtain the fitting error. The system takes the reciprocal of the fitting error as the nectar source fitness, driving the lead bees and follower bees to continuously converge towards regions with high fitness.

[0108] After multiple rounds of deep iteration, the algorithm converges and outputs the optimal calibration parameters. During this process, the service completion rate of node A is optimized and converged to 1.05 (this value is within the legal search range of 0.72 to 1.08, which conforms to the rigorous optimization logic), and its task arrival rate is stabilized at 1.0; at the same time, the arrival rate of node B is output as 0.5 and the service rate as 1.0; the arrival rate of node C is output as 1.2 and the service rate as 1.0.

[0109] Extract the maximum buffer capacity for each node, which is calculated by rounding up the maximum value of the historical task queue. In this example, node A has a maximum capacity of 50, node B has a maximum capacity of 20, and node C has a maximum capacity of 60.

[0110] The system calculates the load intensity of each node (arrival rate divided by service completion rate) and substitutes it into the single-queue, single-server queuing model: Node A: The load intensity is 1.0 divided by 1.05, resulting in approximately 0.95. Substituting this into the queuing model (capacity limit K=50), the steady-state formula is rigorously calculated to show that its current steady-state queue length is approximately 15, and the blocking probability of a new task being rejected is approximately 0.00.

[0111] Node B: The load intensity is 0.5 divided by 1.0, resulting in 0.5. Substituting this into the model (K=20), the steady-state queue length is calculated to be approximately 1, and the blocking probability is approximately 0.00.

[0112] Node C: The load intensity is 1.2 divided by 1.0, resulting in 1.2, indicating that the system is in an overloaded and congested state. Substituting this into the model (K=60), the steady-state queue length is calculated to be approximately 55 nodes, with a blocking probability of approximately 0.17.

[0113] Finally, the system integrates the data to calculate queuing loss metrics: Node A loss term: queue length ratio (15 divided by 50 equals 0.30) plus blocking probability (0.00), totaling 0.30.

[0114] Node B loss term: queue length ratio (1 divided by 20 equals 0.05) plus blocking probability (0.00), totaling 0.05.

[0115] The loss term for node C is: the queue length ratio (55 divided by 60 is approximately 0.92) plus the blocking probability (0.17), totaling 1.09.

[0116] Sum the loss terms of the three nodes in the entire cluster (0.30 plus 0.05 plus 1.09 equals 1.44), then divide by the total number of nodes 3 to obtain the arithmetic mean of 0.48, which is the cluster queuing loss index output in this step.

[0117] 204. The index calculation module is used to calculate the weighted sum of squares of the current cluster state probability vector relative to the reference state, taking the average of the cluster state probability vectors of the most recent multiple time windows as the reference state. The Lyapunov stability is obtained by performing an exponential transformation on the weighted sum of squares of the offset. Based on the calibrated transfer rate parameter set, the running state probability and the blocked state probability of each node are calculated by the fluid Petri net model. The running state probability and the blocked state probability are multiplied by a preset discount factor and then summed to obtain the effective resource utilization rate.

[0118] Specifically, from the time series of cluster state probability vectors, the state probability vectors of the thirty time windows preceding the current time window are taken, and the arithmetic mean is calculated for each state category to obtain the reference state probability vector; the difference between the current cluster state probability vector and the reference state probability vector for each state category is calculated, and the square of each difference is multiplied by the weight corresponding to that state category, where the weight for running state is 0.5, the weight for blocked state is 0.3, the weight for idle state is 0.15, and the weight for fault state is 0.05. The weighted square values ​​of each state category are summed to obtain the offset weighted sum of squares. The offset is obtained by taking the square root of the weighted sum of squares of the offsets. A negative exponential transformation with the natural constant as the base is performed on the offset to obtain the Lyapunov stability. Based on the calibrated transfer rate parameter set, the steady-state equation of the fluid Petri net model is solved to obtain the running state probability and the blocked state probability of each node. For each node, the ratio of the number of tasks completed in the historical blocked state to the number of tasks completed in the historical running state is obtained as the blocked state discount coefficient. The running state probability and the blocked state probability are multiplied by the blocked state discount coefficient and then added to obtain the effective utilization rate of the node. The effective utilization rate of all nodes in the cluster is averaged to obtain the effective resource utilization rate. The Lyapunov stability is used for weighted summation to obtain the comprehensive operating efficiency index, and the effective resource utilization rate is used for weighted summation to obtain the comprehensive operating efficiency index.

[0119] Furthermore, the reference state probability vector is determined as follows: starting from the current time window, trace back thirty consecutive time windows to obtain the cluster state probability vector corresponding to each window, forming a historical state probability vector sequence; calculate the arithmetic mean and standard deviation of the thirty values ​​for each state category in the historical state probability vector sequence to obtain the historical mean vector and historical standard deviation vector for each state category; for each window in the historical state probability vector sequence, compare the deviation of each state category value in that window with its corresponding historical mean, and when the deviation of any state category exceeds twice the historical standard deviation of that state category, the window is marked as an abnormal window; All abnormal windows are removed from the historical state probability vector sequence. The arithmetic mean of the state category values ​​of the remaining windows is calculated to obtain the reference state probability vector. The reference state probability vector is used to calculate the weighted sum of squares of the offset of the current cluster state probability vector relative to the reference state probability vector, and thus obtain the Lyapunov stability.

[0120] It should be noted that the system extracts thirty cluster state probability vector samples continuously in the historical direction starting from the current time window.

[0121] The system calculates the arithmetic mean and standard deviation for four states: idle, running, blocked, and faulty, based on these historical samples. Preliminary calculations yield the following historical mean vectors: idle 0.25, running 0.35, blocked 0.35, and faulty 0.05. The synchronously calculated historical standard deviation vectors for each state are: idle 0.05, running 0.08, blocked 0.10, and faulty 0.02.

[0122] During the anomaly window screening process, the system compared the data characteristics of these thirty historical windows one by one. The inspection revealed that the failure probability of the twelfth historical window was 0.12, with an absolute deviation of 0.07 from its historical average of 0.05. Since this deviation of 0.07 was significantly greater than twice the historical standard deviation corresponding to the failure state (i.e., 0.04), the system triggered a data cleaning mechanism, marking this window and another window exhibiting similarly large fluctuations as anomalies and removing them.

[0123] The remaining twenty-eight stable historical windows after filtering were recalculated with an arithmetic mean to obtain a purer and more reliable reference state probability vector: idle state 0.26, running state 0.38, blocked state 0.33, and fault state 0.03.

[0124] The system retrieves the cluster state probability vectors (idle state 0.30, running state 0.27, blocked state 0.36, fault state 0.07) determined in step 202 and configures sensitivity weights for them: running state is set to 0.5, blocked state is set to 0.3, idle state is set to 0.15, and fault state is set to 0.05.

[0125] The system calculates the difference between the current probability and the reference probability for each item, squares the difference, and then performs a weighted average. Idle state deviation weighting: The difference between the current 0.30 and the reference 0.26 is 0.04, which is squared to get 0.0016, and multiplied by the weight 0.15 to get 0.00024.

[0126] Running deviation weighted: The difference between the current 0.27 and the reference 0.38 is -0.11, which is squared to get 0.0121. Multiplying by the weight 0.5 gives 0.00605.

[0127] Blocked state deviation weighting: The difference between the current 0.36 and the reference 0.33 is 0.03, which is squared to get 0.0009, and multiplied by the weight 0.3 to get 0.00027.

[0128] Fault state deviation weighting: The difference between the current 0.07 and the reference 0.03 is 0.04. The squared value is 0.0016. Multiplying by the weight 0.05 gives 0.00008.

[0129] Summing the four micro-deviation values ​​together, we get the overall weighted sum of squares of deviations as 0.00664.

[0130] To transform this weighted sum of squares into a physically meaningful index of system convergence, the Lyapunov stability is introduced. Calculation formula: ; The system takes the square root of the weighted sum of squares of the offset, 0.00664, to obtain a dimensionless attenuation offset of approximately 0.0815. This value is then substituted into the formula to perform a negative natural exponent transformation (i.e., calculating the natural constant to the power of -0.0815), yielding a Lyapunov stability of approximately 0.92.

[0131] Based on the best-fit parameters output by the artificial bee colony algorithm in step 203, the fluid Petri net model calculates the steady-state probabilities of the three nodes. At this point, the probabilities output by the model precisely approximate the observed target from step 202. Node A: The model outputs a running state probability of 0.31 and a blocked state probability of 0.35. Querying the system's historical logs, the ratio (discount factor) of the number of tasks completed by Node A in the blocked state to the number of tasks completed in the running state is 0.20. The effective utilization rate of Node A equals 0.31 plus (0.35 multiplied by 0.20), resulting in 0.38.

[0132] Node B: The model outputs a running state probability of 0.30 and a blocked state probability of 0.13. The calculated discount factor is extremely small, at 0.05. The effective utilization rate of Node B equals 0.30 plus (0.13 multiplied by 0.05), rounded to approximately 0.31.

[0133] Node C: The model outputs a running state probability of 0.20 and a blocked state probability of 0.60. Calculations show that due to cache compensation, its discount factor is as high as 0.50. The effective utilization rate of node C equals 0.20 plus (0.60 multiplied by 0.50), resulting in 0.50.

[0134] Logical verification shows that the average probability of the three nodes in the running state (0.31, 0.30, 0.20, averaging 0.27) and the average probability of the blocked state (0.35, 0.13, 0.60, averaging 0.36) meet the scale requirements of step 202, proving that the algorithm's optimization convergence is accurate. Finally, the single-point utilization of the three nodes is added together (0.38 plus 0.31 plus 0.50 equals 1.19), divided by the total number of 3, and averaged to obtain the average effective resource utilization of the cluster in this time window, which is approximately 0.40.

[0135] 205. The comprehensive evaluation module is used to perform a negative exponential transformation with the natural constant as the base on the cluster queuing loss index to obtain the queuing efficiency compensation value. The effective resource utilization rate, Lyapunov stability and queuing efficiency compensation value are weighted and summed according to preset weights to obtain the comprehensive operating efficiency index. The comprehensive operating efficiency index is compared with the preset threshold to output the efficiency level.

[0136] Specifically, the effective resource utilization rate, Lyapunov stability, and cluster queuing loss index for the current time window are obtained. The cluster queuing loss index is compared with the average value of the cluster queuing loss index for the most recent thirty time windows. If the current cluster queuing loss index exceeds 1.5 times the average value, the weight corresponding to the queuing efficiency compensation value is adjusted to 0.5, the weight corresponding to the effective resource utilization rate is adjusted to 0.25, and the weight corresponding to the Lyapunov stability is adjusted to 0.25. Otherwise, the default values ​​of 0.4 for the effective resource utilization rate, 0.3 for the Lyapunov stability, and 0.3 for the queuing efficiency compensation value are maintained. A negative exponential transformation with the natural constant base is performed on the cluster queuing loss index to obtain the queuing efficiency compensation value. The effective resource utilization rate, Lyapunov stability, and queuing efficiency compensation value are weighted and summed according to the adjusted or default weights to obtain the comprehensive operational efficiency index. The comprehensive operational efficiency index is compared with three preset thresholds of 0.85, 0.70, and 0.50. When the comprehensive operational efficiency index is greater than or equal to 0.85, the output efficiency level is excellent; when it is greater than or equal to 0.70 and less than 0.85, the output efficiency level is good; when it is greater than or equal to 0.50 and less than 0.70, the output efficiency level is medium; and when it is less than 0.50, the output efficiency level is poor. The efficiency level is output to the cluster scheduler. When the efficiency level is poor or medium, the scheduler is triggered to adjust the task allocation strategy, reducing the allocation of new tasks to nodes with high queuing loss.

[0137] It should be noted that the raw data of the three core indicators required for the current time window are accurately extracted from the pre-calculation stage: the effective resource utilization rate is 0.40, the Lyapunov stability is 0.92, and the cluster queuing loss indicator is 0.48.

[0138] The system queries the persistent layer of the monitoring database, retrieves the historical cluster queuing loss index for the past thirty consecutive time windows, summarizes them, calculates the arithmetic mean, and obtains a baseline value of 0.30 for the historical average queuing loss index.

[0139] To determine whether the current cluster is experiencing a sudden task congestion, the system compares the current queuing loss metric of 0.48 with 1.5 times the historical average of 0.30 (0.30 multiplied by 1.5 equals 0.45). The current 0.48 exceeds the preset deterioration threshold of 0.45, meeting the trigger condition that the current cluster is in a queuing backlog state. Based on this diagnosis, the system's built-in dynamic weight allocation mechanism is immediately triggered: the weight of the queuing efficiency compensation value is significantly increased from the default 0.3 to 0.5; to maintain the total weight unchanged, the system simultaneously decreases the weight of effective resource utilization from the default 0.4 to 0.25, and the weight of Lyapunov stability from the default 0.3 to 0.25.

[0140] The system extracts the current cluster queuing loss index of 0.48 and performs a negative exponential transformation on it with the natural constant as the base, thereby mapping the absolute value representing the loss to a positive efficiency compensation in the range of 0 to 1. By calculating the natural constant raised to the power of -0.48, the system calculates a queuing efficiency compensation value of approximately 0.62. The larger the queuing loss index, the smaller the compensation value, which is consistent with the basic physical characteristics of performance degradation.

[0141] Based on the new weight ratios after the trigger adjustment, a weighted summation operation is performed on the above three indicators. The specific numerical calculation and weighted mapping process is shown in Table 2 below: Table 2

[0142] As detailed in the table above, the system multiplies each indicator value by its corresponding dynamic weight to obtain a weighted individual score (i.e., 0.40 multiplied by 0.25 equals 0.10; 0.92 multiplied by 0.25 equals 0.23; 0.62 multiplied by 0.50 equals 0.31). Summing these three weighted scores (0.10 plus 0.23 plus 0.31) yields a total of 0.6400. After numerical processing, the overall operational efficiency index of the current computing cluster is determined to be 0.64.

[0143] The system retrieves three rating thresholds set in memory for tiered classification, which are 0.85, 0.70, and 0.50. The system then logically compares the calculated overall operating efficiency index of 0.64 with these three hard threshold conditions.

[0144] Since the value 0.64 is less than 0.70, but greater than or equal to 0.50, the system determines that the index clearly falls into the medium efficiency range, and then outputs the overall cluster efficiency level for the current time window as medium to the external interface.

[0145] This moderate rating was pushed to the top-level cluster scheduler in real time as a control command. Since the rating matched the preset intervention conditions triggered when the efficiency level was poor or moderate, the scheduler immediately initiated a flow control-based adjustment strategy. Combined with detailed data from the system's underlying layers (node ​​C was previously on the verge of severe overload and backlog), the scheduler proactively reduced or even temporarily blocked the distribution of computing tasks to node C when allocating subsequent new service requests. Instead, it redirected the new traffic to redundant computing power areas such as node B, where queuing losses were less significant, thereby curbing efficiency decline through proactive intervention.

[0146] 206. Node Diagnosis Module: Based on the calibrated transfer rate parameter set, this module uses a fluid Petri net model to calculate the failure probability and idle probability of each node. It extracts the number of task failures and task completions for each node within the sliding time window from the preprocessed operational index data. The failure rate is obtained by dividing the number of task failures by the sum of the number of task failures and task completions. The node failure probability and the failure rate are added together by a preset weight to obtain the node failure risk value. The node failure risk value is calculated by subtracting the node failure risk value from 1 to obtain the node failure risk compensation value. The node idle probability is subtracted from the preset resource idle baseline value by a preset weight to obtain the node resource idle value. The node failure risk compensation value and the node resource idle value are added together by a preset weight to obtain the node health index. The node health index of all nodes in the cluster is sorted in ascending order of value. Nodes with a health index lower than the median of the health index of all nodes in the cluster are identified as inefficient nodes. For inefficient nodes, their node failure risk value is compared with their node resource idle value. Inefficient nodes with a failure risk value greater than or equal to their node resource idle value are marked as failure-dominant, and inefficient nodes with a failure risk value less than their node resource idle value are marked as idle-dominant. Inefficient node diagnostic information containing inefficient node identifier, node health index, and inefficiency type label is generated and output to the operation and maintenance terminal.

[0147] Furthermore, the node resource idle baseline value is taken as 0.9 times the average idle state probability of all nodes in the cluster within the previous 30 time windows plus 0.05; the preset weights for the fault state probability and task failure ratio in the node fault risk value are 0.55 and 0.45, respectively; the preset weights for the idle state probability and node resource idle baseline value in the node resource idle value are 0.7 and 0.3, respectively; the preset weights for the node fault risk compensation value and node resource idle value in the node health index are 0.6 and 0.4, respectively; the node health index obtained in this way is used to extract inefficient nodes, compare fault risk values ​​with resource idle values, and output inefficient type labels.

[0148] It should be noted that, to ensure that the sum of the probabilities of the four states (running, blocked, idle, and faulty) of each node is strictly 1, the system combines hardware monitoring residuals to supplement the remaining idle state probability and fault state probability of each node: Node A: Given that the running state is 0.31 and the blocked state is 0.35 (totaling to 0.66), the probability of filling the idle state is 0.25 and the probability of the fault state is 0.09.

[0149] Node B: Given a running state of 0.30 and a blocked state of 0.13 (totaling 0.43), the probability of reading to fill the idle state is 0.55, and the probability of a fault state is 0.02.

[0150] Node C: Given a running state of 0.20 and a blocked state of 0.60 (totaling 0.80), the probability of reading to fill the idle state is 0.02, and the probability of a fault state is 0.18.

[0151] The arithmetic mean of the idle state probabilities of the three nodes yields a current average of 0.273. The system reviews the previous thirty historical time windows and calculates the historical average idle state probability of the entire cluster to be 0.273 (assuming it is similar to the current period's). Following the rules, this historical average is multiplied by 0.9 to obtain 0.2457. Adding a fixed offset compensation of 0.05, the precise baseline value for node resource idleness is 0.2957.

[0152] The system extracts the exact proportion of tasks executed by each node within the sliding window: Node A: A total of 10 tasks failed, 490 tasks were completed, and a total of 500 tasks were completed. The calculated task failure rate is 0.02.

[0153] Node B: A total of 2 tasks failed, 998 tasks were completed, and the total number of tasks was 1000. The calculated task failure rate is 0.002.

[0154] Node C: A total of 25 tasks failed, 475 tasks were completed, and a total of 500 tasks were completed. The calculated task failure rate is 0.05.

[0155] For node A, a multi-dimensional cross-calculation is performed: its failure probability (0.09) is multiplied by a preset weight of 0.55, and the task failure ratio (0.02) is multiplied by 0.45, resulting in a node failure risk value of 0.0585. Subtracting 0.0585 from the value 1 yields a node failure risk complement of 0.9415. Next, its idle probability (0.25) is multiplied by a weight of 0.7, and the idle baseline value (0.2957) is subtracted by a weight of 0.3, resulting in a node resource idle value of 0.0863. Finally, the complement value (0.9415) is multiplied by a weight of 0.6, and the idle value (0.0863) is multiplied by a weight of 0.4, summing these results in a health index of 0.5994 for node A.

[0156] The calculations for nodes B and C were completed and compiled into the following comparison matrix: Table 3

[0157] Note: A negative idle value for node C indicates that it is operating under excessive overload, which seriously deviates from the safe idle redundancy and lowers its health index.

[0158] The node health indices of the entire cluster are sorted in ascending order. The sorted sequence is as follows: 0.4973 for node C, 0.5994 for node A, and 0.7113 for node B.

[0159] The system extracts the median from the ordered sequence of these three values. Clearly, the median of the health index for the entire cluster is 0.5994. Based on predefined logic, the system iterates through the sequence, forcibly extracting all nodes with a health index strictly below the median of 0.5994 as inefficient nodes. After comparison, it is found that only node C, with a value of 0.4973, meets this condition, and node C is captured by the system and added to the inefficient node pool.

[0160] For the captured inefficient node C, the system initiates a drill-down diagnostic procedure. The system extracts and compares the two main intrinsic indicators that cause node C's inefficiency: the node failure risk value is recorded as 0.1215, and the node resource idle value is recorded as -0.0747.

[0161] Through direct numerical comparison, since the positive value 0.1215 is mathematically and significantly greater than the negative number 0.0747, the system confirmed that the health decline of node C was mainly caused by frequent errors in the underlying operation (rather than simply insufficient task allocation). Based on this, the system added a fault-dominated underlying classification label to node C.

[0162] The inefficient node identifier node C, its corresponding evaluation score node health index of 0.4973, and the inefficiency type marked as fault-dominant by in-depth diagnosis are packaged into an inefficient node diagnostic information package. This information package is then formatted and output to an external operation and maintenance terminal system, thereby providing data support for data center physical investigation and hardware and software disaster recovery plans.

[0163] Figure 4This is a schematic diagram of the structure of an AI-based computing cluster performance evaluation device 300 provided in an embodiment of the present invention. The AI-based computing cluster performance evaluation device 300 can vary significantly due to different configurations or performance characteristics. It may include one or more central processing units (CPUs) 310 (e.g., one or more processors) and memory 320, and one or more storage media 330 (e.g., one or more mass storage devices) for storing application programs 333 or data 332. The memory 320 and storage media 330 can be temporary or persistent storage. The program stored in the storage media 330 may include one or more modules (not shown in the diagram), each module including a series of instruction operations on the AI-based computing cluster performance evaluation device 300. Furthermore, the processor 310 may be configured to communicate with the storage media 330 and execute the series of instruction operations in the storage media 330 on the AI-based computing cluster performance evaluation device 300.

[0164] The AI-based computing cluster efficiency evaluation device 300 may also include one or more power supplies 340, one or more wired or wireless network interfaces 350, one or more input / output interfaces 360, and / or one or more operating systems 331, such as Windows Server, Mac OS X, Unix, Linux, FreeBSD, etc. Those skilled in the art will understand that... Figure 4 The illustrated structure of the AI-based computing cluster performance evaluation device does not constitute a limitation on the AI-based computing cluster performance evaluation device. It may include more or fewer components than illustrated, or combine certain components, or have different component arrangements.

[0165] The present invention also provides an AI-based computing cluster operation efficiency evaluation device, which includes a memory and a processor. The memory stores computer-readable instructions. When the computer-readable instructions are executed by the processor, the processor performs the steps of the AI-based computing cluster operation efficiency evaluation system in the above embodiments.

[0166] The present invention also provides a computer-readable storage medium, which can be a non-volatile computer-readable storage medium or a volatile computer-readable storage medium, wherein the computer-readable storage medium stores instructions that, when the instructions are executed on a computer, cause the computer to perform the steps of the AI-based computing cluster operation efficiency evaluation system.

[0167] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0168] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0169] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. An AI-based computing cluster operation efficiency evaluation system, characterized in that, include: The data preprocessing module is used to collect the running indicator data of each computing node in the computing cluster in the current time window, and preprocess the running indicator data to obtain preprocessed running indicator data. The parameter statistics module is used to determine the node state probability of each computing node based on the preprocessed operation index data, and aggregate them to obtain the cluster state probability vector of the current time window. The initial transfer rate parameter set is obtained based on the preprocessed operation index data. The queuing loss module is used to calibrate the parameters of a preset performance evaluation model based on a preset optimization algorithm and the initial transfer rate parameter set, so that the model state probability output by the preset performance evaluation model approximates the cluster state probability vector, and obtains the calibrated transfer rate parameter set. A queuing model is constructed based on the calibrated transfer rate parameter set, and a cluster queuing loss index is calculated based on the queuing model. The index calculation module is used to obtain the reference state probability vector corresponding to the cluster state probability vector, calculate the system stability index based on the deviation between the cluster state probability vector and the reference state probability vector in the current time window, and calculate the effective resource utilization rate based on the calibrated transfer rate parameter set and the preset performance evaluation model. The comprehensive evaluation module is used to integrate the cluster queuing loss index, the system stability index, and the effective resource utilization rate to calculate the comprehensive operating efficiency index, and output the efficiency evaluation result based on the comprehensive operating efficiency index.

2. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, The operational metrics data include processor utilization, task queue length, input / output wait time, and number of task failures. The data preprocessing module is specifically used to: sequentially perform missing value filling and outlier smoothing on the operational indicator data to obtain preprocessed operational indicator data.

3. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, When the parameter statistics module determines the node state probability of each computing node based on the preprocessed operational index data and aggregates them to obtain the cluster state probability vector for the current time window, it is specifically used for: Based on the preprocessed operational index data, the membership degree of each computing node in various preset state categories is calculated using membership functions. The preset state categories include idle state, running state, blocked state, and fault state. The membership degrees are normalized to obtain the node state probabilities corresponding to each computing node. The node state probabilities of all computing nodes within the current time window are averaged according to the preset state categories to obtain the cluster state probability vector.

4. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, The initial transfer rate parameter set includes task arrival rate, service completion rate, blockage transfer rate, blockage release rate, failure rate, and failure recovery rate.

5. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, The preset optimization algorithm is the artificial bee colony algorithm, the preset performance evaluation model is the fluid Petri net model, and the queuing model is a single queue single server queuing model with a buffer capacity limit. When the queuing loss module calculates the cluster queuing loss index based on the queuing model, it is specifically used for: Calculate the steady-state queue length and blocking probability of each computing node under the queuing model; The cluster queuing loss index is obtained by summing and averaging the ratio of the steady-state queue length of each computing node to the corresponding upper limit of the buffer capacity and the blocking probability.

6. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, When calculating the system stability index, the index calculation module is specifically used to: calculate the weighted sum of squares of the offset of the cluster state probability vector relative to the reference state probability vector in the current time window, and perform a negative exponential transformation on the weighted sum of squares of the offset to obtain the Lyapunov stability as the system stability index. When the indicator calculation module calculates the effective resource utilization rate based on the calibrated transfer rate parameter set and the preset performance evaluation model, it is specifically used to: calculate the running state probability and blocking state probability of each computing node based on the calibrated transfer rate parameter set and the preset performance evaluation model; multiply the running state probability and the blocking state probability by a preset discount coefficient and sum them; and calculate the mean of all computing nodes to obtain the effective resource utilization rate.

7. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, When the index calculation module obtains the reference state probability vector corresponding to the cluster state probability vector, it is specifically used for: Obtain the historical cluster state probability vectors corresponding to a preset number of consecutive time windows before the current time window, and form a historical state probability vector sequence. Abnormal windows are identified and removed from the historical state probability vector sequence. The historical cluster state probability vectors corresponding to the remaining windows are averaged according to their respective state categories to obtain the reference state probability vector.

8. The AI-based computing cluster operation efficiency evaluation system according to claim 6, characterized in that, The specific formula for calculating the Lyapunov stability L_{stab} is as follows: ； Where j represents the state category. These correspond to the idle state, running state, blocked state, and fault state, respectively. This represents the weight corresponding to state category j; This represents the value of the cluster state probability vector in state category j for the current time window; This represents the value of the reference state probability vector in state class j.

9. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, When the comprehensive evaluation module integrates the cluster queuing loss index, the system stability index, and the effective resource utilization rate to calculate the comprehensive operating efficiency index, it is specifically used for: The queuing loss index of the cluster is transformed by a negative exponential transformation to obtain the queuing efficiency compensation value; The effective resource utilization rate, the system stability index, and the queuing efficiency compensation value are weighted and summed according to the preset dynamic adjustment weight or default weight to obtain the comprehensive operating efficiency index.

10. The AI-based computing cluster operation efficiency evaluation system according to claim 1, characterized in that, It also includes a node diagnostic module: The failure probability and idle probability of each computing node are calculated based on the preset performance evaluation model, and the node failure risk value and node resource idle value are calculated by combining the historical task failure ratio obtained based on the preprocessed operation index data. The node failure risk value is converted into a node failure risk complement value, and the node failure risk complement value is weighted and summed with the node resource idle value to obtain the node health index; Inefficient nodes are identified based on the node health index of all computing nodes, and the node failure risk value of the inefficient node is compared with the node resource idle value, and inefficient node diagnostic information containing inefficiency type label is output.

Images