A graphics card workstation intelligent configuration method based on big data analysis

Abstract

This invention discloses an intelligent configuration method for graphics card workstations based on big data analysis, comprising: S1, collecting data and features to generate an original holographic runtime dataset; S2, constructing a three-dimensional heterogeneous tensor matrix, extracting the kernel tensor and factor matrix using HOSVD decomposition, and generating a deep computing power feature vector; S3, constructing a computing power feature profile library, calculating similarity to identify task load pressure patterns, and outputting a target task feature profile; S4, generating a preliminary configuration scheme using an improved WGAN-GP model, and introducing a manifold regularization projection mechanism to filter candidate configuration subsets; S5, parsing and obtaining hard constraints, and matching the final configuration parameters; S6, issuing configuration parameters and collecting real-time load data for dynamic correction; S7, constructing incremental samples to feed back into the original dataset, and performing continuous iterative self-optimization. This invention achieves accurate matching of graphics card resources and task load, effectively improving the computing power utilization efficiency of the workstation.

Description

Technical Field

[0001] This invention relates to the fields of big data analytics and the Internet of Things (IoT), and in particular to a method for intelligent configuration of graphics card workstations based on big data analytics. Background Technology

[0002] Generative adversarial networks (GANs), with their ability to model and generate samples from high-dimensional and complex probability distributions, have been widely applied in recent years in fields such as smart hardware selection, computing resource scheduling, and automated system design, becoming an important technical means to achieve automated optimization of device parameters. However, in practical applications, intelligent configuration of computing resources faces many challenges, such as the exponential growth of hardware parameter combinations, drastic fluctuations in application task load, and stringent physical engineering constraints. The deployment effectiveness of GANs is still limited by many factors.

[0003] Currently, most intelligent configuration methods rely on traditional expert rule bases or simple linear programming algorithms for parameter recommendation, making it difficult to fully utilize multi-source information such as underlying operational status data, software environment characteristics, and historical performance records. This results in a lack of comprehensive modeling of computing resources. Some systems only use the highest efficiency or lowest cost as optimization objectives, ignoring the combined impact of multi-dimensional hard constraints such as user budget limitations, physical space size, and energy consumption control requirements. This limits the practical implementation capability of configuration solutions and user satisfaction. Furthermore, the configuration generation process lacks mathematical constraints on physical feasibility, making it difficult to provide users or the system with configuration basis that conforms to physical laws, affecting the usability and credibility of the generated results in a real physical environment.

[0004] Furthermore, existing generative adversarial network models mostly use statically designed loss functions and discrimination mechanisms in parameter generation, failing to introduce manifold projection mechanisms to effectively constrain infeasible regions in the parameter space. This results in some generated parameter points diverging into physically infeasible regions, leading to situations that violate hardware common sense, such as abnormal memory capacity or extreme core frequency values. This makes it difficult to adapt to complex and ever-changing business needs, seriously affecting the practical value and stability of the model in real-world scenarios.

[0005] Therefore, how to provide a method for intelligent configuration of graphics card workstations based on big data analysis is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0006] One objective of this invention is to propose an intelligent configuration method for graphics card workstations based on big data analysis. This invention fully integrates key steps such as holographic runtime data construction, HOSVD algorithm tensor decomposition, improved WGAN-GP model generation and manifold regularization projection constraints, and Pareto multi-objective optimization. It constructs a configuration generation process with spatiotemporal alignment denoising, deep computational feature extraction, parametric manifold forced projection, and multi-constraint adaptive matching, achieving optimal configuration of graphics card resources in complex hardware environments. This invention introduces an improved WGAN-GP model with a manifold regularization projection mechanism, using orthogonal projection layers to calculate normal vectors and force divergent parameters back to the manifold surface. This model possesses advantages such as strong nonlinear coupling capability in feature extraction, high physical feasibility of the configuration scheme, good balance in multi-objective decision-making, and high accuracy in constraint matching. It can significantly improve the generation quality and physical robustness of configuration parameters, thereby effectively solving problems such as insufficient feature mining, generation parameters violating physical laws, and low matching degree with user needs in existing methods.

[0007] A method for intelligent configuration of a graphics card workstation based on big data analysis according to an embodiment of the present invention includes the following steps:

[0008] S1. Synchronously collect multi-dimensional graphics card running fingerprint data and associated application software environment characteristics to generate the original holographic running state dataset;

[0009] S2. Preprocess the original holographic running state dataset, construct a three-dimensional heterogeneous tensor matrix, use the HOSVD algorithm to perform multilinear algebraic decomposition, extract the kernel tensor and factor matrices of each dimension that characterize the nonlinear coupling relationship between graphics card hardware parameters and application task load, and expand and reconstruct the kernel tensor to generate a deep computing power feature vector.

[0010] S3. Construct a computing power feature profile library using deep computing power feature vectors, reduce historical running data to computing power fingerprint templates, and identify the specific sensitivity type and load pressure mode of the user's current task to graphics card resources by calculating the similarity between the input parameters of the user's task to be configured and the computing power fingerprint templates, and output the target task feature profile.

[0011] S4. Based on the target task feature profile, generate a preliminary configuration scheme using the improved WGAN-GP model, calculate the Wasserstein distance and gradient penalty operation to optimize the parameter distribution, introduce a manifold regularization projection mechanism, construct a low-dimensional embedded data manifold based on historical data, calculate the normal vector using the orthogonal projection layer, force the parameters that diverge to the physically infeasible region to be projected back to the manifold, and select a subset of candidate configurations.

[0012] S5. Obtain the user's natural language requirement description, parse out the hard constraint indicators, calculate the optimal solution set in the candidate configuration subset based on the Pareto multi-objective optimization algorithm, and calculate the weighted Hamming distance according to the hard constraint indicators to match the final graphics card workstation configuration parameters from the optimal solution set.

[0013] S6. Send the graphics card workstation configuration parameters to the physical workstation, collect real-time load data and compare it with the target task feature profile. If it exceeds the preset fluctuation threshold, call the PID algorithm to perform adaptive dynamic correction.

[0014] S7. The final operating parameters after dynamic adjustment and the corresponding actual operating performance data are used to construct incremental samples, which are then fed back to the original holographic operating state dataset for rolling updates and continuous iterative self-optimization.

[0015] Optionally, S1 specifically includes:

[0016] S11. By deploying low-level probes in distributed workstation nodes, multi-dimensional graphics card running fingerprint data and associated application software environment characteristics are collected synchronously.

[0017] S12. Obtain the GPU stream multiprocessor usage waveform, memory addressing bandwidth peak value and PCIe channel communication congestion index from the multidimensional graphics card running fingerprint data, and obtain the software version number, rendering pipeline type and API call set from the associated application software environment characteristics.

[0018] S13. The collected multidimensional graphics card running fingerprint data and associated application software environment features are spliced ​​together to generate the original holographic running state dataset.

[0019] Optionally, S2 specifically includes:

[0020] S21. Read the data records in the original holographic running state dataset, extract the timestamp information attached to each record, and align the multi-dimensional graphics card running fingerprint data and application software environment characteristics collected by different workstation nodes on the time axis according to the time sequence of the timestamps. Then, use the statistical 3σ principle to identify outliers in the data and judge data points that deviate from the mean by more than three times the standard deviation as noise and remove them.

[0021] S22. Define three coordinate axes corresponding to the hardware dimension, scene dimension and performance index dimension respectively. Map the cleaned data according to these three coordinate axes to establish a numerical storage structure determined by row index, column index and depth index, and construct a three-dimensional heterogeneous tensor matrix.

[0022] S23. For the three-dimensional heterogeneous tensor matrix, initialize the decomposition process of the HOSVD algorithm, keep the scene dimension and performance index dimension unchanged, flatten the three-dimensional heterogeneous tensor matrix along the hardware dimension direction, convert it into a two-dimensional unfolded matrix in the hardware dimension, calculate the product of the two-dimensional unfolded matrix and its own transpose matrix to obtain the covariance matrix in the hardware dimension.

[0023] S24. Perform eigenvalue decomposition on the covariance matrix of the hardware dimension, construct a new matrix by multiplying the diagonal elements of the identity matrix by an unknown and then subtracting the corresponding elements of the covariance matrix, calculate the determinant of the new matrix and set it to zero, obtain all eigenvalues ​​by solving the equations, substitute each obtained eigenvalue into the new matrix to replace the unknown, and construct a system of linear equations.

[0024] S25. Arrange the coefficients and constant terms of each row of equations in the system of equations into numerical rows. Multiply any numerical row by a preset non-zero constant and add it to another numerical row to make the coefficient at a specific position in the row become zero. Repeat the process until the numerical rows are arranged into an upper triangle shape. Start from the last row and work backward to solve the unknowns, calculate each eigenvector, and arrange them in descending order of eigenvalues. Select the preset number of eigenvectors at the top and arrange them as column vectors in sequence to generate a factor matrix of the hardware dimension.

[0025] S26. Referring to the processing steps from S23 to S25, keeping the hardware dimension and performance index dimension unchanged, the three-dimensional heterogeneous tensor matrix is ​​expanded into a two-dimensional expanded matrix along the scene dimension. The covariance matrix is ​​calculated and decomposed to obtain the factor matrix of the scene dimension. Keeping the hardware dimension and scene dimension unchanged, the three-dimensional heterogeneous tensor matrix is ​​expanded into a two-dimensional expanded matrix along the performance index dimension. The covariance matrix is ​​calculated and decomposed to obtain the factor matrix of the performance index dimension.

[0026] S27. Using the three-dimensional heterogeneous tensor matrix as the multiplicand, perform continuous modulo n multiplication operations with the transpose of the factor matrix in the hardware dimension, the transpose of the factor matrix in the scene dimension, and the transpose of the factor matrix in the performance index dimension, respectively. By continuously projecting and shrinking along the three dimensions, calculate the kernel tensor that describes the nonlinear coupling relationship between the graphics card hardware parameters and the application task load.

[0027] S28. Read the extracted kernel tensor and perform tensor product operation again with the generated three-dimensional factor matrix to reconstruct the high-dimensional kernel tensor into a low-dimensional feature matrix. Then, read the numerical data in the reconstructed feature matrix in row-major order and convert it into vector format to generate the deep computing power feature vector.

[0028] Optionally, S3 specifically includes:

[0029] S31. Read the generated deep computing power feature vector, classify and store the values ​​in the deep computing power feature vector according to the graphics card model and the corresponding application software environment features, establish an index containing the correspondence between hardware parameters and scene labels, and build a computing power feature profile library for application scenarios.

[0030] S32. Extract all deep computing power feature vectors within the historical time period from the computing power feature profile library, calculate the Euclidean distance between every two deep computing power feature vectors, classify feature vectors with a distance value less than the preset clustering radius into the same category, calculate the average vector of all feature vectors in each category, use the average vector as the center of the corresponding category, and generate a standardized computing power fingerprint template.

[0031] S33. Obtain the input parameters of the user's task to be configured, convert the input parameters into a task feature vector of the same dimension as the deep computing power feature vector according to a preset format, calculate the spatial distance value between the task feature vector and each standardized computing power fingerprint template, and mark the template with the smallest value as the best matching template.

[0032] S34. Based on the graphics card sensitivity tags associated with the best matching template, identify the specific sensitivity type of the user's current task to memory bandwidth, number of computing cores and texture fill rate, and read the load peak data in the template to determine the load pressure mode.

[0033] S35. Combine the identified specific sensitivity types with the load pressure patterns to generate feature description data and output it as the target task feature profile.

[0034] Optionally, S4 specifically includes:

[0035] S41. Read the target task feature profile, use the feature values ​​as random number seeds to generate an initial noise vector and input it into the generator's preset first fully connected neural network layer, then map it to a high-dimensional feature space. Input the mapped feature vector into a preset one-dimensional transposed convolutional layer, extend the length of the feature vector to the preset dimension of the graphics card configuration parameters, and output the preliminary configuration scheme.

[0036] S42. The numerical parameters in the preliminary configuration scheme are mixed and shuffled with the real historical configuration parameters stored in the database and input into the input layer of the discriminator. The discriminator extracts features from the input data through a preset multi-layer convolutional structure. The extracted last layer feature map is flattened into a one-dimensional feature vector. Each element in the one-dimensional feature vector is multiplied by the weight value of the preset fully connected layer of the discriminator and accumulated. After being mapped by the activation function, the output real value is used as the discrimination score.

[0037] S43. Calculate the difference between the average discrimination score corresponding to the preliminary configuration scheme and the average discrimination score corresponding to the real historical configuration parameters to obtain the Wasserstein distance. Generate a uniformly distributed random number between 0 and 1 on the straight line between the parameter points of the preliminary configuration scheme and the parameter points of the real historical configuration. Multiply the random number by the value of the real configuration parameter point, subtract the random number from 1 and multiply it by the value of the preliminary configuration parameter point. Add the two products to obtain the interpolation point and calculate the derivative with respect to the input parameters.

[0038] S44. Squaring the calculated derivative, subtracting the constant 1 from the squared result, squaring the subtraction result to obtain the gradient penalty term, multiplying it by the preset penalty coefficient, adding the product to the Wasserstein distance to construct the total loss function, calculating the partial derivative of the total loss function with respect to each element in the generator weight matrix and the discriminator weight matrix, multiplying each partial derivative value by the set learning rate to obtain the update amount of each weight value, subtracting the corresponding update amount from the original weight value to complete one parameter iteration optimization;

[0039] S45. Extract multiple sets of graphics card configuration records from the historical running data, subtract the overall average of all configuration records from each value in each set of configuration records to obtain the centered data, and multiply it with the corresponding transpose matrix to obtain the covariance matrix. Solve for the eigenvalues ​​and eigenvectors of the covariance matrix.

[0040] S46. Sort the eigenvalues ​​from largest to smallest, select the eigenvectors corresponding to the preset number of eigenvalues ​​at the top of the sort as projection axes, multiply the centered data matrix with the projection axis matrix to obtain the low-dimensional coordinate points after projection, and connect all the coordinate points to construct a low-dimensional embedded data manifold.

[0041] S47. Connect an orthogonal projection layer to the output of the generator. Arbitrarily select a data point on the data manifold and construct a tiny tangent plane with the data point as the center. Select a preset extremely short vector along two different coordinate axes in the tangent plane. Calculate the cross product of the two vectors to obtain a normal vector perpendicular to the tangent plane. Divide each value of the normal vector by the square root of the sum of the squares of all values ​​of the normal vector and normalize the length of the normal vector to 1.

[0042] S48. Read each parameter value point in the preliminary configuration scheme, calculate the straight-line distance from the parameter value point to the nearest point on the data manifold. If the calculated straight-line distance value is greater than the preset tolerance threshold, it is determined that the parameter point is located in a physically infeasible area. Starting from the parameter point, move along the normalized normal vector direction or the opposite direction. The moving distance is equal to the calculated straight-line distance value. Force the parameter point to move to the data manifold surface.

[0043] S49. Traverse all parameter points after projection correction, check whether the video memory capacity value of each parameter point is less than or equal to zero and whether the core frequency value is negative. If any value is negative or zero, remove the current parameter point. Sort the remaining parameter points from high to low according to the corresponding discrimination score, select the preset number of parameter points at the top of the sort as the final result, and filter out the candidate configuration subset.

[0044] Optionally, S5 specifically includes:

[0045] S51. Obtain the user's natural language demand description and input it into the pre-trained natural language processing (NLP) model. Extract words containing currency symbols and number combinations from the text as the budget limit, extract words containing length units and number combinations as the space size limit, extract words representing energy consumption priority and convert them into corresponding values ​​as energy efficiency preference weights to obtain hard constraint indicators.

[0046] S52. Read the parameter points in the subset of candidate configurations and obtain the corresponding graphics card performance score, total power consumption value and hardware cost price by querying the preset hardware specification parameter table. Take the graphics card performance score as the maximization objective and the total power consumption value and hardware cost price as the minimization objective to construct the objective function of the multi-objective optimization problem. Use the Pareto multi-objective optimization algorithm to calculate the objective function, filter out the configuration schemes that will cause the other objectives to decrease if any objective is improved, and combine them into the optimal solution set.

[0047] S53. Convert all parameters of each configuration scheme in the optimal solution set into a binary encoding sequence, convert the budget upper limit and space size limit in the hard constraint indicators into the corresponding binary standard sequence, compare the binary encoding sequence of the configuration scheme with the binary standard sequence bit by bit, count the number of different digits in each bit as the Hamming distance, and multiply it with the energy efficiency preference weight to calculate the weighted Hamming distance.

[0048] S54. Sort all configuration schemes in the optimal solution set in ascending order of the calculated weighted Hamming distance value, select the configuration scheme ranked first, and extract the graphics card model, video memory capacity, core frequency and power parameters contained in the configuration scheme as the final graphics card workstation configuration parameters.

[0049] Optionally, S6 specifically includes: sending the graphics card workstation configuration parameters to the physical workstation, collecting real-time load data of the physical workstation in the background, comparing the real-time load data with the target task feature profile, and if the performance fluctuation is detected to exceed the preset fluctuation threshold, calling the PID algorithm to adaptively and dynamically correct the power consumption limit, fan speed curve and memory frequency of the graphics card according to the deviation of the real-time load status.

[0050] Optionally, S7 specifically includes: constructing incremental samples from the dynamically adjusted final operating parameters and corresponding actual operating performance data and feeding them back to the original holographic operating state dataset in real time; using the incremental data to perform rolling updates on the three-dimensional heterogeneous tensor matrix; and performing continuous iterative self-optimization of the configuration model.

[0051] The beneficial effects of this invention are:

[0052] This invention addresses the challenges of complex hardware parameter coupling and variable application loads in GPU workstation configurations by deploying underlying probes and constructing a holographic runtime dataset. It employs spatiotemporal alignment and denoising cleaning techniques to unify data standards, utilizes the HOSVD algorithm to perform multilinear algebraic decomposition on the 3D heterogeneous tensor matrix, and extracts deep computing power feature vectors to characterize the nonlinear relationship between hardware and load. The target task feature profile is input into an improved WGAN-GP model, and parameter distribution is optimized using Wasserstein distance and gradient penalty. A manifold regularization projection mechanism is specifically introduced to calculate the data manifold normal vector, forcibly projecting parameters diverging to physically infeasible regions back onto the manifold surface, generating a high-quality subset of candidate configurations. In the decision-making phase, the optimal solution set is calculated by combining analytical hard constraints with the Pareto multi-objective optimization algorithm, and the final configuration parameters are matched using weighted Hamming distance. Furthermore, an incremental sample feedback mechanism is used to continuously update the 3D heterogeneous tensor matrix, and a PID algorithm is invoked to dynamically adjust the real-time load. Ultimately, it achieves closed-loop management of intelligent generation of graphics card workstation configurations, physical constraint compliance verification, and continuous iterative self-optimization, effectively improving the innovation of configuration schemes, the adaptability of physical environments, and the stability of long-term model operation. Attached Figure Description

[0053] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:

[0054] Figure 1 This is a flowchart of a graphics card workstation intelligent configuration method based on big data analysis proposed in this invention;

[0055] Figure 2 This is a flowchart of the three-dimensional heterogeneous tensor matrix decomposition and depth computing power feature vector generation based on the HOSVD algorithm proposed in this invention.

[0056] Figure 3 This is a flowchart of the parameter generation and configuration subset selection process for the improved WGAN-GP model proposed in this invention, which introduces a manifold regular projection mechanism. Detailed Implementation

[0057] The present invention will now be described in further detail with reference to the accompanying drawings. These drawings are simplified schematic diagrams, illustrating only the basic structure of the invention, and therefore only show the components relevant to the invention.

[0058] refer to Figures 1-3 A method for intelligent configuration of graphics card workstations based on big data analysis includes the following steps:

[0059] S1. By deploying low-level probes in distributed workstation nodes, multi-dimensional graphics card running fingerprint data and associated application software environment characteristics are collected synchronously. The multi-dimensional graphics card running fingerprint data includes GPU stream multiprocessor occupancy waveform, memory addressing bandwidth peak value and PCIe channel communication congestion index. The application software environment characteristics include software version number, rendering pipeline type and API call interface set, generating original holographic running state dataset.

[0060] S2. Spatiotemporal alignment and denoising cleaning are performed on the original holographic running state dataset. A three-dimensional heterogeneous tensor matrix containing hardware dimension, scene dimension and performance index dimension is constructed. The HOSVD algorithm is used to perform multilinear algebraic decomposition on the three-dimensional heterogeneous tensor matrix to extract the kernel tensor and factor matrices of each dimension that characterize the nonlinear coupling relationship between graphics card hardware parameters and application task load. The kernel tensor is expanded and reconstructed to generate a deep computing power feature vector.

[0061] S3. Construct a computing power feature profile library for application scenarios using deep computing power feature vectors. Use big data clustering algorithms to reduce historical running data to standardized computing power fingerprint templates. By calculating the similarity between the input parameters of the user's task to be configured and the computing power fingerprint template, identify the specific sensitivity type and load pressure mode of the user's current task to graphics card resources, and output the target task feature profile.

[0062] S4. Based on the target task feature profile, generate a preliminary configuration scheme in the digital twin simulator using the improved WGAN-GP model, optimize the parameter distribution by calculating Wasserstein distance and gradient penalty operation, introduce manifold regularization projection mechanism, construct a low-dimensional embedded data manifold based on historical data, calculate normal vectors using orthogonal projection layer, force parameters diverging to physically infeasible regions to be projected back to the manifold surface, and select a high-quality subset of candidate configurations.

[0063] S5. Obtain the user's natural language requirement description, use the natural language processing (NLP) model to parse out the hard constraint indicators including budget limit, space size limit and energy efficiency preference weight, calculate the optimal solution set in the candidate configuration subset based on the Pareto multi-objective optimization algorithm, and calculate the weighted Hamming distance according to the hard constraint indicators, and match the final graphics card workstation configuration parameters from the optimal solution set.

[0064] S6. Send the graphics card workstation configuration parameters to the physical workstation and collect real-time load data to compare with the target task feature profile. If the performance fluctuation exceeds the preset fluctuation threshold, call the PID algorithm to make adaptive dynamic correction based on the deviation of the real-time load status.

[0065] S7. The final operating parameters after dynamic adjustment and the corresponding actual operating performance data are used to construct incremental samples, which are then fed back to the original holographic operating state dataset for rolling updates and continuous iterative self-optimization.

[0066] This implementation significantly improves the accuracy and performance of GPU workstation configuration. By constructing a three-dimensional heterogeneous tensor matrix containing hardware, scene, and performance indicators, and using the HOSVD algorithm to extract deep computing power feature vectors, it achieves decoupled analysis of complex data such as GPU streaming multiprocessor usage and memory bandwidth, accurately depicting the nonlinear coupling relationship between hardware parameters and task load. The introduction of an improved WGAN-GP model and manifold regularization projection mechanism generates high-quality preliminary configuration schemes, effectively preventing parameters from diverging to physically infeasible regions and ensuring the rationality and feasibility of configuration parameters. Combining natural language processing to parse user hard constraints and using the Pareto multi-objective optimization algorithm to match the optimal solution, it achieves intelligent transformation from fuzzy requirements to precise configuration. Furthermore, by adaptively and dynamically correcting performance fluctuations through a PID algorithm and feeding operational data back to the dataset for continuous iteration, this invention significantly enhances the system's robustness and self-evolution capabilities in complex application scenarios, greatly improving resource allocation efficiency and user experience.

[0067] In this embodiment, S1 specifically includes:

[0068] S11. By deploying low-level probes in distributed workstation nodes, multi-dimensional graphics card running fingerprint data and associated application software environment characteristics are collected synchronously.

[0069] S12. Obtain the GPU stream multiprocessor usage waveform, memory addressing bandwidth peak value and PCIe channel communication congestion index from the multidimensional graphics card running fingerprint data, and obtain the software version number, rendering pipeline type and API call set from the associated application software environment characteristics.

[0070] S13. The collected multidimensional graphics card running fingerprint data and associated application software environment features are spliced ​​together to generate the original holographic running state dataset.

[0071] In this embodiment, S2 specifically includes:

[0072] S21. Read the data records in the original holographic running state dataset, extract the timestamp information attached to each record, and align the multi-dimensional graphics card running fingerprint data and application software environment characteristics collected by different workstation nodes on the time axis according to the time sequence of the timestamps. Then, use the statistical 3σ principle to identify outliers in the data and judge data points that deviate from the mean by more than three times the standard deviation as noise and remove them.

[0073] S22. Define three coordinate axes corresponding to the hardware dimension, scene dimension, and performance index dimension respectively. Map the cleaned data spatially according to these three coordinate axes to establish a numerical storage structure determined by row index, column index, and depth index. Construct a three-dimensional heterogeneous tensor matrix containing hardware dimension, scene dimension, and performance index dimension.

[0074] S23. For the three-dimensional heterogeneous tensor matrix, initialize the decomposition process of the HOSVD algorithm, keep the scene dimension and performance index dimension unchanged, flatten the three-dimensional heterogeneous tensor matrix along the hardware dimension direction, convert it into a two-dimensional unfolded matrix in the hardware dimension, calculate the product of the two-dimensional unfolded matrix and its own transpose matrix to obtain the covariance matrix in the hardware dimension.

[0075] S24. Perform eigenvalue decomposition on the covariance matrix of the hardware dimension, construct a new matrix by multiplying the diagonal elements of the identity matrix by an unknown and then subtracting the corresponding elements of the covariance matrix, calculate the determinant of the new matrix and set it to zero, obtain all eigenvalues ​​by solving the equations, substitute each obtained eigenvalue into the new matrix to replace the unknown, and construct a system of linear equations.

[0076] S25. Arrange the coefficients and constant terms of each row of equations in the system of equations into numerical rows. Multiply any numerical row by a preset non-zero constant and add it to another numerical row to make the coefficient at a specific position in the row become zero. Repeat the process until the numerical rows are arranged into an upper triangle shape. Start from the last row and work backward to solve the unknowns, calculate each eigenvector, and arrange them in descending order of eigenvalues. Select the preset number of eigenvectors at the top and arrange them as column vectors in sequence to generate a factor matrix of the hardware dimension.

[0077] S26. Referring to the processing steps from S23 to S25, keeping the hardware dimension and performance index dimension unchanged, the three-dimensional heterogeneous tensor matrix is ​​expanded into a two-dimensional expanded matrix along the scene dimension. The covariance matrix is ​​calculated and decomposed to obtain the factor matrix of the scene dimension. Keeping the hardware dimension and scene dimension unchanged, the three-dimensional heterogeneous tensor matrix is ​​expanded into a two-dimensional expanded matrix along the performance index dimension. The covariance matrix is ​​calculated and decomposed to obtain the factor matrix of the performance index dimension.

[0078] S27. Using the three-dimensional heterogeneous tensor matrix as the multiplicand, perform continuous modulo n multiplication operations with the transpose of the factor matrix in the hardware dimension, the transpose of the factor matrix in the scene dimension, and the transpose of the factor matrix in the performance index dimension, respectively. By continuously projecting and shrinking along the three dimensions, calculate the kernel tensor that describes the nonlinear coupling relationship between the graphics card hardware parameters and the application task load.

[0079] S28. Read the extracted kernel tensor and perform tensor product operation again with the generated three-dimensional factor matrix to reconstruct the high-dimensional kernel tensor into a low-dimensional feature matrix. Then, read the numerical data in the reconstructed feature matrix in row-major order and convert it into vector format to generate the deep computing power feature vector.

[0080] This implementation introduces the HOSVD algorithm as its core innovative technology, which has significant differences and advantages compared to traditional matrix factorization techniques such as PCA and shallow neural network feature extraction methods. Traditional PCA forcibly unfolds high-dimensional data into one-dimensional vectors, resulting in the loss of the inherent spatial structure and potential correlations of multi-dimensional data; shallow neural networks struggle to handle complex nonlinear relationships and are prone to overfitting when samples are limited. HOSVD, by simultaneously performing eigenvalue decomposition and modular multiplication operations across three dimensions—hardware, scene, and performance metrics—accurately extracts the factor matrices and kernel tensors of each dimension, profoundly characterizing the nonlinear coupling relationship between graphics card hardware parameters and application task load. This multi-dimensional tensor decomposition mechanism can generate low-dimensional deep computing feature vectors through kernel tensor reconstruction while preserving the high-order structure of the data, effectively eliminating redundant noise. Compared to traditional methods, this implementation significantly improves the feature representation capability and computational robustness of heterogeneous data, ensuring the accuracy and practicality of subsequent configuration schemes.

[0081] In this embodiment, S3 specifically includes:

[0082] S31. Read the generated deep computing power feature vector, classify and store the values ​​in the deep computing power feature vector according to the graphics card model and the corresponding application software environment features, establish an index containing the correspondence between hardware parameters and scene labels, and build a computing power feature profile library for application scenarios.

[0083] S32. Extract all deep computing power feature vectors within the historical time period from the computing power feature profile library, calculate the Euclidean distance between every two deep computing power feature vectors, classify feature vectors with a distance value less than the preset clustering radius into the same category, calculate the average vector of all feature vectors in each category, use the average vector as the center of the corresponding category, and generate a standardized computing power fingerprint template.

[0084] S33. Obtain the input parameters of the user's task to be configured, convert the input parameters into a task feature vector of the same dimension as the deep computing power feature vector according to a preset format, calculate the spatial distance value between the task feature vector and each standardized computing power fingerprint template, and mark the template with the smallest value as the best matching template.

[0085] S34. Based on the graphics card sensitivity tags associated with the best matching template, identify the specific sensitivity type of the user's current task to memory bandwidth, number of computing cores and texture fill rate, and read the load peak data in the template to determine the load pressure mode.

[0086] S35. Combine the identified specific sensitivity types with the load pressure patterns to generate feature description data and output it as the target task feature profile.

[0087] In this embodiment, S4 specifically includes:

[0088] S41. Read the target task feature profile, use the feature values ​​as random number seeds to generate an initial noise vector and input it into the generator's preset first fully connected neural network layer, then map it to a high-dimensional feature space. Input the mapped feature vector into a preset one-dimensional transposed convolutional layer, extend the length of the feature vector to the preset dimension of the graphics card configuration parameters, and output a preliminary configuration scheme including the graphics card model number, memory capacity and core frequency in Hertz.

[0089] S42. The numerical parameters in the preliminary configuration scheme are mixed and shuffled with the real historical configuration parameters stored in the database and input into the input layer of the discriminator. The discriminator extracts features from the input data through a preset multi-layer convolutional structure. The extracted last layer feature map is flattened into a one-dimensional feature vector. Each element in the one-dimensional feature vector is multiplied by the weight value of the preset fully connected layer of the discriminator and accumulated. After being mapped by the activation function, a real value between negative infinity and positive infinity is output as the discrimination score.

[0090] S43. Calculate the difference between the average discrimination score corresponding to the preliminary configuration scheme and the average discrimination score corresponding to the real historical configuration parameters to obtain the Wasserstein distance. Generate a uniformly distributed random number between 0 and 1 on the straight line between the parameter points of the preliminary configuration scheme and the parameter points of the real historical configuration. Multiply the random number by the value of the real configuration parameter point, subtract the random number from 1 and multiply it by the value of the preliminary configuration parameter point. Add the two products to obtain the interpolation point and calculate the derivative with respect to the input parameters.

[0091] S44. Squaring the calculated derivative, subtracting the constant 1 from the squared result, squaring the subtraction result to obtain the gradient penalty term, multiplying it by the preset penalty coefficient, adding the product to the Wasserstein distance to construct the total loss function, calculating the partial derivative of the total loss function with respect to each element in the generator weight matrix and the discriminator weight matrix, multiplying each partial derivative value by the set learning rate to obtain the update amount of each weight value, subtracting the corresponding update amount from the original weight value to complete one parameter iteration optimization;

[0092] S45. Extract multiple sets of graphics card configuration records from the historical running data, subtract the overall average of all configuration records from each value in each set of configuration records to obtain the centered data, and multiply it with the corresponding transpose matrix to obtain the covariance matrix. Solve for the eigenvalues ​​and eigenvectors of the covariance matrix.

[0093] S46. Sort the eigenvalues ​​from largest to smallest, select the eigenvectors corresponding to the preset number of eigenvalues ​​at the top of the sort as projection axes, multiply the centered data matrix with the projection axis matrix to obtain the low-dimensional coordinate points after projection, and connect all the coordinate points to construct a low-dimensional embedded data manifold.

[0094] S47. Connect an orthogonal projection layer to the output of the generator. Arbitrarily select a data point on the data manifold and construct a tiny tangent plane with the data point as the center. Select a preset extremely short vector along two different coordinate axes in the tangent plane. Calculate the cross product of the two vectors to obtain a normal vector perpendicular to the tangent plane. Divide each value of the normal vector by the square root of the sum of the squares of all values ​​of the normal vector and normalize the length of the normal vector to 1.

[0095] S48. Read each parameter value point in the preliminary configuration scheme, calculate the straight-line distance from the parameter value point to the nearest point on the data manifold. If the calculated straight-line distance value is greater than the preset tolerance threshold, it is determined that the parameter point is located in a physically infeasible area. Starting from the parameter point, move along the normalized normal vector direction or the opposite direction. The moving distance is equal to the calculated straight-line distance value. Force the parameter point to move to the data manifold surface.

[0096] S49. Traverse all parameter points after projection correction, check whether the video memory capacity value of each parameter point is less than or equal to zero and whether the core frequency value is negative. If any value is negative or zero, remove the current parameter point. Sort the remaining parameter points from high to low according to the corresponding discrimination score, select the preset number of parameter points at the top of the sort as the final result, and filter out a high-quality subset of candidate configurations.

[0097] This invention introduces an improved WGAN-GP model combined with a manifold regularization projection mechanism to achieve intelligent generation of graphics card configuration parameters and optimization of physical feasible region constraints. A generator is used to generate an initial configuration scheme based on the target task feature profile mapping. A total loss function is constructed by combining Wasserstein distance and gradient penalty terms. The weight parameters of the generator and discriminator are iteratively optimized to ensure that the generated configuration closely approximates the real data distribution. Simultaneously, historical data is extracted to construct a low-dimensional embedded data manifold. Normal vectors are calculated using orthogonal projection layers to forcibly pull parameter points that deviate to the physically infeasible region back to the manifold surface. This invention effectively solves the problem of the generated model easily producing illegal parameters that violate hardware physical logic, significantly improving the effectiveness and accuracy of the configuration scheme. The high-quality subset of candidate configurations after projection correction and filtering greatly reduces the evaluation cost of invalid schemes, providing a reliable guarantee for subsequent accurate matching of the optimal graphics card workstation configuration.

[0098] The improved WGAN-GP model of this invention is similar to the original WGAN-GP model in that both retain the core architecture of generative adversarial networks, namely, to approximate the real data distribution through adversarial game training between the generator and the discriminator, and both use Wasserstein distance as the loss function to alleviate the gradient vanishing problem, and constrain the gradient norm of the discriminator through a gradient penalty term to maintain the stability of training.

[0099] The difference lies in that this invention breaks away from the limitations of the original WGAN-GP model, which ignores physical feasibility and manifold structure during the generation process. It introduces a manifold regularization projection mechanism, constructing a constraint system based on data geometric features. Building upon the original model's direct output of generation parameters, this invention adds a manifold construction and projection correction module in steps S45 to S48. First, the covariance matrix is ​​calculated using historical running data, and eigenvectors are extracted to construct the projection axis, projecting the high-dimensional configuration data into a low-dimensional space to construct the data manifold. Next, in step S47, the outer product of the manifold tangent planes is calculated to obtain the normalized normal vector. Then, in step S48, the straight-line distance between the initial configuration scheme and the data manifold is detected in real time. If the distance exceeds a tolerance threshold, it is determined to be located in a physically infeasible region, and the parameter points are forcibly pulled back to the manifold surface according to the normal vector direction, rather than being directly output.

[0100] The beneficial effects of the improvements are that by introducing manifold regularization projection, the improved WGAN-GP model can effectively eliminate illegal parameter combinations that violate the physical logic of the hardware, solving the defect of the original model that is prone to generating numerical anomalies or logically contradictory configurations, and ensuring the physical realizability of the generated results. This forced alignment mechanism based on data geometric features significantly improves the quality and rationality of configuration parameters and greatly reduces the computational overhead of the subsequent screening stage. Combined with the optimization of Wasserstein distance, this invention significantly enhances the convergence speed and robustness of the model under complex constraint spaces while maintaining the high expressive power of adversarial training, providing high-quality decision support for workstation configuration.

[0101] In this embodiment, S5 specifically includes:

[0102] S51. Obtain the user's natural language demand description and input it into the pre-trained natural language processing (NLP) model. Extract words containing currency symbols and number combinations from the text as the budget limit, extract words containing length units and number combinations as the space size limit, extract words representing energy consumption priority and convert them into corresponding values ​​as energy efficiency preference weights, and obtain hard constraint indicators including budget limit, space size limit and energy efficiency preference weights.

[0103] S52. Read the parameter points in the high-quality candidate configuration subset and obtain the corresponding graphics card performance score, total power consumption value and hardware cost price by querying the preset hardware specification parameter table. Take the graphics card performance score as the maximization objective and the total power consumption value and hardware cost price as the minimization objective to construct the objective function of the multi-objective optimization problem. Use the Pareto multi-objective optimization algorithm to calculate the objective function, screen out the configuration schemes that will cause the other objectives to decrease if any objective is improved, and combine them into the optimal solution set.

[0104] S53. Convert all parameters of each configuration scheme in the optimal solution set into a binary encoding sequence, convert the budget upper limit and space size limit in the hard constraint indicators into the corresponding binary standard sequence, compare the binary encoding sequence of the configuration scheme with the binary standard sequence bit by bit, count the number of different digits in each bit as the Hamming distance, and multiply it with the energy efficiency preference weight to calculate the weighted Hamming distance.

[0105] S54. Sort all configuration schemes in the optimal solution set in ascending order of the calculated weighted Hamming distance value, select the configuration scheme ranked first, and extract the graphics card model, video memory capacity, core frequency and power parameters contained in the configuration scheme as the final graphics card workstation configuration parameters.

[0106] In this embodiment, S6 specifically includes: sending the graphics card workstation configuration parameters to the physical workstation, collecting the real-time load data of the physical workstation in the background, comparing the real-time load data with the target task feature profile, and if the performance fluctuation is detected to exceed the preset fluctuation threshold, calling the PID algorithm to adaptively and dynamically correct the power consumption limit, fan speed curve and memory frequency of the graphics card according to the deviation of the real-time load status.

[0107] In this embodiment, S7 specifically includes: constructing incremental samples from the dynamically adjusted final operating parameters and the corresponding actual operating performance data and feeding them back to the original holographic operating state dataset in real time; using the incremental data to perform rolling updates on the three-dimensional heterogeneous tensor matrix; and performing continuous iterative self-optimization of the configuration model.

[0108] Example 1: To verify the feasibility of this invention in practice, it was applied to a large animation rendering studio cluster in a certain province. Located in the Shenzhen Nanshan High-Tech Industrial Park, the studio primarily engages in 3D animated film production, VR virtual reality content development, and digital film and television post-production. It has 216 high-end graphics workstations with varying configurations, distributed across multiple work areas including the rendering farm, modeling area, special effects compositing area, and texture mapping area. The workstations use a diverse range of graphics card models, including 23 different specifications such as RTX 4090 and RTX A6000, with memory ranging from 8 gigabytes to 48 gigabytes, large core clock speeds, and prices ranging from RMB 3,500 to RMB 28,000. Their business encompasses film-level scene rendering, complex character animation calculations, and real-time interactive VR development, resulting in vastly different computing power requirements.

[0109] The existing configuration model relied on the experience of senior IT engineers, which had many drawbacks. Engineers could only roughly allocate graphics cards based on task type, lacking detailed consideration of software versions, scenario complexity, and other factors. This resulted in high-end graphics cards being used for lightweight tasks, while employees who truly needed high-performance graphics cards were forced to use low-end equipment. Furthermore, equipment mobility was poor, rarely dynamically adjusted according to task changes, often leading to idle and wasted computing power. In urgent projects, it was difficult to quickly identify idle resources, often resulting in unnecessary procurement expenditures, and decisions regarding the obsolescence of aging equipment were difficult.

[0110] After introducing this invention, the studio deployed a lightweight, low-level probe program on all workstations to collect GPU operating fingerprint data 24 / 7, including over forty metrics such as memory usage, core temperature, and GPU utilization, with millisecond-level timestamps. The probe is compatible with heterogeneous hardware and uses differential compression algorithms to reduce transmission pressure. The cleaned data is uploaded to the HOSVD algorithm module on the central server, where it is spatiotemporally aligned and mapped to a three-dimensional space, corresponding to hardware, scene, and performance dimensions. After outlier removal using the three-sigma principle, a three-dimensional heterogeneous tensor matrix containing 80 million elements is constructed. The HOSVD algorithm performs multilinear algebraic decomposition on this matrix, extracting the kernel tensor and factor matrix, deeply analyzing and identifying the optimal combination of hardware parameters under different scenarios, and generating deep computing power feature vectors stored in a feature profile library.

[0111] When employees submit hardware requirements, the system extracts a feature profile of the target task and inputs it into an improved WGAN-GP model generator. The generator maps low-dimensional feature vectors to a high-dimensional parameter space, generating a preliminary graphics card configuration scheme. For outliers that may violate physical laws, the system calculates manifold normal vectors through an orthogonal projection layer, forcing infeasible parameter points back onto the manifold surface to ensure compliance with physical constraints. The generated scheme is then evaluated by a discriminator, which employs Wasserstein distance and gradient penalty mechanisms to improve stability. After adversarial game optimization, the configuration scheme distribution approaches the historical optimum. Subsequently, the system uses a Pareto multi-objective optimization algorithm to find a balance between budget, performance, and energy efficiency, eliminating schemes with excessively hard constraints. It then matches the target task profile with a weighted Hamming distance and outputs the final recommendation result. The system also continuously optimizes based on feedback, incrementally updating the tensor matrix and dynamically fine-tuning the load using a PID algorithm to ensure efficient resource utilization. Table 1 below shows detailed comparison data between the method of this invention and traditional empirical methods in intelligent graphics card configuration tasks.

[0112] Table 1. Performance Comparison Data Between the Invention and Traditional Methods in Intelligent Graphics Card Configuration

[0113] Based on the comparative data shown in Table 1, it can be seen that the intelligent configuration method for graphics cards based on the HOSVD algorithm and the improved WGAN-GP proposed in this invention shows significant performance advantages over traditional empirical methods in terms of heterogeneous computing power scheduling, especially in terms of configuration accuracy, response time, resource matching degree and cost control.

[0114] In terms of configuration accuracy, this invention maintains a high level of over 95% in all six typical application scenarios, far exceeding the average accuracy of traditional methods (approximately 68%). For example, in the "deep learning model training" scenario, traditional methods rely on the subjective judgment of engineers, making it difficult to accurately match complex computing power requirements, resulting in an accuracy of only 65.2%. In contrast, this invention achieves 95.5% accuracy by integrating deep computing power feature vectors with a manifold projection mechanism, effectively solving the performance bottleneck problem caused by insufficient configuration in high-load tasks.

[0115] Regarding response timeliness, this invention significantly shortens decision-making time through an automated parameter generation process using generative adversarial networks. The average response time is reduced from over 45 minutes using traditional methods to approximately 10 minutes, a nearly fourfold increase in speed. For example, the traditional response time for "complex character animation calculation" is 52.1 minutes, while this invention only requires 10.2 minutes, greatly improving equipment scheduling efficiency in emergency situations.

[0116] In terms of resource matching accuracy, this invention maintains a success rate above 91% across all scenarios, while traditional methods typically hover around 60%. Traditional methods, lacking refined analysis, often result in idle high-performance resources or overloaded low-performance resources. This invention utilizes precise matching based on multi-dimensional feature profiles, leading to more scientific hardware allocation. Simultaneously, it demonstrates significant advantages in controlling budget overruns and computing power idle rates. This invention keeps budget overruns below 3.5% and computing power idle rates down to around 7.4%, significantly reducing operating costs and filling the technical gaps in dynamic resource optimization offered by traditional methods.

[0117] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A method for intelligent configuration of graphics card workstations based on big data analysis, characterized in that, Includes the following steps: S1. Synchronously collect multi-dimensional graphics card running fingerprint data and associated application software environment characteristics to generate the original holographic running state dataset; S2. Preprocess the original holographic running state dataset, construct a three-dimensional heterogeneous tensor matrix, use the HOSVD algorithm to perform multilinear algebraic decomposition, extract the kernel tensor and factor matrices of each dimension that characterize the nonlinear coupling relationship between graphics card hardware parameters and application task load, and expand and reconstruct the kernel tensor to generate a deep computing power feature vector. S3. Construct a computing power feature profile library using deep computing power feature vectors, reduce historical running data to computing power fingerprint templates, and identify the specific sensitivity type and load pressure mode of the user's current task to graphics card resources by calculating the similarity between the input parameters of the user's task to be configured and the computing power fingerprint templates, and output the target task feature profile. S4. Based on the target task feature profile, generate a preliminary configuration scheme using the improved WGAN-GP model, calculate the Wasserstein distance and gradient penalty operation to optimize the parameter distribution, introduce a manifold regularization projection mechanism, construct a low-dimensional embedded data manifold based on historical data, calculate the normal vector using the orthogonal projection layer, force the parameters that diverge to the physically infeasible region to be projected back to the manifold, and select a subset of candidate configurations. S5. Obtain the user's natural language requirement description, parse out the hard constraint indicators, calculate the optimal solution set in the candidate configuration subset based on the Pareto multi-objective optimization algorithm, and calculate the weighted Hamming distance according to the hard constraint indicators to match the final graphics card workstation configuration parameters from the optimal solution set. S6. Send the graphics card workstation configuration parameters to the physical workstation, collect real-time load data and compare it with the target task feature profile. If it exceeds the preset fluctuation threshold, call the PID algorithm to perform adaptive dynamic correction. S7. The final operating parameters after dynamic adjustment and the corresponding actual operating performance data are used to construct incremental samples, which are then fed back to the original holographic operating state dataset for rolling updates and continuous iterative self-optimization.

2. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S1 specifically includes: S11. By deploying low-level probes in distributed workstation nodes, multi-dimensional graphics card running fingerprint data and associated application software environment characteristics are collected synchronously. S12. Obtain the GPU stream multiprocessor usage waveform, memory addressing bandwidth peak value and PCIe channel communication congestion index from the multidimensional graphics card running fingerprint data, and obtain the software version number, rendering pipeline type and API call set from the associated application software environment characteristics. S13. The collected multidimensional graphics card running fingerprint data and associated application software environment features are spliced ​​together to generate the original holographic running state dataset.

3. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S2 specifically includes: S21. Read the data records in the original holographic running state dataset, extract the timestamp information attached to each record, and align the multi-dimensional graphics card running fingerprint data and application software environment characteristics collected by different workstation nodes on the time axis according to the time sequence of the timestamps. Then, use the statistical 3σ principle to identify outliers in the data and judge data points that deviate from the mean by more than three times the standard deviation as noise and remove them. S22. Define three coordinate axes corresponding to the hardware dimension, scene dimension and performance index dimension respectively. Map the cleaned data according to these three coordinate axes to establish a numerical storage structure determined by row index, column index and depth index, and construct a three-dimensional heterogeneous tensor matrix. S23. For the three-dimensional heterogeneous tensor matrix, initialize the decomposition process of the HOSVD algorithm, keep the scene dimension and performance index dimension unchanged, flatten the three-dimensional heterogeneous tensor matrix along the hardware dimension direction, convert it into a two-dimensional unfolded matrix in the hardware dimension, calculate the product of the two-dimensional unfolded matrix and its own transpose matrix to obtain the covariance matrix in the hardware dimension. S24. Perform eigenvalue decomposition on the covariance matrix of the hardware dimension, construct a new matrix by multiplying the diagonal elements of the identity matrix by an unknown and then subtracting the corresponding elements of the covariance matrix, calculate the determinant of the new matrix and set it to zero, obtain all eigenvalues ​​by solving the equations, substitute each obtained eigenvalue into the new matrix to replace the unknown, and construct a system of linear equations. S25. Arrange the coefficients and constant terms of each row of equations in the system of equations into numerical rows. Multiply any numerical row by a preset non-zero constant and add it to another numerical row to make the coefficient at a specific position in the row become zero. Repeat the process until the numerical rows are arranged into an upper triangle shape. Start from the last row and work backward to solve the unknowns, calculate each eigenvector, and arrange them in descending order of eigenvalues. Select the preset number of eigenvectors at the top and arrange them as column vectors in sequence to generate a factor matrix of the hardware dimension. S26. Referring to the processing steps from S23 to S25, keeping the hardware dimension and performance index dimension unchanged, the three-dimensional heterogeneous tensor matrix is ​​expanded into a two-dimensional expanded matrix along the scene dimension. The covariance matrix is ​​calculated and decomposed to obtain the factor matrix of the scene dimension. Keeping the hardware dimension and scene dimension unchanged, the three-dimensional heterogeneous tensor matrix is ​​expanded into a two-dimensional expanded matrix along the performance index dimension. The covariance matrix is ​​calculated and decomposed to obtain the factor matrix of the performance index dimension. S27. Using the three-dimensional heterogeneous tensor matrix as the multiplicand, perform continuous modulo n multiplication operations with the transpose of the factor matrix in the hardware dimension, the transpose of the factor matrix in the scene dimension, and the transpose of the factor matrix in the performance index dimension, respectively. By continuously projecting and shrinking along the three dimensions, calculate the kernel tensor that describes the nonlinear coupling relationship between the graphics card hardware parameters and the application task load. S28. Read the extracted kernel tensor and perform tensor product operation again with the generated three-dimensional factor matrix to reconstruct the high-dimensional kernel tensor into a low-dimensional feature matrix. Then, read the numerical data in the reconstructed feature matrix in row-major order and convert it into vector format to generate the deep computing power feature vector.

4. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S3 specifically includes: S31. Read the generated deep computing power feature vector, classify and store the values ​​in the deep computing power feature vector according to the graphics card model and the corresponding application software environment features, establish an index containing the correspondence between hardware parameters and scene labels, and build a computing power feature profile library for application scenarios. S32. Extract all deep computing power feature vectors within the historical time period from the computing power feature profile library, calculate the Euclidean distance between every two deep computing power feature vectors, classify feature vectors with a distance value less than the preset clustering radius into the same category, calculate the average vector of all feature vectors in each category, use the average vector as the center of the corresponding category, and generate a standardized computing power fingerprint template. S33. Obtain the input parameters of the user's task to be configured, convert the input parameters into a task feature vector of the same dimension as the deep computing power feature vector according to a preset format, calculate the spatial distance value between the task feature vector and each standardized computing power fingerprint template, and mark the template with the smallest value as the best matching template. S34. Based on the graphics card sensitivity tags associated with the best matching template, identify the specific sensitivity type of the user's current task to memory bandwidth, number of computing cores and texture fill rate, and read the load peak data in the template to determine the load pressure mode. S35. Combine the identified specific sensitivity types with the load pressure patterns to generate feature description data and output it as the target task feature profile.

5. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S4 specifically includes: S41. Read the target task feature profile, use the feature values ​​as random number seeds to generate an initial noise vector and input it into the generator's preset first fully connected neural network layer, then map it to a high-dimensional feature space. Input the mapped feature vector into a preset one-dimensional transposed convolutional layer, extend the length of the feature vector to the preset dimension of the graphics card configuration parameters, and output the preliminary configuration scheme. S42. The numerical parameters in the preliminary configuration scheme are mixed and shuffled with the real historical configuration parameters stored in the database and input into the input layer of the discriminator. The discriminator extracts features from the input data through a preset multi-layer convolutional structure. The extracted last layer feature map is flattened into a one-dimensional feature vector. Each element in the one-dimensional feature vector is multiplied by the weight value of the preset fully connected layer of the discriminator and accumulated. After being mapped by the activation function, the output real value is used as the discrimination score. S43. Calculate the difference between the average discrimination score corresponding to the preliminary configuration scheme and the average discrimination score corresponding to the real historical configuration parameters to obtain the Wasserstein distance. Generate a uniformly distributed random number between 0 and 1 on the straight line between the parameter points of the preliminary configuration scheme and the parameter points of the real historical configuration. Multiply the random number by the value of the real configuration parameter point, subtract the random number from 1 and multiply it by the value of the preliminary configuration parameter point. Add the two products to obtain the interpolation point and calculate the derivative with respect to the input parameters. S44. Squaring the calculated derivative, subtracting the constant 1 from the squared result, squaring the subtraction result to obtain the gradient penalty term, multiplying it by the preset penalty coefficient, adding the product to the Wasserstein distance to construct the total loss function, calculating the partial derivative of the total loss function with respect to each element in the generator weight matrix and the discriminator weight matrix, multiplying each partial derivative value by the set learning rate to obtain the update amount of each weight value, subtracting the corresponding update amount from the original weight value to complete one parameter iteration optimization; S45. Extract multiple sets of graphics card configuration records from the historical running data, subtract the overall average of all configuration records from each value in each set of configuration records to obtain the centered data, and multiply it with the corresponding transpose matrix to obtain the covariance matrix. Solve for the eigenvalues ​​and eigenvectors of the covariance matrix. S46. Sort the eigenvalues ​​from largest to smallest, select the eigenvectors corresponding to the preset number of eigenvalues ​​at the top of the sort as projection axes, multiply the centered data matrix with the projection axis matrix to obtain the low-dimensional coordinate points after projection, and connect all the coordinate points to construct a low-dimensional embedded data manifold. S47. Connect an orthogonal projection layer to the output of the generator. Arbitrarily select a data point on the data manifold and construct a tiny tangent plane with the data point as the center. Select a preset extremely short vector along two different coordinate axes in the tangent plane. Calculate the cross product of the two vectors to obtain a normal vector perpendicular to the tangent plane. Divide each value of the normal vector by the square root of the sum of the squares of all values ​​of the normal vector and normalize the length of the normal vector to 1. S48. Read each parameter value point in the preliminary configuration scheme, calculate the straight-line distance from the parameter value point to the nearest point on the data manifold. If the calculated straight-line distance value is greater than the preset tolerance threshold, it is determined that the parameter point is located in a physically infeasible area. Starting from the parameter point, move along the normalized normal vector direction or the opposite direction. The moving distance is equal to the calculated straight-line distance value. Force the parameter point to move to the data manifold surface. S49. Traverse all parameter points after projection correction, check whether the video memory capacity value of each parameter point is less than or equal to zero and whether the core frequency value is negative. If any value is negative or zero, remove the current parameter point. Sort the remaining parameter points from high to low according to the corresponding discrimination score, select the preset number of parameter points at the top of the sort as the final result, and filter out the candidate configuration subset.

6. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S5 specifically includes: S51. Obtain the user's natural language demand description and input it into the pre-trained natural language processing (NLP) model. Extract words containing currency symbols and number combinations from the text as the budget limit, extract words containing length units and number combinations as the space size limit, extract words representing energy consumption priority and convert them into corresponding values ​​as energy efficiency preference weights to obtain hard constraint indicators. S52. Read the parameter points in the subset of candidate configurations and obtain the corresponding graphics card performance score, total power consumption value and hardware cost price by querying the preset hardware specification parameter table. Take the graphics card performance score as the maximization objective and the total power consumption value and hardware cost price as the minimization objective to construct the objective function of the multi-objective optimization problem. Use the Pareto multi-objective optimization algorithm to calculate the objective function, filter out the configuration schemes that will cause the other objectives to decrease if any objective is improved, and combine them into the optimal solution set. S53. Convert all parameters of each configuration scheme in the optimal solution set into a binary encoding sequence, convert the budget upper limit and space size limit in the hard constraint indicators into the corresponding binary standard sequence, compare the binary encoding sequence of the configuration scheme with the binary standard sequence bit by bit, count the number of different digits in each bit as the Hamming distance, and multiply it with the energy efficiency preference weight to calculate the weighted Hamming distance. S54. Sort all configuration schemes in the optimal solution set in ascending order of the calculated weighted Hamming distance value, select the configuration scheme ranked first, and extract the graphics card model, video memory capacity, core frequency and power parameters contained in the configuration scheme as the final graphics card workstation configuration parameters.

7. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S6 specifically includes: sending the graphics card workstation configuration parameters to the physical workstation, collecting real-time load data of the physical workstation in the background, comparing the real-time load data with the target task feature profile, and if the performance fluctuation is detected to exceed the preset fluctuation threshold, calling the PID algorithm to adaptively and dynamically correct the power consumption limit, fan speed curve and memory frequency of the graphics card according to the deviation of the real-time load status.

8. The intelligent configuration method for graphics card workstations based on big data analysis according to claim 1, characterized in that, S7 specifically includes: constructing incremental samples from the dynamically adjusted final operating parameters and corresponding actual operating performance data and feeding them back to the original holographic operating state dataset in real time; using the incremental data to perform rolling updates on the three-dimensional heterogeneous tensor matrix; and performing continuous iterative self-optimization of the configuration model.

Images