Multi-node resource load prediction method and device depending on frequency domain enhancement and dynamic graph structure learning

Abstract

The invention discloses a multi-node resource load prediction method and device depending on frequency domain enhancement and dynamic graph structure learning, and belongs to the technical field of cloud computing resource management. According to the method, frequency domain enhancement and dynamic graph structure learning are combined, so that the multi-node load prediction precision and stability are remarkably improved; the method can adapt to non-stationary and emergent scenes, and is low in delay and low in overhead; online incremental reasoning and large-scale expansion are supported; time-varying adjacency and frequency band weight are generated, so that interpretation, operation and maintenance are facilitated; interfaces are clear, and integration landing is easy. Meanwhile, training instability caused by uneven feature scales is relieved, the fitting ability of a long-term trend and local peaks and valleys is improved, precision and efficiency are both considered, and deployment is easy.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of cloud computing resource management, and particularly relates to a spatiotemporal graph neural network method and system for multi-node resource load prediction, which relates to a graph neural network (GNN), a time series convolution network (TCN), and a frequency domain modeling (FFT / spectral convolution). BACKGROUND

[0002] The rapid development of cloud computing technology is driving more and more enterprises and organizations to migrate their business systems to cloud platforms to achieve resource elasticity, on-demand allocation, and cost optimization. However, the characteristics of multi-tenancy and multi-task concurrent operation in cloud platforms result in significant non-stationarity, high-frequency volatility, and burstiness of resource load, making existing scheduling and resource management mechanisms face severe challenges. Google and Microsoft platform measurement data show that CPU load changes dramatically over time and lacks predictability, significantly increasing the complexity and pressure of data centers in energy efficiency management and service quality assurance.

[0003] To alleviate the impact of high load on system operation, researchers at home and abroad have been continuously exploring more accurate load prediction methods. Existing load prediction research mainly develops along three paths: statistical regression, machine learning, and deep learning. Early methods such as ARIMA / ARMA and their integrated variants can capture linear trends and periodic patterns, but they are limited in the presence of nonlinearity and multiscale scenarios commonly found in modern cloud platforms.

[0004] Deep learning methods improve modeling capabilities for short-term and medium-term dependencies through time series convolution or memory units, and improved models based on Transformer (such as Informer, Autoformer, FEDformer, etc.) further make progress in long sequence modeling and multi-step prediction.

[0005] At the same time, as the cluster size expands, the time-varying correlation between nodes becomes a key factor affecting prediction accuracy; although spatiotemporal graph models such as STGCN and DCRNN have verified the effectiveness of graph structure in modeling cross-node dependencies, most methods default to static adjacency or rely on prior topology, making it difficult to reflect the real-time interaction between business and scheduling in cloud environments. On the other hand, there are multiscale periodicities such as daily / weekly rhythms in load sequences, and modeling in the time domain alone cannot clearly distinguish the behavior of different frequency components; existing attempts to integrate frequency domain ideas into time series models (such as sequence decomposition, Fourier transform, or neural operator framework) have shown potential, but there is still a lack of systematic solutions for the collaborative modeling of frequency domain information and dynamic graph structure.

[0006] Therefore, in order to overcome the problems of insufficient utilization of periodic features, difficulty in characterizing the dynamic evolution of node relationships over time, and insufficient spatiotemporal dependency modeling in multi-node resource load prediction under cloud computing environment, this invention proposes a frequency domain enhanced dynamic graph neural network method. By introducing spectrum modeling to improve the ability to perceive periods and trends, a dynamic structure learning mechanism is designed to capture the time-varying dependencies between nodes, and a spatiotemporal-frequency domain joint learning framework is constructed to achieve high-precision prediction and stronger generalization ability for complex non-stationary load data. Summary of the Invention

[0007] This invention addresses the problems of insufficient utilization of periodic features, difficulty in characterizing time-varying node relationships, and inadequate spatiotemporal dependency modeling by proposing a frequency-domain enhanced dynamic graph neural network to improve prediction accuracy and generalization under non-stationary, bursty, and high-frequency fluctuating loads.

[0008] The technical solution of this invention is as follows:

[0009] A multi-node resource load prediction method relying on frequency domain enhancement and dynamic graph structure learning, comprising the following steps:

[0010] S1 constructs a load dataset based on the Google Cloud Platform task_usage sub-table;

[0011] Settings: Window Length =60 seconds; historical window length L, number of nodes N, number of channels C, embedding dimension d, Top-K sparsity K; tracking starting point This is the officially defined start time for the dataset; all timestamps are from [a certain point in time]. Relative time;

[0012] S1.1 First, locate the task_usage sub-table (originally multiple .csv.gz compressed files) in the Google Cluster Trace released in 2011, and treat it as a single, very large log table stored in a distributed manner;

[0013] To avoid memory spikes caused by loading all at once, a "batch" approach is adopted: each loading round reads only a number of files, not exceeding a set limit. After completing the selection columns, time unit unification, and preliminary cleaning of this small batch, the intermediate results are written to disk, and then the next batch is read. This process is repeated until all files are processed.

[0014] The time field is uniformly defined by distance. The microseconds are converted to seconds; this is only a unit conversion and does not involve time zones. During the initial cleaning stage, column types are forced to align, records with missing key fields or unreasonable start and end times are discarded, duplicate rows are deduplicated, and quality logs are recorded for auditing. Intermediate results are saved in columnar Parquet format by time range to improve subsequent I / O efficiency. The original compressed files are preserved as is to ensure traceability. The random seed and reading order are fixed to ensure that the results can be reproduced under the same configuration.

[0015] S1.2 From the task_usage sub-table, only key fields with unified Chinese names are retained: task start time, task end time, job number, task index, running machine number, average CPU utilization, maximum CPU utilization, normalized memory usage, maximum memory usage, and average disk I / O index. These Chinese names are only used for semantic consistency and do not change the numerical caliber. For example, whether the CPU has been normalized according to the number of cores, and whether the memory unit and statistical rules are consistent with the data source facts. In the subsequent normalization step, each channel will be compressed to the [0,1] interval to eliminate the difference in units and scales.

[0016] S1.3 Next, adjust the continuous time axis according to the fixed window length. (60 seconds) Divide into a series of non-overlapping windows The feature aggregation is based on the granularity of "each machine (node) × each time window": mean features (such as average CPU or average I / O) in records falling into the same window are weighted and summed according to the time overlap ratio between the record and the window; the maximum feature (such as maximum CPU or maximum memory) in records falling into the same window is taken as the maximum value within that window; if a machine is completely missing in some time windows, it is aligned and filled according to the forward priority rule, and the maximum filling span is set to no more than 5 time windows. If the span exceeds the limit, it is still considered missing and replaced by the global median in the future. If the forward value is old (>3 windows and not as recent as the backward value), the backward value is used instead; in order to suppress the impact of extreme values ​​on statistical stability, each channel is gently pruned by 1%–99% (Winsorize) to ensure that each node can give a feature vector with consistent dimensions and stable values ​​under the same time window;

[0017] S1.4 After the aggregation of all machines and all time windows is completed, stack the feature vectors into a load tensor in machine and time order. Subsequently, the minimum / maximum value for each channel is calculated based solely on the training set. Perform Min–Max normalization on all samples to obtain scale-uniform and numerically stable input: ; This allows us to obtain the load dataset. This not only mitigates the conflicts in measurement caused by different resource definitions, but also lays the foundation for subsequent "equal-weight modeling" (strictly reusing training set statistics during the verification / testing phase to avoid data leakage).

[0018] S2 takes the normalized load tensor output from step S1. As input, dynamic node embedding computation is performed to extract compact representations from time series fragments that can be reused in subsequent spatial structure learning; the entire process maintains consistency with the time alignment and missing data handling strategy in step S1 to avoid caliber drift.

[0019] S2.1 Apply a length of [length] to each node on the timeline. The sliding window will display the most recent Normalized load tensor at each time step Direct slicing And ensure that the same time alignment and padding strategy as step S1 is used throughout; in order to suppress the impact of occasional spikes on the embedding, median filtering is applied in the fragment dimension to smooth single-point anomalies, and finally a set of historical time series fragments with equal length and dimension across nodes and at the same time is obtained, which is convenient for subsequent parallel processing and comparison.

[0020] S2.2 To convert historical time series segments into fixed-length vectors and feed them into the representation model, the vectors are arranged in a fixed order: channel first, time second. Expanding on the previous approach, when the dimensionality is high, a linear transformation is first applied to reduce it to an intermediate dimension to mitigate dimensionality explosion and numerical instability, before feeding it into a multilayer perceptron network composed of several fully connected layers. A multilayer perceptron network is employed. Extract the dynamic embedding representation of the node at this moment ReLU activation, layer normalization, and a set percentage of discarding are uniformly adopted between layers: ,in, This represents an MLP network with an activation function. This is the embedding dimension. The embedding vector is used to capture an abstract feature representation of the node's current load state;

[0021] S2.3 embeds all nodes at the same time and stacks them in machine number order to obtain... The embedding sequence is formed by rolling along time and advancing over time. To meet the timeliness requirements of online inference, a sliding update mechanism is adopted: the expansion and forward results of historical moments are cached, and only the fragment update and forward mapping are performed for the newly added time step. The remaining historical embeddings are directly reused, thereby bringing the incremental computational overhead per unit time close to the constant level.

[0022] After receiving the dynamic nodes output from step S2, S3 uses two sets of learnable linear mappings to form source and target representations respectively, thereby explicitly distinguishing the information sender and receiver. Based on this, it learns direction-sensitive dependencies in the same semantic space and constructs a time-varying directed graph. The specific steps are as follows:

[0023] S3.1 At time t, for Left-multiply by two sets of learnable matrices or , obtain source end representation Representation of the target end Both share node semantics but are in a direction-sensitive embedding space, which is beneficial for capturing asymmetric dependencies;

[0024] S3.2 In the above space, calculate the relation strength using the matrix inner product. Subsequently, a non-negative initial relational graph was obtained by suppressing negative values ​​using ReLU. This approach, which first uses linear similarity and then nonlinear truncation, reduces the interference of noise and anomalous fluctuations on structure learning while ensuring computational efficiency. Specifically, it first uses similarity to determine the route and then uses a threshold to determine whether to switch strategies.

[0025] S3.3 To transform the weights into a probabilistic outgoing edge distribution that can be used for message passing, for The adjacency matrix is ​​obtained by performing Softmax row by row. When it is necessary to control computational complexity or improve robustness, only the row with the largest weight should be retained. The edges are then renormalized according to the retained weights to obtain a sparse and stable time-varying directed graph structure for subsequent graph convolution.

[0026] S4 performs a Fast Fourier Transform (FFT) along the time dimension on the node features in the time domain to obtain a spectral representation. Learnable weights are then introduced in the frequency domain for element-wise modulation to achieve adaptive filtering and amplification. Finally, an Inverse Fast Fourier Transform (IFFT) is used to restore the frequency domain, resulting in frequency domain enhancement features that are equivalent to time domain convolution but calculated more efficiently. The system maintains stability on the numerical scale through lightweight residuals and normalization. The specific steps are as follows:

[0027] S4.1 Perform a Fast Fourier Transform (FFT) along the time dimension for each node and each channel to decompose the temporal energy of each node into different frequency components. Subsequently, the frequency domain information is convolved through a predefined frequency domain filter (a learnable spectral weight matrix) to capture the feature patterns of the node sequence in different frequency ranges.

[0028] S4.2 introduces and in the frequency domain Isomorphic learnable weights Element-wise multiplication yields Intuitively, this is equivalent to setting data-driven passbands and stopbands for different frequency bands: important main periods are emphasized, while unstable high-frequency noise or low-frequency drift is suppressed, thus injecting "sensitivity to period" into the features.

[0029] S4.3 Perform an inverse fast Fourier transform (IFFT) on the weighted spectrum to restore it to the time domain, and combine this with lightweight residuals and layer normalization to stabilize the numerical scale, thus obtaining the enhanced time domain features: ,in It is the input time-domain sequence (e.g., a node in a sequence of length ). (A segment containing multiple channels). For element-wise multiplication; This is the inverse fast Fourier transform; For layer normalization, the output is the frequency domain enhanced feature, which will be fused with the spatial interaction result of graph convolution at the block level.

[0030] S5 Constructs FEDG for Multi-Node Load Prediction: Establishes an end-to-end spatiotemporal-frequency domain joint prediction process, and completes the overall design and implementation from structured modeling of historical load, feature extraction and fusion to the final prediction output;

[0031] S5.1 The time-varying adjacency matrix output in step S3 For the message-passing structure, graph convolution is performed on the temporal features to aggregate the representations of adjacent nodes to the central node according to their weights. Then, a spatial interaction update is completed through linear transformation and nonlinear activation.

[0032]

[0033] in To form a symmetric or row-normalized matrix after adding self-loops, For activation functions;

[0034] To expand the spatial receptive field and maintain training stability, S5.2 stacks several dynamic graph convolutions layer by layer and adds residual connections and normalization between layers to alleviate the gradient vanishing / exploding problem, enabling the model to learn the dependencies between distant nodes at a deep level without overfitting.

[0035] S5.3 Output graph convolution at the block level The frequency domain enhancement features obtained in step S4 Perform element-wise addition and apply layer normalization:

[0036]

[0037] This results in a fused representation that simultaneously possesses periodic awareness (frequency domain) and spatial interaction (graph convolution), which serves as the final output of this block and is fed into subsequent blocks or prediction heads to regress the future. Step load;

[0038] S5.4 In online inference, the structure and features cached from the previous time step are reused, and only one graph convolution forward pass and lightweight structure update are performed for the newly arrived time step (e.g., for...). and (Incremental computation), thereby keeping the additional computation cost at each moment at a constant level, meeting the real-time requirements in scenarios with rapidly changing loads;

[0039] S6. During the training phase, with the most recent Using multi-node historical data as input, predict the future. The target load for each step (which can be a single channel such as CPU or multiple channels combined) is monitored on the validation set using error metrics (such as MAE, RMSE, MAPE), and an early stopping strategy is used to avoid overfitting. When the accuracy on the test set is insufficient, optimizer hyperparameters such as the learning rate and weight decay are adjusted first, followed by adjustments to the window length L, the sharing / independent strategy of frequency domain weights, and other parameters. Sparsity, number of graph convolutional layers and hidden dimensions, dropout rate and normalization location, and pruning quantiles and missing fill rules in step S1; the entire process adheres to using only training set statistics for normalization, fixing the random seed and solidifying key components (such as... (Model weights and configuration) to ensure that the results are reproducible and the deployment is traceable.

[0040] A multi-node resource load prediction device relying on frequency domain enhancement and dynamic graph structure learning includes: at least one processor, and a memory communicatively connected to the at least one processor;

[0041] The memory stores instructions that can be executed by the processor, which are then executed by the at least one processor to perform the aforementioned multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning.

[0042] The beneficial effects of this invention are as follows: This invention combines frequency domain enhancement with dynamic graph structure learning, significantly improving the accuracy and stability of multi-node load prediction; it can adapt to non-stationary and bursty scenarios, with low latency and low overhead; it supports online incremental inference and large-scale expansion; it generates time-varying adjacency and frequency band weights, facilitating interpretation and maintenance; the interface is clear and easy to integrate and implement. Simultaneously, it mitigates training instability caused by uneven feature scales, improves the fitting ability of long-term trends and local peaks and valleys, balancing accuracy and efficiency, and is easy to deploy. Attached Figure Description

[0043] Figure 1 This is a diagram of the overall model structure based on the deep convolutional neural network FEDG;

[0044] Figure 2 Flowchart for generating historical load nodes;

[0045] Figure 3 A flowchart for generating the adjacency matrix;

[0046] Figure 4 This is a graph showing the variation of eigenvalues ​​over time.

[0047] Figure 5 MAE heatmap for each node;

[0048] Figure 6 The comparison diagram shows the FEDG algorithm with other popular prediction algorithms, where (a) represents low error nodes, (b) represents low to medium error nodes, (c) represents medium error nodes, and (d) represents high error nodes. Detailed Implementation

[0049] The specific embodiments of the present invention will be further described below with reference to the accompanying drawings and technical solutions.

[0050] This invention addresses the problems of insufficient utilization of periodic features, difficulty in characterizing time-varying node relationships, and inadequate spatiotemporal dependency modeling by proposing a frequency-domain enhanced dynamic graph neural network to improve prediction accuracy and generalization under non-stationary, bursty, and high-frequency fluctuating loads.

[0051] The preprocessed data of this invention are as follows Figure 1 As shown, the specific steps are as follows:

[0052] S1 constructs a load dataset based on the Google Cloud Platform task_usage sub-table;

[0053] Settings: Window Length =60 seconds; historical window length L, number of nodes N, number of channels C, embedding dimension d, Top-K sparsity K; tracking starting point This is the officially defined start time for the dataset; all timestamps are from [a certain point in time]. Relative time;

[0054] S1.1 First, locate the task_usage sub-table (originally multiple .csv.gz compressed files) in the Google Cluster Trace released in 2011, and treat it as a single, very large log table stored in a distributed manner;

[0055] To avoid memory spikes caused by loading all at once, a "batch" approach is adopted: each loading round reads only a number of files, not exceeding a set limit. After completing the selection columns, time unit unification, and preliminary cleaning of this small batch, the intermediate results are written to disk, and then the next batch is read. This process is repeated until all files are processed.

[0056] The time field is uniformly converted from microseconds to seconds from t0. This is only a unit conversion and does not involve time zones. During the initial cleaning stage, column types are forced to align, records with missing key fields or unreasonable start and end times are discarded, and duplicate rows are deduplicated and recorded in the quality log for auditing. Intermediate results are saved in columnar Parquet format by time range to improve subsequent I / O efficiency. The original compressed file is retained as is to ensure traceability. The random seed and reading order are fixed to ensure that the results can be reproduced under the same configuration.

[0057] S1.2 From the task_usage sub-table, only key fields with unified Chinese names are retained: task start time, task end time, job number, task index, running machine number, average CPU utilization, maximum CPU utilization, normalized memory usage, maximum memory usage, and average disk I / O index. These Chinese names are only used for semantic consistency and do not change the numerical caliber. For example, whether the CPU has been normalized according to the number of cores, and whether the memory unit and statistical rules are consistent with the data source facts. In the subsequent normalization step, each channel will be compressed to the [0,1] interval to eliminate the difference in units and scales.

[0058] S1.3 Next, adjust the continuous time axis according to the fixed window length. (60 seconds) Divide into a series of non-overlapping windows The feature aggregation is based on the granularity of "each machine (node) × each time window": mean features (such as average CPU or average I / O) in records falling into the same window are weighted and summed according to the time overlap ratio between the record and the window; the maximum feature (such as maximum CPU or maximum memory) in records falling into the same window is taken as the maximum value within that window; if a machine is completely missing in some time windows, it is aligned and filled according to the forward priority rule, and the maximum filling span is set to no more than 5 time windows. If the span exceeds the limit, it is still considered missing and replaced by the global median in the future. If the forward value is old (>3 windows and not as recent as the backward value), the backward value is used instead; in order to suppress the impact of extreme values ​​on statistical stability, each channel is gently pruned by 1%–99% (Winsorize) to ensure that each node can give a feature vector with consistent dimensions and stable values ​​under the same time window;

[0059] S1.4 After the aggregation of all machines and all time windows is completed, stack the feature vectors into a load tensor in machine and time order. Subsequently, the minimum / maximum value for each channel is calculated based solely on the training set. Perform Min–Max normalization on all samples to obtain scale-uniform and numerically stable input: ; This allows us to obtain the load dataset. This not only mitigates the conflicts in measurement caused by different resource definitions, but also lays the foundation for subsequent "equal-weight modeling" (strictly reusing training set statistics during the verification / testing phase to avoid data leakage).

[0060] Among them, the generation of historical load nodes is as follows Figure 2 The specific steps are as follows:

[0061] S2 takes the normalized load tensor output from step S1. As input, dynamic node embedding computation is performed to extract compact representations from time series fragments that can be reused in subsequent spatial structure learning; the entire process maintains consistency with the time alignment and missing data handling strategy in step S1 to avoid caliber drift.

[0062] S2.1 Apply a length of [length] to each node on the timeline. The sliding window will display the most recent Normalized load tensor at each time step Direct slicing And ensure that the same time alignment and padding strategy as step S1 is used throughout; in order to suppress the impact of occasional spikes on the embedding, median filtering is applied in the fragment dimension to smooth single-point anomalies, and finally a set of historical time series fragments with equal length and dimension across nodes and at the same time is obtained, which is convenient for subsequent parallel processing and comparison.

[0063] S2.2 To convert historical time series segments into fixed-length vectors and feed them into the representation model, the vectors are arranged in a fixed order: channel first, time second. Expanding on the previous approach, when the dimensionality is high, a linear transformation is first applied to reduce it to an intermediate dimension to mitigate dimensionality explosion and numerical instability, before feeding it into a multilayer perceptron network composed of several fully connected layers. A multilayer perceptron network is employed. Extract the dynamic embedding representation of the node at this moment ReLU activation, layer normalization, and a set percentage of discarding are uniformly adopted between layers: ,in, This represents an MLP network with an activation function. This is the embedding dimension. The embedding vector is used to capture an abstract feature representation of the node's current load state;

[0064] S2.3 embeds all nodes at the same time and stacks them in machine number order to obtain... The embedding sequence is formed by rolling along time and advancing over time. To meet the timeliness requirements of online inference, a sliding update mechanism is adopted: the expansion and forward results of historical moments are cached, and only the fragment update and forward mapping are performed for the newly added time step. The remaining historical embeddings are directly reused, thereby bringing the incremental computational overhead per unit time close to the constant level.

[0065] Generating a dynamic adjacency matrix, such as Figure 3 As shown, the steps are as follows:

[0066] After receiving the dynamic nodes output from step S2, S3 uses two sets of learnable linear mappings to form source and target representations respectively, thereby explicitly distinguishing the information sender and receiver. Based on this, it learns direction-sensitive dependencies in the same semantic space and constructs a time-varying directed graph. The specific steps are as follows:

[0067] S3.1 At time t, for Left-multiply by two sets of learnable matrices or , obtain source end representation Representation of the target end Both share node semantics but are in a direction-sensitive embedding space, which is beneficial for capturing asymmetric dependencies;

[0068] S3.2 In the above space, calculate the relation strength using the matrix inner product. Subsequently, a non-negative initial relational graph was obtained by suppressing negative values ​​using ReLU. This approach, which first uses linear similarity and then nonlinear truncation, reduces the interference of noise and anomalous fluctuations on structure learning while ensuring computational efficiency. Specifically, it first uses similarity to determine the route and then uses a threshold to determine whether to switch strategies.

[0069] S3.3 To transform the weights into a probabilistic outgoing edge distribution that can be used for message passing, for The adjacency matrix is ​​obtained by performing Softmax row by row. When it is necessary to control computational complexity or improve robustness, only the row with the largest weight should be retained. The edges are then renormalized according to the retained weights to obtain a sparse and stable time-varying directed graph structure for subsequent graph convolution.

[0070] S4 performs a Fast Fourier Transform (FFT) along the time dimension on the node features in the time domain to obtain a spectral representation. Learnable weights are then introduced in the frequency domain for element-wise modulation to achieve adaptive filtering and amplification. Finally, an Inverse Fast Fourier Transform (IFFT) is used to restore the frequency domain, resulting in frequency domain enhancement features that are equivalent to time domain convolution but calculated more efficiently. The system maintains stability on the numerical scale through lightweight residuals and normalization. The specific steps are as follows:

[0071] S4.1 Perform a Fast Fourier Transform (FFT) along the time dimension for each node and each channel to decompose the temporal energy of each node into different frequency components. Subsequently, the frequency domain information is convolved through a predefined frequency domain filter (a learnable spectral weight matrix) to capture the feature patterns of the node sequence in different frequency ranges.

[0072] S4.2 introduces and in the frequency domain Isomorphic learnable weights Element-wise multiplication yields Intuitively, this is equivalent to setting data-driven passbands and stopbands for different frequency bands: important main periods are emphasized, while unstable high-frequency noise or low-frequency drift is suppressed, thus injecting "sensitivity to period" into the features.

[0073] S4.3 Perform an inverse fast Fourier transform (IFFT) on the weighted spectrum to restore it to the time domain, and combine this with lightweight residuals and layer normalization to stabilize the numerical scale, thus obtaining the enhanced time domain features: ,in It is the input time-domain sequence (e.g., a node in a sequence of length ). (A segment containing multiple channels). For element-wise multiplication; This is the inverse fast Fourier transform; For layer normalization, the output is the frequency domain enhanced feature, which will be fused with the spatial interaction result of graph convolution at the block level.

[0074] like Figure 4 As shown, a multi-node resource load prediction method relying on frequency domain enhancement and dynamic graph structure learning has the following specific steps:

[0075] S5 Constructs FEDG for Multi-Node Load Prediction: Establishes an end-to-end spatiotemporal-frequency domain joint prediction process, and completes the overall design and implementation from structured modeling of historical load, feature extraction and fusion to the final prediction output;

[0076] S5.1 The time-varying adjacency matrix output in step S3 For the message-passing structure, graph convolution is performed on the temporal features to aggregate the representations of adjacent nodes to the central node according to their weights. Then, a spatial interaction update is completed through linear transformation and nonlinear activation.

[0077]

[0078] in To form a symmetric or row-normalized matrix after adding self-loops, For activation functions;

[0079] To expand the spatial receptive field and maintain training stability, S5.2 stacks several dynamic graph convolutions layer by layer and adds residual connections and normalization between layers to alleviate the gradient vanishing / exploding problem, enabling the model to learn the dependencies between distant nodes at a deep level without overfitting.

[0080] S5.3 Output graph convolution at the block level The frequency domain enhancement features obtained in step S4 Perform element-wise addition and apply layer normalization:

[0081]

[0082] This results in a fused representation that simultaneously possesses periodic awareness (frequency domain) and spatial interaction (graph convolution), which serves as the final output of this block and is fed into subsequent blocks or prediction heads to regress the future. Step load;

[0083] S5.4 In online inference, the structure and features cached from the previous time step are reused, and only one graph convolution forward pass and lightweight structure update are performed for the newly arrived time step (e.g., for...). and (Incremental computation), thereby keeping the additional computation cost at each moment at a constant level, meeting the real-time requirements in scenarios with rapidly changing loads;

[0084] S6. During the training phase, with the most recent Using multi-node historical data as input, predict the future. The target load for each step (which can be a single channel such as CPU or multiple channels combined) is monitored on the validation set using error metrics (such as MAE, RMSE, MAPE), and an early stopping strategy is used to avoid overfitting. When the accuracy on the test set is insufficient, optimizer hyperparameters such as the learning rate and weight decay are adjusted first, followed by adjustments to the window length L, the sharing / independent strategy of frequency domain weights, and other parameters. Sparsity, number of graph convolutional layers and hidden dimensions, dropout rate and normalization location, and pruning quantiles and missing fill rules in step S1; the entire process adheres to using only training set statistics for normalization, fixing the random seed and solidifying key components (such as... (Model weights and configuration) to ensure that the results are reproducible and the deployment is traceable.

[0085] The beneficial effects of this invention are as follows: This invention combines frequency domain enhancement with dynamic graph structure learning, significantly improving the accuracy and stability of multi-node load prediction; it can adapt to non-stationary and bursty scenarios, with low latency and low overhead; it supports online incremental inference and large-scale expansion; it generates time-varying adjacency and frequency band weights, facilitating interpretation and maintenance; the interface is clear and easy to integrate and implement. Simultaneously, it mitigates training instability caused by uneven feature scales, improves the fitting ability of long-term trends and local peaks and valleys, balancing accuracy and efficiency, and is easy to deploy.

[0086] like Figure 5 and Figure 6 The image shows the training method for training sub-nodes using this algorithm. The specific steps are as follows:

[0087] To verify the effectiveness of the proposed FEDG model, this paper conducts extensive experiments and comparative analyses on the Google Cluster dataset. To validate the comprehensive advantages of FEDG, this paper supplements the analysis with a system comparison across strong family baselines under a unified protocol. Evaluation metrics include commonly used performance indicators such as mean squared error (MSE), mean absolute error (MAE), and coefficient of determination (R²). The prediction time for 1000 machines is also statistically analyzed. Specific results are shown in Table 1.

[0088] Table 1 Comparison of experimental results for different models

[0089]

[0090] S7.1 To further analyze the adaptability of the proposed FEDG model on different types of nodes, four representative nodes were selected from the test set according to error level, and the MAE of each node was mapped to a two-dimensional heatmap (corresponding to...). Figure 5 The color intensity indicates the magnitude of the error, visually displaying the distribution and clustering areas of the error in the node space, which facilitates the rapid location of high-error nodes and potential anomaly clusters.

[0091] S7.2 Stratified sampling is performed from the test set according to the error stratification threshold (MAE < 0.10, 0.10–0.20, 0.20–0.30, MAE ≥ 0.35), and four representative nodes are selected and labeled as (a), (b), (c), and (d) to ensure that the test cases cover different load types from low dynamics to strong non-stationary loads.

[0092] S7.3 Plot the true trajectory and multi-model prediction curves (FEDG, STGCN+MLP, STGCN+TCN, STGCN+LSTM, etc.) for nodes (a)–(d), respectively. Figure 6 The horizontal axis represents the time step, and the vertical axis represents the normalized CPU utilization rate, ensuring time alignment and comparability with the same units, thereby enabling fine-grained comparisons on a node-by-node and time-by-time basis.

[0093] S7.4 Based on curve comparison, the following conclusions are drawn for each node: Node (a) shows that all models fit well in low-dynamic scenarios, but FEDG responds faster at inflection points and fits fine fluctuations better; Node (b) shows more short-term fluctuations, and FEDG and STGCN+MLP can capture the direction of mutations, while STGCN+LSTM / TCN has lag or misestimation, and traditional GCN is over-smoothed; Node (c) shows obvious periodicity and large peaks and troughs, and FEDG is more accurate in amplitude and phase, while LSTM lags and TCN / MLP has trend shift; Node (d) is strongly non-stationary and has frequent sudden changes, with most models shifting significantly, while FEDG still maintains the overall trend consistency, with only slight lag at extreme values, and has the best robustness.

Claims

1. A multi-node resource load prediction method relying on frequency domain enhancement and dynamic graph structure learning, characterized in that, The steps are as follows: S1 constructs a load dataset based on the Google Cloud Platform task_usage sub-table; S2 takes the normalized load tensor output from step S1 as input and performs dynamic node embedding calculation to extract compact representations that can be reused in subsequent spatial structure learning from time series segments; the whole process is consistent with the time alignment and missing handling strategy of step S1 to avoid caliber drift. After receiving the dynamic nodes output from step S2, S3 uses two sets of learnable linear mappings to form source and target representations for them respectively, thereby explicitly distinguishing the information sender and the information receiver. Based on this, it learns direction-sensitive dependencies in the same semantic space and constructs a time-varying directed graph. S4 performs a Fast Fourier Transform (FFT) along the time dimension on the node features in the time domain to obtain a spectral representation. Learnable weights are then introduced in the frequency domain for element-wise modulation to achieve adaptive filtering and amplification. Finally, an Inverse Fast Fourier Transform (IFT) is used to restore the frequency domain to the time domain, resulting in frequency domain enhancement features that are equivalent to time-domain convolution but calculated more efficiently. The system maintains stability on the numerical scale through lightweight residuals and normalization. S5 Constructs FEDG for Multi-Node Load Prediction: Establishes an end-to-end spatiotemporal-frequency domain joint prediction process, and completes the overall design and implementation from structured modeling of historical load, feature extraction and fusion to the final prediction output; S6. During the training phase, the multi-node history of the most recent step is used as input to predict the target load of the future step. Error metrics are used to monitor performance on the validation set, and an early stopping strategy is employed to avoid overfitting. When the accuracy of the test set is insufficient, the learner hyperparameters such as learning rate and weight decay are adjusted first, followed by adjustments to the window length L, the sharing / independence strategy and sparsity of frequency domain weights, the number of graph convolutional layers and hidden dimensions, the dropout rate and normalization position, as well as the pruning quantiles and missing fill rules in step S1. Throughout the process, only training set statistics are used for normalization, random seeds are fixed, and key components are solidified to ensure that the results are reproducible and traceable upon deployment.

2. The multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning according to claim 1, characterized in that, The specific steps of S1 are as follows: Settings: Window length; historical window length L, number of nodes N, number of channels C, embedding dimension d, Top-K sparsity K; tracking starting point This is the officially defined start time for the dataset; all timestamps are from [a certain point in time]. Relative time; S1.1 First, locate the task_usage sub-table in Google Cluster Trace and store it separately as a single, very large log table; Each loading cycle reads only a limited number of files, up to the set limit. After completing the selection of columns, unification of time units, and preliminary cleaning of this small batch, the intermediate results are written to disk, and then the next batch is read. This process is repeated until all files are processed. The time field is uniformly converted from microseconds to seconds from t0. This is only a unit conversion and does not involve time zones. During the initial cleaning stage, column types are forced to align, records with missing key fields or unreasonable start and end times are discarded, and duplicate rows are deduplicated and recorded in the quality log for auditing. Intermediate results are saved in columnar Parquet format by time range to improve subsequent I / O efficiency. The original compressed file is retained as is to ensure traceability. The random seed and reading order are fixed to ensure that the results can be reproduced under the same configuration. S1.2 Only key fields in the task_usage sub-table are retained and uniformly named in Chinese: task start time, task end time, job number, task index, running machine number, average CPU utilization, maximum CPU utilization, normalized memory usage, maximum memory usage, and average disk I / O index. These Chinese names are only used for semantic consistency and do not change the numerical caliber. They will only be compressed to the [0,1] interval in the uniform normalization step to eliminate differences in units and scales. S1.3 Next, adjust the continuous time axis according to the fixed window length. Divide into a series of non-overlapping windows The feature aggregation is based on the granularity of "each machine × each time window": the mean class features in the records falling into the same window are weighted and summed according to the time overlap ratio between the records and the window; the maximum class feature in the records falling into the same window is taken as the maximum value within the window; if a machine is completely missing in some time windows, it is aligned and filled according to the forward priority rule and the maximum filling span is set to no more than 5 time windows. If the span exceeds the limit, it is still considered missing and replaced by the global median in the future. If the forward value is outdated, the backward value is used instead. S1.4 After the aggregation of all machines and all time windows is completed, the feature vectors are stacked into a load tensor in machine and time order; then, the minimum / maximum value of each channel is calculated only based on the training set, and Min-Max normalization is performed on all samples to obtain a scale-uniform and numerically stable input: ; Obtain the load dataset.

3. The multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning according to claim 1, characterized in that, Step S2 is as follows: S2.1 Apply a length of [length] to each node on the timeline. The sliding window will display the most recent Normalized load tensor at each time step Direct slicing And ensure that the same time alignment and padding strategy as step S1 is used throughout; in order to suppress the impact of occasional spikes on the embedding, median filtering is applied in the fragment dimension to smooth single-point anomalies, and finally a set of historical time series fragments with equal length and dimension across nodes and at the same time is obtained, which is convenient for subsequent parallel processing and comparison. S2.2 To convert historical time series segments into fixed-length vectors and feed them into the representation model, the vectors are arranged in a fixed order: channel first, time second. Expanding; when the dimension is large, it is first reduced to an intermediate dimension through a linear transformation to alleviate dimensionality explosion and numerical instability, and then fed into a multilayer perceptron network composed of several fully connected layers; using a multilayer perceptron network Extract the dynamic embedding representation of the node at this moment ReLU activation, layer normalization, and a set percentage of discarding are uniformly adopted between layers: ,in, This represents an MLP network with an activation function. This is the embedding dimension; the embedding vector is used to capture an abstract feature representation of the node's current load state. S2.3 embeds all nodes at the same time and stacks them in machine number order to obtain... The embedding sequence is formed by rolling along time. To meet the timeliness requirements of online inference, a sliding update mechanism is adopted: the expansion and forward results of historical moments are cached, and only the fragment update and forward mapping are performed for the newly added time step. The remaining historical embeddings are directly reused, thereby bringing the incremental computational cost per unit time close to the constant level.

4. The multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning according to claim 1, characterized in that, Step S3 is as follows: The specific steps are as follows: S3.1 At time t, for Left-multiply by two sets of learnable matrices or , obtain source end representation Representation of the target end Both share node semantics but are in a direction-sensitive embedding space, which is beneficial for capturing asymmetric dependencies; S3.2 In the above space, calculate the relation strength using the matrix inner product. Subsequently, a non-negative initial relational graph was obtained by suppressing negative values ​​using ReLU. This approach, which first uses linear similarity and then nonlinear truncation, reduces the interference of noise and anomalous fluctuations on structure learning while ensuring computational efficiency. Specifically, it first uses similarity to determine the route and then uses a threshold to determine whether to switch strategies. S3.3 To transform the weights into a probabilistic outgoing edge distribution that can be used for message passing, for Softmax is performed row by row to obtain the adjacency matrix. When it is necessary to control computational complexity or improve robustness, only the row with the largest weight should be retained. The edges are then renormalized according to the retained weights to obtain a sparse and stable time-varying directed graph structure for subsequent graph convolution.

5. The multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning according to claim 1, characterized in that, Step S4 is as follows: The specific steps are as follows: S4.1 Perform a Fast Fourier Transform (FFT) along the time dimension for each node and each channel to decompose the temporal energy of each node into different frequency components. Then, perform a convolution operation on the frequency domain information through a predefined frequency domain filter to capture the feature patterns of the node sequence in different frequency ranges. S4.2 introduces and in the frequency domain Isomorphic learnable weights Element-wise multiplication yields ; S4.3 Perform an inverse fast Fourier transform (IFFT) on the weighted spectrum to restore it to the time domain, and combine this with lightweight residuals and layer normalization to stabilize the numerical scale, thus obtaining the enhanced time domain features: ,in It is the input time-domain sequence; For element-wise multiplication; This is the inverse fast Fourier transform; For layer normalization, the output is the frequency domain enhanced feature, which will be fused with the spatial interaction result of graph convolution at the block level.

6. The multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning according to claim 1, characterized in that, Step S5 is as follows: S5.1 The time-varying adjacency matrix output in step S3 For the message-passing structure, graph convolution is performed on the temporal features to aggregate the representations of adjacent nodes to the central node according to their weights. Then, a spatial interaction update is completed through linear transformation and nonlinear activation. ； in To form a symmetric or row-normalized matrix after adding self-loops, For activation functions; To expand the spatial receptive field and maintain training stability, S5.2 stacks several dynamic graph convolutions layer by layer and adds residual connections and normalization between layers to alleviate the gradient vanishing / exploding problem, enabling the model to learn the dependencies between distant nodes at a deep level without overfitting. S5.3 Outputs graph convolution at the block level The frequency domain enhancement features obtained in step S4 Perform element-wise addition and apply layer normalization: ； This results in a fused representation that simultaneously possesses periodic perception and spatial interaction, which serves as the final output of this block and is fed into subsequent blocks or prediction heads to regress the future. Step load; In online inference, S5.4 reuses the structure and features cached in the previous time step, and only performs a graph convolution forward pass and a lightweight structure update once for the newly arrived time step, thereby keeping the additional computational cost at each time step at a constant level and meeting the real-time requirements of scenarios with rapidly changing loads.

7. A multi-node resource load prediction device relying on frequency domain enhancement and dynamic graph structure learning, comprising: At least one processor, and a memory communicatively connected to said at least one processor; The memory stores instructions executable by the processor, which are executed by the at least one processor to cause the at least one processor to perform a multi-node resource load prediction method based on frequency domain enhancement and dynamic graph structure learning as described in any one of claims 1-6.

Images