Machine learning-based intelligent generation system for overall machine configuration

Abstract

The application relates to the technical field of intelligent generation of computer hardware configuration, and discloses a whole-machine configuration intelligent generation system based on machine learning, which comprises a demand acquisition unit, a feature analysis unit and a configuration generation unit. The demand acquisition unit obtains user configuration demands through an interactive interface and carries out format standardization processing; the feature analysis unit extracts key demand features by using a natural language understanding model; and the configuration generation unit generates a candidate configuration scheme by calling a model according to the key features. The system also evaluates the rationality of the scheme by using a random forest model, diagnoses the problem type by using a sequence neural model, and dynamically optimizes configuration parameters. The application realizes intelligent generation and optimization of the configuration scheme, and improves the accuracy of the configuration scheme and user satisfaction.

Description

Technical Field

[0001] This invention relates to the field of intelligent generation technology for computer hardware configuration, specifically to an intelligent generation system for whole-machine configuration based on machine learning. Background Technology

[0002] In today's rapidly developing information technology landscape, the field of system configuration generation faces numerous challenges. As user demands for system configurations become increasingly diverse and personalized, traditional configuration generation methods are revealing significant limitations. Traditional configuration generation often relies on manual experience or simple rules, making it difficult to efficiently process massive amounts of complex user requirements. User-inputted configuration requirements are typically unstructured, varied in expression, and may contain repetitions. Manual processing is not only inefficient but also prone to omissions or misunderstandings, leading to deviations between the generated configuration and the user's actual needs.

[0003] Traditional methods lack a deep understanding of semantics and syntax when extracting key requirements, making it difficult to accurately grasp the core of user needs. For example, traditional methods struggle to comprehensively and accurately extract and analyze multi-dimensional requirements such as performance, scalability, and cost, thus affecting the quality of subsequent configuration scheme generation.

[0004] Traditional methods for generating candidate configuration schemes typically employ single-objective optimization, failing to comprehensively consider multiple interrelated factors such as performance, scalability, and cost. This results in configuration schemes that may perform well in one aspect but fall short in others, making it difficult to meet users' overall requirements for system configuration.

[0005] When the generated configuration is unreasonable, traditional methods lack effective evaluation and diagnostic mechanisms, making it impossible to quickly and accurately determine the problem type and make targeted optimizations. This not only increases the time cost of configuration generation but may also lead to a decrease in user satisfaction.

[0006] With the development of machine learning technology, although there have been some attempts to apply machine learning to configuration generation, existing technologies still have shortcomings in areas such as standardizing the format of requirement information, dynamically filtering key features, multi-objective optimization, and evaluating and optimizing solutions. These limitations prevent the intelligent and efficient generation of complete system configurations. Therefore, there is an urgent need for a machine learning-based intelligent system for generating complete system configurations to address the aforementioned problems in traditional methods, improve the efficiency and quality of complete system configuration generation, and meet the increasingly diverse needs of users. Summary of the Invention

[0007] The purpose of this invention is to provide an intelligent system for generating complete machine configurations based on machine learning, so as to solve the problems mentioned in the background art.

[0008] To achieve the above objectives, the present invention provides the following technical solution: an intelligent system for generating system configuration based on machine learning, the system comprising:

[0009] Requirements Acquisition Unit: Acquires configuration requirements information input by users through an interactive interface, performs format standardization processing, and obtains structured requirements data;

[0010] Feature parsing unit: Based on structured requirement data, it uses a natural language understanding model to extract key requirement features;

[0011] Configuration generation unit: Based on key requirement characteristics, it calls the configuration generation model to generate candidate configuration schemes.

[0012] Preferably, the specific methods for obtaining configuration requirement information input by the user through the interactive interface and performing format standardization processing to obtain structured requirement data include:

[0013] The input requirement information is deduplicated using a duplicate item detection algorithm to obtain deduplicated requirement data; semantic normalization technology is then used to unify the representation of the deduplicated requirement data to obtain structured requirement data.

[0014] Preferably, the specific methods for extracting key requirement features using a natural language understanding model based on structured requirement data include:

[0015] Step S1: Use word embedding algorithm to calculate the feature vector of each sentence in the semantic space and syntactic space in the structured requirement data; introduce an attention mechanism based on the feature vectors in the semantic space and syntactic space to calculate the feature weights;

[0016] Step S2: Dynamically filter key features by calculating the mean and variance of feature weights;

[0017] Step S3: When the feature weight of a statement is greater than the high threshold, it is a core requirement feature and is directly retained; when the feature weight of a statement is between the low threshold and the high threshold, proceed to step S4 to determine whether to retain or discard it; when the feature weight of a statement is less than the low threshold, it is a secondary requirement feature and is discarded.

[0018] Step S4: Calculate the feature relevance based on the feature vectors of the semantic space and syntactic space; for each statement, use the cosine similarity algorithm to calculate the relevance feature weights of two adjacent statements in the relevance direction, and compare the relevance feature weights with the feature weights of the current statement; when the feature weight of the current statement is greater than or equal to the relevance feature weight, the statement is retained as a key requirement feature; when the feature weight of the current statement is less than the relevance feature weight, the statement is discarded.

[0019] Preferably, the specific method for generating candidate configuration schemes by invoking the configuration generation model based on key requirement characteristics includes:

[0020] Key requirements include performance requirements, scalability requirements, and cost requirements.

[0021] Based on the extracted key demand features, a set of demand features is obtained using a feature fusion algorithm;

[0022] By using a set of demand features and a multi-objective optimization algorithm, the suitability of each configuration parameter is calculated to obtain the performance requirement parameters.

[0023] Based on the correlation degree from the m-th demand feature to the previous demand feature and the feature strength from the m-th demand feature to the next demand feature, the scalability demand parameters are calculated using a dynamic programming algorithm.

[0024] The constraint satisfaction algorithm is used to calculate the cost requirement parameters between the m-th demand feature and the preceding and following demand features.

[0025] Preferably, based on key demand characteristics and environmental parameters, a random forest model is used to evaluate the rationality of candidate configuration schemes, specifically including:

[0026] Based on key demand features and environmental parameters, interpolation imputation is used to handle missing and outlier values, and Z-score is used for standardization to obtain a comprehensive feature dataset; the comprehensive feature dataset is then used as input to the random forest model.

[0027] Initialize hyperparameters using grid search, including the number of trees, maximum depth, minimum number of sample splits, and maximum number of features; initialize the weights and biases of the base classifiers using heuristics.

[0028] Calculate the initial error function value of the random forest model;

[0029] In each iteration, gradient boosting is used to update the weights and biases of the base classifier, and a new error function is calculated during the update process.

[0030] When the maximum number of iterations is reached, the iteration stops, and the weights and biases of the final base classifier are output. The decision score is calculated using the final weights and biases. If the decision score is greater than the set threshold, it indicates that the candidate configuration is reasonable. If the decision score is less than or equal to the set threshold, it indicates that the candidate configuration is unreasonable.

[0031] Preferably, when an unreasonable candidate configuration scheme is detected, a sequence neural model is used to determine the problem type, wherein the sequence neural model specifically includes:

[0032] The input layer takes the key requirements and environmental parameters of unreasonable candidate configuration schemes as input; the number of neurons is set to be equal to the dimension of the input data.

[0033] The hidden layer passes the input data from the input layer to the first hidden layer. Through linear transformation and the Swish activation function, the output of the first hidden layer is obtained. The output of the first hidden layer is passed to the next hidden layer. The Swish activation function is used repeatedly to calculate the output of the next hidden layer until the last hidden layer is reached and the output of the last hidden layer is obtained.

[0034] The output layer passes the output of the last hidden layer to the output layer, and uses a linear transformation to project the hidden layer output onto the three-dimensional problem type space, outputting the output value of the three-dimensional problem type; where the first dimension problem type is insufficient performance, the second dimension problem type is insufficient scalability, and the third dimension problem type is excessive cost.

[0035] Preferably, the method of using a sequence neural model to determine the problem type includes:

[0036] The probability of the question type is calculated by using the Softmax activation function based on the output value of the 3D question type from the output layer.

[0037] The algorithm determines the final problem type. When the set number of iterations is reached, iteration stops, and the probability of the final problem type is output. The final probabilities of the three-dimensional problem types are compared, and the one with the higher probability is selected as the primary problem in the candidate configuration scheme. If the final probability of the first-dimensional problem type is greater than that of the second and third-dimensional problem types, the problem type is insufficient performance. If the final probability of the second-dimensional problem type is greater than that of the first and third-dimensional problem types, the problem type is insufficient scalability. If the final probability of the third-dimensional problem type is greater than that of the first and second-dimensional problem types, the problem type is excessive cost.

[0038] Preferably, the specific method for calculating the probability of a three-dimensional problem type using the Softmax activation function includes:

[0039] For the output value of the nth question type from the output layer, the dynamic weight of the nth question type, and the adjustment coefficient of the nth question type, the probability of the nth question type is calculated using the Softmax activation function;

[0040] The calculation steps for the adjustment coefficient are as follows: for the initial adjustment coefficient, the exponential smoothing method is used to calculate the smoothing adjustment coefficient; the adaptive adjustment method is used to calculate the adaptive adjustment coefficient; and the smoothing adjustment coefficient and the adaptive adjustment coefficient are combined to calculate the final adjustment coefficient.

[0041] Preferably, when the problem type is insufficient performance, a dynamic optimization control model is used to adjust the configuration generation parameters to improve the performance of the configuration scheme, specifically including:

[0042] When the problem type is insufficient performance, use performance testing tools to measure the actual performance indicators of the current configuration scheme, and calculate the performance gap by comparing the actual performance indicators with the target performance indicators. For the performance gap, use a dynamic optimization control model to adjust the weight of the configuration generation parameters to improve the performance of the configuration scheme to the target range.

[0043] Preferably, when the problem type is insufficient scalability, a dynamic optimization control model is used to adjust the configuration generation parameters to enhance the scalability of the configuration scheme, specifically including:

[0044] An interface testing tool is used to detect the supported types and number of hardware interfaces in the configuration scheme, and the actual expansion capability is calculated based on the interface information. The expansion capability deviation is calculated based on the actual expansion capability and the target expansion capability. Based on the expansion capability deviation, a dynamic optimization control model is used to calculate the interface parameter adjustment amount, and the interface weight of the configuration generation parameters is adjusted to optimize the scalability of the configuration scheme.

[0045] Compared with the prior art, the beneficial effects of the present invention are:

[0046] In the requirement collection stage, after obtaining user configuration requirement information through the interactive interface, duplicate item detection algorithm is used for deduplication, and semantic normalization technology is used to achieve unified expression, resulting in structured requirement data. This process effectively improves the standardization and accuracy of requirement information, avoids misunderstanding caused by information duplication or expression differences, and lays a solid foundation for subsequent feature analysis and configuration generation.

[0047] The feature parsing unit extracts key requirement features based on structured requirement data using a natural language understanding model. Specifically, it calculates feature vectors of sentences in the semantic and syntactic spaces through word embedding algorithms, introduces an attention mechanism to calculate feature weights, and dynamically filters key features by combining mean and variance. Furthermore, it optimizes the filtering results by calculating feature correlation. This multi-dimensional feature extraction and filtering method accurately captures the core of user needs, ensuring that no important requirement features are overlooked, thus providing a strong guarantee for generating configuration solutions that meet user expectations.

[0048] The configuration generation unit, based on extracted key requirement features including performance, scalability, and cost, invokes a configuration generation model to generate candidate configuration schemes. This process employs a feature fusion algorithm to obtain a set of requirement features, a multi-objective optimization algorithm to calculate the configuration parameter fit to obtain performance requirement parameters, a dynamic programming algorithm to calculate scalability requirement parameters by combining the correlation and feature strength of requirement features, and a constraint-based algorithm to calculate cost requirement parameters. This configuration generation method, which comprehensively considers multiple factors, can generate optimized configuration schemes that balance performance, scalability, and cost, maximizing the fulfillment of users' overall system configuration requirements.

[0049] When evaluating the rationality of candidate configuration schemes, based on key requirement features and environmental parameters, data is processed using interpolation imputation and Z-score methods to obtain a comprehensive feature dataset, which is then input into a random forest model for evaluation. Simultaneously, grid search is used to initialize hyperparameters, heuristic methods are used to initialize the weights and biases of the base classifiers, and gradient boosting is used for iterative updates to ensure the accuracy of the evaluation results. When an unreasonable scheme is detected, a sequence neural model is used to determine the problem type. This model, through the design of input, hidden, and output layers, combined with the Softmax activation function to calculate the probability of the problem type, can accurately identify problem types such as insufficient performance, insufficient scalability, or excessive cost.

[0050] The system can take corresponding optimization measures for different problem types. When the problem type is insufficient performance, performance testing tools are used to measure actual performance indicators, calculate performance gaps, and adjust the weights of configuration generation parameters through a dynamic optimization control model to improve configuration scheme performance. When the problem type is insufficient scalability, interface detection tools are used to detect hardware interface information, calculate scalability deviations, and calculate interface parameter adjustment amounts through a dynamic optimization control model to adjust interface weights and optimize configuration scheme scalability. This precise problem diagnosis and targeted optimization adjustment can quickly improve unreasonable configuration schemes, enhance configuration scheme quality, and increase user satisfaction.

[0051] This invention achieves intelligent generation of system configurations through the collaborative work of various units and the application of a series of advanced algorithms, effectively improving the efficiency and accuracy of configuration generation and providing users with system configuration solutions that better meet their needs. Attached Figure Description

[0052] Figure 1 This is a schematic diagram illustrating the working principle of the machine learning-based intelligent configuration generation system described in this invention.

[0053] Figure 2 A flowchart for extracting key requirement features;

[0054] Figure 3Flowcharts generated for candidate configuration schemes;

[0055] Figure 4 The flowchart for calculating the Softmax probability;

[0056] Figure 5 A flowchart for adjusting configuration parameters when performance is insufficient. Detailed Implementation

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

[0058] Please see Figures 1-5 This invention relates to a machine learning-based intelligent system for generating system configurations. The system includes a requirements acquisition unit, a feature parsing unit, and a configuration generation unit. Specific implementation details are as follows:

[0059] The requirements gathering unit acquires configuration requirements input by users through an interactive interface and performs format standardization processing to obtain structured requirements data. Specifically, the interactive interface can take various forms, such as a web page or client software interface, where users input configuration requirements such as performance requirements, functional requirements, and budget constraints. After receiving this information, the requirements gathering unit performs format standardization processing for subsequent processing.

[0060] The feature parsing unit extracts key requirement features based on structured requirement data using a natural language understanding model. This natural language understanding model can employ various machine learning models, such as recurrent neural networks (RNNs) and long short-term memory networks (LSTMs), to extract key features that significantly impact configuration generation through analysis of the structured requirement data.

[0061] The configuration generation unit calls the configuration generation model to generate candidate configuration schemes based on key requirement characteristics. The configuration generation model can be a machine learning model trained on historical configuration data, capable of generating candidate configuration schemes that meet the requirements based on the input key requirement characteristics.

[0062] Example 1:

[0063] The specific implementation method for obtaining configuration requirement information input by the user and performing format standardization processing to obtain structured requirement data in the requirement acquisition unit is as follows:

[0064] The interactive interface upon which the requirements gathering unit relies can be implemented in various forms. For example, a web interface can be built, allowing users to access the webpage through a browser and fill in configuration requirements in the corresponding input areas; alternatively, a client software interface can be developed, allowing users to install the software locally and input requirements through the software's interactive window. Regardless of the interface form, its design must consider user ease of operation, ensuring that users can clearly and accurately input various requirements, such as equipment performance requirements, functional characteristics, expected costs, and usage scenarios.

[0065] After the user completes the input of their requirements, the requirement acquisition unit first performs duplicate detection on the input information. The core principle of the duplicate detection algorithm used here is to identify duplicate information by extracting and comparing features from the text content. Specifically, the algorithm first breaks down the input requirement information into sentences or paragraphs, and then generates a corresponding feature identifier for each segmented unit, such as by calculating the hash value of the text as a feature identifier. Different text content generates different hash values, while duplicate text content will necessarily have the same hash value. In this way, the algorithm can quickly locate duplicate requirement information. For example, the user may mention the requirement of "needing a high-performance processor" multiple times during the input process, or express the same meaning in different ways. The duplicate detection algorithm can identify these essentially duplicate contents and retain only one copy, thus obtaining deduplicated requirement data. In the deduplication process, the algorithm also considers semantic-level repetition, not just the complete consistency of text characters, to ensure the accuracy and comprehensiveness of deduplication.

[0066] After deduplication, the requirement acquisition unit performs semantic normalization on the deduplicated requirement data. The purpose of semantic normalization is to transform requirement information with different expressions but the same semantic meaning into a unified expression, giving the requirement data structured and standardized characteristics. This technology requires the integration of relevant methods from the field of natural language processing. First, a semantic dictionary is constructed, containing common synonyms, near-synonyms, and standard semantic expressions corresponding to different expressions. For example, different expressions such as "high processor performance," "high-performance CPU," and "powerful central processing unit performance" all correspond to the standard expression "high processor performance" in the semantic dictionary. When processing the deduplicated requirement data, the system analyzes the semantics of each sentence, matching and mapping it with the semantic dictionary to convert it into a unified standard expression. This process may involve word segmentation, part-of-speech tagging, and semantic parsing to accurately understand the meaning of the sentences and find the corresponding standard expression.

[0067] When performing semantic normalization, it is also necessary to consider the influence of context on semantics. Some expressions may have different meanings in different contexts, so the system needs to combine the content of the preceding and following text to accurately determine the semantics of the statement and avoid normalization errors. For example, the word "memory" may refer to different concepts such as memory capacity and memory type in different contexts. The system needs to determine its specific meaning based on the context and perform the corresponding normalization process.

[0068] After semantic normalization, the originally scattered and diverse requirement information is transformed into structured requirement data with a unified structure and standardization. This structured requirement data is stored in specific data formats, such as JSON and XML, where each field has a clear definition and meaning, facilitating processing by subsequent feature parsing units. For example, the structured requirement data clearly distinguishes different types of requirements such as performance requirements, scalability requirements, and cost requirements, and represents each requirement with standardized fields and values.

[0069] Through the synergy of duplicate item detection algorithms and semantic normalization technology, the requirement acquisition unit can efficiently and accurately transform unstructured user-inputted requirement information into structured requirement data, laying a solid data foundation for subsequent key requirement feature extraction and candidate configuration scheme generation. The entire process is highly automated, requiring no manual intervention, which greatly improves the efficiency of requirement acquisition and processing while ensuring data quality and consistency. In practical applications, this process can be flexibly adjusted and optimized according to different application scenarios and needs to adapt to different types of system configuration requirement information processing. For example, the semantic dictionary can be specifically expanded and adjusted for different industries and types of equipment to improve the accuracy of semantic normalization. The parameters of the duplicate item detection algorithm can also be optimized according to the actual data characteristics to achieve better deduplication results.

[0070] Example 2:

[0071] When the configuration generation unit generates candidate configuration schemes based on key requirement characteristics, these key requirement characteristics cover dimensions such as performance, scalability, and cost. The specific implementation method is as follows:

[0072] Suppose the user's configuration requirement is "to build a workstation for graphics rendering, with a budget of 8000 yuan, supporting future upgrades to the graphics card and storage, and a rendering speed no lower than the average level of similar configurations." After processing by the requirement acquisition unit, the key requirement features extracted by the feature analysis unit include: performance requirement features (such as processor multi-core performance and graphics card rendering capabilities), scalability requirement features (such as the number of PCIe interfaces and storage slot types), and cost requirement features (total budget constraints and cost allocation for each component).

[0073] Based on these key requirements, the configuration generation unit uses a feature fusion algorithm to integrate the requirements. This algorithm performs correlation analysis on requirements across different dimensions. For example, it correlates the performance requirement of "rendering speed no less than average" with the cost requirement of "budget of 8000 yuan" to determine the performance thresholds and cost limits for the processor and graphics card. Specifically, the system assigns weights to the performance requirements of "multi-core processor" and "high-performance graphics card" with the cost requirement of "component cost not exceeding 40%", forming a set of requirements features that includes processor model, graphics card type, and budget allocation ratio.

[0074] By using a set of demand features, the system employs a multi-objective optimization algorithm to calculate the suitability of each configuration parameter to obtain the performance requirement parameters. Taking processor selection as an example, the multi-objective optimization algorithm considers factors such as multi-core performance, power consumption, and price simultaneously. Assuming candidate processors include the Intel i7-13700K and the AMD Ryzen 7 5800X, the algorithm calculates the single-core / multi-core performance scores of both processors based on the rendering task's multi-core performance requirements, while simultaneously comparing their prices to see if they fall within the cost budget. For example, the i7-13700K might have a higher multi-core performance score, but its price exceeds the budget by 20%; the Ryzen 7 5800X might have a slightly lower performance score, but its price is within the budget and its power consumption is lower. The algorithm will comprehensively evaluate through multi-objective optimization (such as weighted summation) and ultimately select the Ryzen 7 5800X, which has a higher suitability, as the processor performance parameter, ensuring that performance requirements are met within cost constraints.

[0075] When calculating scalability requirements, the system uses a dynamic programming algorithm based on the correlation and strength of the m-th requirement feature with its preceding and following features. Taking storage scalability as an example, the user requirement of "supporting future storage upgrades" is the m-th feature, preceded by "motherboard type" and followed by "storage interface type." The system first calculates the correlation between "motherboard type" and "upgradeable storage" (e.g., ATX motherboards support more storage slots than ITX motherboards, resulting in a higher correlation), and then calculates the strength of the relationship between "upgradeable storage" and "storage interface type" (e.g., NVMe interfaces have stronger expansion potential than SATA interfaces). The dynamic programming algorithm starts with motherboard selection and gradually derives the optimal storage scalability solution: if a motherboard supporting 4 SATA interfaces and 2 M.2 interfaces is selected, although the current configuration only uses 2 SATA hard drives, it can be upgraded to an NVMe SSD via the M.2 interface to meet the "support upgrades" requirement. The algorithm determines scalability parameters such as the number of motherboard interfaces and storage slot types based on the correlation and strength of the features, ensuring that the configuration meets current requirements while reserving upgrade space.

[0076] For cost requirements, the system calculates the cost allocation among various features using a constraint-satisfying algorithm. For example, under the constraint of a total budget of 8000 yuan, the costs of components such as the processor, graphics card, motherboard, storage, and power supply must meet the overall budget limit, while the compatibility between components must also meet cost constraints. Assuming the graphics card is an RTX 3060 (priced at 2500 yuan), the processor is a Ryzen 7 5800X (1800 yuan), the motherboard is a B550 (800 yuan), the storage is a 1TB NVMe hard drive (500 yuan), the power supply is a 650W (500 yuan), and the case (300 yuan), the total cost is 6400 yuan. The remaining 1600 yuan can be allocated to other components or reserved as a budget. The constraint-satisfying algorithm checks whether the total price of each component is within the budget, while ensuring the compatibility of the motherboard with the processor and graphics card (e.g., the B550 motherboard supports the PCIe interface of Ryzen 7 5800X and RTX 3060). If there is a cost overrun or compatibility issue, the algorithm will readjust the component selection, for example, replacing the RTX 3060 with an RTX 3050 (priced at 1800 yuan) to meet the cost constraint.

[0077] When generating candidate configuration schemes, the system integrates performance, scalability, and cost requirements into a specific component list. For example, for the rendering workstation requirements mentioned above, the final candidate scheme might be: Ryzen 7 5800X processor, RTX 3050 graphics card, B550 motherboard, 1TB NVMe SSD + 2TB SATA SSD, 650W power supply, and mid-tower case. This scheme satisfies the performance requirement of "rendering speed not below average" (guaranteed by the performance parameters of the processor and graphics card), supports future upgrades to the graphics card and storage through the motherboard's storage interfaces and PCIe interfaces (scalability requirement), and keeps the total cost under 8000 yuan (cost requirement).

[0078] Throughout the configuration generation process, the feature fusion algorithm ensures that requirements from different dimensions are comprehensively considered, the multi-objective optimization algorithm balances multiple factors in performance parameter selection, the dynamic programming algorithm derives scalability solutions based on the correlation between requirements, and the constraint satisfaction algorithm guarantees cost and compatibility requirements. Through the synergistic effect of these algorithms, the system can generate reasonable candidate configuration schemes based on the user's key requirement characteristics. Each step combines the logical correlation and constraints of specific requirement characteristics to ensure the accuracy and feasibility of the scheme. In practical applications, this generation process can adjust algorithm parameters and requirement weights according to different types of complete machines (such as servers, game consoles, and office computers). For example, game consoles focus more on graphics card performance and power scalability, while servers focus more on processor multi-core performance and storage capacity, thereby generating configuration schemes adapted to different scenarios.

[0079] Example 3:

[0080] When the configuration generation unit generates candidate configuration schemes based on key requirement characteristics, these key requirement characteristics cover dimensions such as performance, scalability, and cost. The specific implementation method is as follows:

[0081] Suppose the user's configuration requirement is "to build a workstation for graphics rendering, with a budget of 8000 yuan, supporting future upgrades to the graphics card and storage, and a rendering speed no lower than the average level of similar configurations." After processing by the requirement acquisition unit, the key requirement features extracted by the feature analysis unit include: performance requirement features (such as processor multi-core performance and graphics card rendering capabilities), scalability requirement features (such as the number of PCIe interfaces and storage slot types), and cost requirement features (total budget constraints and cost allocation for each component).

[0082] Based on these key requirements, the configuration generation unit uses a feature fusion algorithm to integrate the requirements. This algorithm performs correlation analysis on requirements across different dimensions. For example, it correlates the performance requirement of "rendering speed no less than average" with the cost requirement of "budget of 8000 yuan" to determine the performance thresholds and cost limits for the processor and graphics card. Specifically, the system assigns weights to the performance requirements of "multi-core processor" and "high-performance graphics card" with the cost requirement of "component cost not exceeding 40%", forming a set of requirements features that includes processor model, graphics card type, and budget allocation ratio.

[0083] By using a set of demand features, the system employs a multi-objective optimization algorithm to calculate the suitability of each configuration parameter to obtain the performance requirement parameters. Taking processor selection as an example, the multi-objective optimization algorithm considers factors such as multi-core performance, power consumption, and price simultaneously. Assuming candidate processors include the Intel i7-13700K and the AMD Ryzen 7 5800X, the algorithm calculates the single-core / multi-core performance scores of both processors based on the rendering task's multi-core performance requirements, while simultaneously comparing their prices to see if they fall within the cost budget. For example, the i7-13700K might have a higher multi-core performance score, but its price exceeds the budget by 20%; the Ryzen 7 5800X might have a slightly lower performance score, but its price is within the budget and its power consumption is lower. The algorithm will comprehensively evaluate through multi-objective optimization (such as weighted summation) and ultimately select the Ryzen 7 5800X, which has a higher suitability, as the processor performance parameter, ensuring that performance requirements are met within cost constraints.

[0084] When calculating scalability requirements, the system uses a dynamic programming algorithm based on the correlation and strength of the m-th requirement feature with its preceding and following features. Taking storage scalability as an example, the user requirement of "supporting future storage upgrades" is the m-th feature, preceded by "motherboard type" and followed by "storage interface type." The system first calculates the correlation between "motherboard type" and "upgradeable storage" (e.g., ATX motherboards support more storage slots than ITX motherboards, resulting in a higher correlation), and then calculates the strength of the relationship between "upgradeable storage" and "storage interface type" (e.g., NVMe interfaces have stronger expansion potential than SATA interfaces). The dynamic programming algorithm starts with motherboard selection and gradually derives the optimal storage scalability solution: if a motherboard supporting 4 SATA interfaces and 2 M.2 interfaces is selected, although the current configuration only uses 2 SATA hard drives, it can be upgraded to an NVMe SSD via the M.2 interface to meet the "support upgrades" requirement. The algorithm determines scalability parameters such as the number of motherboard interfaces and storage slot types based on the correlation and strength of the features, ensuring that the configuration meets current requirements while reserving upgrade space.

[0085] For cost requirements, the system calculates the cost allocation among various features using a constraint-satisfying algorithm. For example, under the constraint of a total budget of 8000 yuan, the costs of components such as the processor, graphics card, motherboard, storage, and power supply must meet the overall budget limit, while the compatibility between components must also meet cost constraints. Assuming the graphics card is an RTX 3060 (priced at 2500 yuan), the processor is a Ryzen 7 5800X (1800 yuan), the motherboard is a B550 (800 yuan), the storage is a 1TB NVMe hard drive (500 yuan), the power supply is a 650W (500 yuan), and the case (300 yuan), the total cost is 6400 yuan. The remaining 1600 yuan can be allocated to other components or reserved as a budget. The constraint-satisfying algorithm checks whether the total price of each component is within the budget, while ensuring the compatibility of the motherboard with the processor and graphics card (e.g., the B550 motherboard supports the PCIe interface of Ryzen 7 5800X and RTX 3060). If there is a cost overrun or compatibility issue, the algorithm will readjust the component selection, for example, replacing the RTX 3060 with an RTX 3050 (priced at 1800 yuan) to meet the cost constraint.

[0086] When generating candidate configuration schemes, the system integrates performance, scalability, and cost requirements into a specific component list. For example, for the rendering workstation requirements mentioned above, the final candidate scheme might be: Ryzen 7 5800X processor, RTX 3050 graphics card, B550 motherboard, 1TB NVMe SSD + 2TB SATA SSD, 650W power supply, and mid-tower case. This scheme satisfies the performance requirement of "rendering speed not below average" (guaranteed by the performance parameters of the processor and graphics card), supports future upgrades to the graphics card and storage through the motherboard's storage interfaces and PCIe interfaces (scalability requirement), and keeps the total cost under 8000 yuan (cost requirement).

[0087] Throughout the configuration generation process, the feature fusion algorithm ensures that requirements from different dimensions are comprehensively considered, the multi-objective optimization algorithm balances multiple factors in performance parameter selection, the dynamic programming algorithm derives scalability solutions based on the correlation between requirements, and the constraint satisfaction algorithm guarantees cost and compatibility requirements. Through the synergistic effect of these algorithms, the system can generate reasonable candidate configuration schemes based on the user's key requirement characteristics. Each step combines the logical correlation and constraints of specific requirement characteristics to ensure the accuracy and feasibility of the scheme. In practical applications, this generation process can adjust algorithm parameters and requirement weights according to different types of complete machines (such as servers, game consoles, and office computers). For example, game consoles focus more on graphics card performance and power scalability, while servers focus more on processor multi-core performance and storage capacity, thereby generating configuration schemes adapted to different scenarios.

[0088] Example 4:

[0089] When evaluating the rationality of candidate configuration schemes using a random forest model based on key demand characteristics and environmental parameters, the specific implementation method is as follows:

[0090] Assume the user-generated candidate configuration is "Intel i5-12400F processor, GTX1650 graphics card, 16GB RAM, 512GB NVMe hard drive, 400W power supply," with environmental parameters including usage scenario of "daily office work," ambient temperature of 25℃, and mains voltage of 220V. The system first preprocesses key requirements (such as "multitasking" in performance requirements and "budget of 4000 yuan" in cost requirements) and environmental parameters.

[0091] In the preprocessing stage, the system uses interpolation to handle missing and outlier values. For example, if "8GBGB" is mistakenly entered as a memory parameter, the system will identify it as an outlier and fill it with a linear interpolation using a neighboring reasonable value (such as 16GB). If power parameters are missing, the system will fill them with interpolation based on the power consumption requirements of the processor and graphics card, using the power consumption-power mapping relationship in historical data. Next, Z-score standardization is used to convert all feature data into a standard normal distribution with a mean of 0 and a standard deviation of 1. The standardization formula is:

[0092]

[0093] Where z is the standardized value, x is the original feature value, μ is the mean of the feature, and σ is the standard deviation of the feature. For example, if the original price of a processor is 1200 yuan, the mean of the feature is 1500 yuan, and the standard deviation is 300 yuan, then the standardized value is... Ensure that features of different dimensions (such as price, power consumption, and performance score) are comparable. After processing, a comprehensive feature dataset is obtained, which includes fields such as processor model, price, power consumption, graphics card performance score, memory capacity, storage type, power supply, and ambient temperature.

[0094] The comprehensive feature dataset is used as input to the random forest model. The model initialization phase employs a combination of grid search and heuristic methods. The grid search iterates through preset hyperparameter combinations, such as setting the number of trees to [50, 100, 200], the maximum depth to [10, 20, 30], the minimum number of splits to [2, 5, 10], and the maximum number of features to ['auto', 'sqrt', 'log2']. For each set of hyperparameters, the system uses k-fold cross-validation (e.g., 5-fold) to evaluate the model's accuracy on the validation set and selects the hyperparameter combination with the highest accuracy. For example, when the number of trees is 100, the maximum depth is 20, the minimum number of splits is 5, and the maximum number of features is 'sqrt', the validation set accuracy is the highest, and this combination is determined to be the optimal hyperparameter.

[0095] The weights and biases of the base classifier are initialized heuristically, setting initial values ​​based on feature importance and historical data distribution. For example, for the two strongly correlated features, "processor power consumption" and "power supply power," the system assigns higher initial weights, making the base classifier pay more attention to the correlation of such key features; the bias term is initialized based on the average feature values ​​of historically reasonable configuration schemes, ensuring that the model's initial prediction direction conforms to prior knowledge.

[0096] After initialization, the initial error function value of the random forest model is calculated. The error function uses the mean squared error (MSE), and the formula is:

[0097]

[0098] Where n is the number of samples, y i For actual labels (1 indicates reasonable, 0 indicates unreasonable), This represents the model's predicted value. Assuming that 30 out of 100 samples are predicted incorrectly in the initial prediction, the initial MSE can be calculated using the formula above.

[0099] During the iteration process, the system uses gradient boosting to update the weights and biases of the base classifiers. At each iteration, the model calculates the gradient between the current predicted value and the actual label, adjusting the parameters in the opposite direction of the gradient to reduce error. For example, if a base classifier mispredicts the "insufficient power" configuration, gradient boosting increases the weight of the "power" feature in that classifier, making it pay more attention to this feature in subsequent predictions. After each update, a new error function is recalculated; if the error decreases, the update is retained; otherwise, the parameters are rolled back.

[0100] When the maximum number of iterations (e.g., 500) is reached, iteration stops, and the weights and biases of the final base classifiers are output. The decision score is calculated using the final parameters; the decision score is the weighted sum of the outputs of each base classifier, as shown in the formula:

[0101]

[0102] Where k is the number of base classifiers, w j f is the weight of the j-th base classifier. j (x) represents the output value of the j-th base classifier for input x, and b is the bias term. A threshold of 0.5 is set. If the decision score is greater than 0.5, the candidate configuration is considered reasonable; if it is less than or equal to 0.5, it is considered unreasonable.

[0103] Taking the previous candidate configuration as an example, assuming that there is a significant gap between the power of the "400W power supply" in the comprehensive feature dataset and the theoretical safe power of the total power consumption of the processor (65W) and graphics card (75W) (140W) (a 30% margin needs to be reserved, i.e., 140×1.3=182W), the random forest model, through the voting mechanism of multiple trees and combined with the sample feature of "insufficient power supply leading to unreasonable configuration" in historical data, may ultimately decide that the score is 0.3, which is less than the threshold of 0.5, and the scheme is judged to be unreasonable.

[0104] Throughout the evaluation process, preprocessing ensures data quality, grid search and heuristic initialization optimize model parameters, gradient boosting iteratively optimizes classifier performance, and finally, decision scores accurately determine the rationality of the configuration scheme. This process does not rely on hypothetical experimental data but is based on a logical flow of feature preprocessing, model training, and iterative optimization, ensuring the reliability of the evaluation results. In practical applications, feature weights and thresholds can be adjusted according to different types of system configurations (such as servers and game consoles). For example, servers have higher requirements for power redundancy, so the weight of the "power consumption" feature can be increased and a reasonable threshold lowered to rigorously evaluate the reliability of the configuration scheme.

[0105] Example 5:

[0106] When an unreasonable candidate configuration is detected, the specific implementation method for using a sequence neural model to determine the problem type and make adjustments is as follows:

[0107] Suppose the system generates a candidate configuration of "AMD Ryzen 5 5600G processor, GTX 1050 Ti graphics card, 8GB RAM, 256GB SSD, 300W power supply" for a 1080P resolution gaming PC. The random forest model evaluates this configuration and determines it to be unreasonable. At this point, the system inputs key requirements (such as "game frame rate no less than 60 FPS" and "budget 3500 yuan") and environmental parameters (usage scenario: "gaming entertainment," ambient temperature 30℃) into the sequence neural model.

[0108] The number of neurons in the input layer of a sequence neural model is consistent with the dimensionality of the input data. Assuming the input data contains 10 features (processor model, graphics card performance score, memory capacity, storage capacity, power supply, budget allocation, usage scenario, temperature, frame rate requirement, cost constraints), then the input layer is set with 10 neurons, each neuron corresponding to a standardized value of a feature, such as a processor performance score of 0.7, a standardized value of memory capacity of -0.5, etc.

[0109] The hidden layers employ a multi-layered structure, for example, with three hidden layers, each containing 20, 15, and 10 neurons respectively. When input data is passed from the input layer to the first hidden layer, it undergoes a linear transformation: z1 = W1x + b1, where W1 is the weight matrix and b1 is the bias vector. After the linear transformation, the output is activated by the Swish activation function: f(z) = z·σ(z) (σ is the sigmoid function), giving the output a non-linear characteristic. For example, if the linear combination of the inputs to a neuron in the first hidden layer is 2.5, after Swish activation, the output will be approximately 2.5 × 0.71 = 1.78. This output serves as the input to the next hidden layer, repeating the linear transformation and activation process until the last hidden layer outputs a feature vector of dimension 5, which contains an abstract feature representation of the input data.

[0110] The output layer projects the output of the last hidden layer onto a three-dimensional problem type space through a linear transformation, outputting the output value for the three-dimensional problem type. Assuming the output of the last hidden layer is [1.2, -0.8, 0.5, 0.9, -1.1], after transformation using the weight matrix of the output layer, the three-dimensional output value is obtained as [2.1, 0.5, 3.2], corresponding to the original output values ​​for insufficient performance, insufficient scalability, and excessive cost, respectively.

[0111] When calculating the probability of the question type, the Softmax activation function is used to convert the three-dimensional output values ​​into a probability distribution. The expression for the Softmax function is: Where v i Let be the output value of the i-th dimension. For example, the probability of insufficient performance after Softmax calculation of the above three-dimensional output value [2.1, 0.5, 3.2] is... The probability of insufficient scalability is about 0.06, and the probability of cost exceeding the budget is about 0.70, indicating that cost exceeding the budget may be the main problem.

[0112] The adjustment coefficient is calculated using a combination of exponential smoothing and adaptive adjustment. The initial adjustment coefficient is set to 1. Exponential smoothing dynamically updates the smoothing coefficient based on historical errors; for example, if the error in the previous iteration was large, the smoothing coefficient increases by 0.1. Adaptive adjustment adjusts the adaptive coefficient based on the fluctuation range of the current output value; for example, if the output value fluctuates drastically, the adaptive coefficient decreases by 0.05. The final adjustment coefficient is a weighted sum of the smoothing adjustment coefficient and the adaptive adjustment coefficient (e.g., each accounting for 50%), used to adjust the output value in the Softmax function, making the probability calculation more closely match the current data distribution.

[0113] When the set number of iterations (e.g., 200) is reached, iteration stops, and the final probabilities of the three-dimensional problem types are compared. Assuming the final probabilities are 0.35 for performance inadequacy, 0.10 for scalability inadequacy, and 0.55 for cost overrun, the problem type is determined to be cost overrun since cost overrun has the highest probability. Further analysis reveals that the GTX 1050 Ti graphics card in the candidate configuration costs 1200 yuan, accounting for 34% of the total budget of 3500 yuan, while the RX 6500 XT with equivalent performance costs only 800 yuan, indicating room for cost optimization.

[0114] For issues exceeding cost limits, the system uses a dynamic optimization control model to adjust configuration generation parameters. First, the cost weights of each component are recalculated, reducing the graphics card's cost weight (e.g., from 30% to 25%) while increasing the processor and memory cost weights (e.g., processor from 25% to 28%, memory from 15% to 18%). Then, based on the new cost weights, a new candidate configuration is generated: the processor remains a Ryzen 5 5600G (priced at 1000 yuan), the graphics card is replaced with an RX 6500XT (800 yuan), memory is upgraded to 16GB (500 yuan), storage is expanded to a 512GB SSD (400 yuan), the power supply remains at 300W (200 yuan), and the case costs 300 yuan. The total cost is 1000 + 800 + 500 + 400 + 200 + 300 = 3200 yuan, meeting the budget requirements.

[0115] If the issue type is insufficient performance, for example, if the candidate configuration is "Intel i3-10100F, GT1030 graphics card, 8GB RAM" for video editing, the system will use performance testing tools to measure the actual rendering time of the current configuration (e.g., a 10-minute video takes 45 minutes to render) and calculate the performance difference compared to the target rendering time (30 minutes). The dynamic optimization control model will increase the performance weight of the processor and graphics card (e.g., increase the processor weight from 25% to 35%), and regenerate a configuration such as i5-11400F (1200 yuan), GTX1660Super (1500 yuan), 16GB RAM (600 yuan), with a total cost of 3300 yuan, ensuring that the rendering time is shortened to the target range.

[0116] When the problem type is insufficient expandability, for example, if the configuration uses a MATX motherboard (only 2 SATA interfaces and 1 M.2 interface), and the user's requirement is "support for adding 4 hard drives later," the system uses an interface detection tool to obtain the motherboard interface information and calculates the actual expansion capability as 3 storage interfaces (2 SATA + 1 M.2), while the target expansion capability is 4, with a deviation of -1. The dynamic optimization control model calculates the interface parameter adjustment amount, changes the motherboard type to ATX (supporting 4 SATA + 2 M.2 interfaces), increases the interface weight (from 15% to 20%), and selects an ATX motherboard (700 yuan) when regenerating the configuration, replacing the original MATX motherboard (500 yuan), to ensure that the expansion capability meets the requirements.

[0117] Throughout the process, the sequence neural model extracts features and determines the problem type through a multi-layered network structure. The dynamic optimization control model adjusts configuration parameters according to the problem type, forming a closed-loop optimization. For example, in the game console case mentioned above, from identifying cost overruns to adjusting component selection and generating a new solution, each step is based on feature association of input data and model calculation, ensuring the rationality and relevance of the adjustments. In practical applications, this mechanism can adjust model parameters and optimization strategies according to different machine types (such as servers and workstations). For example, servers prioritize scalability and stability, so the weight of interface quantity and power redundancy can be increased, making problem type judgment and adjustment more aligned with scenario requirements.

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

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

Claims

1. A machine learning-based intelligent configuration generation system, characterized in that, include: Requirements Acquisition Unit: Acquires configuration requirements information input by users through an interactive interface, performs format standardization processing, and obtains structured requirements data; Feature parsing unit: Based on structured requirement data, it uses a natural language understanding model to extract key requirement features; Configuration generation unit: Based on key requirement characteristics, it calls the configuration generation model to generate candidate configuration schemes; The specific methods for generating candidate configuration schemes by invoking the configuration generation model based on key requirement characteristics include: Key requirements include performance requirements, scalability requirements, and cost requirements. Based on the extracted key demand features, a set of demand features is obtained using a feature fusion algorithm; By using a set of demand features and a multi-objective optimization algorithm, the suitability of each configuration parameter is calculated to obtain the performance requirement parameters. Based on the correlation degree from the m-th demand feature to the previous demand feature and the feature strength from the m-th demand feature to the next demand feature, the scalability demand parameters are calculated using a dynamic programming algorithm. The constraint satisfaction algorithm is used to calculate the cost requirement parameters between the m-th demand feature and the preceding and following demand features.

2. The intelligent system for generating complete machine configuration based on machine learning according to claim 1, characterized in that, The specific methods for obtaining configuration requirement information input by the user through the interactive interface and performing format standardization processing to obtain structured requirement data include: The input requirement information is deduplicated using a duplicate item detection algorithm to obtain deduplicated requirement data; semantic normalization technology is then used to unify the representation of the deduplicated requirement data to obtain structured requirement data.

3. The intelligent whole-machine configuration generation system based on machine learning according to claim 2, characterized in that, The specific methods for extracting key requirement features using a natural language understanding model based on structured requirement data include: Step S1: Use word embedding algorithm to calculate the feature vector of each sentence in the semantic space and syntactic space in the structured requirement data; introduce an attention mechanism based on the feature vectors in the semantic space and syntactic space to calculate the feature weights; Step S2: Dynamically filter key features by calculating the mean and variance of feature weights; Step S3: When the feature weight of a statement is greater than the high threshold, it is a core requirement feature and is directly retained; when the feature weight of a statement is between the low threshold and the high threshold, proceed to step S4 to determine whether to retain or discard it; when the feature weight of a statement is less than the low threshold, it is a secondary requirement feature and is discarded. Step S4: Calculate the feature relevance based on the feature vectors of the semantic space and syntactic space; for each statement, use the cosine similarity algorithm to calculate the relevance feature weights of two adjacent statements in the relevance direction, and compare the relevance feature weights with the feature weights of the current statement; when the feature weight of the current statement is greater than or equal to the relevance feature weight, the statement is retained as a key requirement feature; when the feature weight of the current statement is less than the relevance feature weight, the statement is discarded.

4. The intelligent system for generating complete machine configuration based on machine learning according to claim 1, characterized in that, Based on key demand characteristics and environmental parameters, a random forest model is used to evaluate the rationality of candidate configuration schemes, specifically including: Based on key demand features and environmental parameters, interpolation imputation is used to handle missing and outlier values, and Z-score is used for standardization to obtain a comprehensive feature dataset; the comprehensive feature dataset is then used as input to the random forest model. Initialize hyperparameters using grid search, including the number of trees, maximum depth, minimum number of sample splits, and maximum number of features; initialize the weights and biases of the base classifiers using heuristics. Calculate the initial error function value of the random forest model; In each iteration, gradient boosting is used to update the weights and biases of the base classifier, and a new error function is calculated during the update process. When the maximum number of iterations is reached, the iteration stops, and the weights and biases of the final base classifier are output. The decision score is calculated using the final weights and biases. If the decision score is greater than the set threshold, it indicates that the candidate configuration is reasonable. If the decision score is less than or equal to the set threshold, it indicates that the candidate configuration is unreasonable.

5. The intelligent system for generating complete machine configuration based on machine learning according to claim 4, characterized in that, When an unreasonable candidate configuration is detected, a sequence neural model is used to determine the problem type. The sequence neural model specifically includes: The input layer takes the key requirements and environmental parameters of unreasonable candidate configuration schemes as input; the number of neurons is set to be equal to the dimension of the input data. The hidden layer passes the input data from the input layer to the first hidden layer. Through linear transformation and the Swish activation function, the output of the first hidden layer is obtained. The output of the first hidden layer is passed to the next hidden layer. The Swish activation function is used repeatedly to calculate the output of the next hidden layer until the last hidden layer is reached and the output of the last hidden layer is obtained. The output layer passes the output of the last hidden layer to the output layer, and uses a linear transformation to project the hidden layer output onto the three-dimensional problem type space, outputting the output value of the three-dimensional problem type; where the first dimension problem type is insufficient performance, the second dimension problem type is insufficient scalability, and the third dimension problem type is excessive cost.

6. The intelligent system for generating complete machine configuration based on machine learning according to claim 5, characterized in that, The use of sequence neural models to determine the problem type includes: The probability of the question type is calculated by using the Softmax activation function based on the output value of the 3D question type from the output layer. The algorithm determines the final problem type. When the set number of iterations is reached, iteration stops, and the probability of the final problem type is output. The final probabilities of the three-dimensional problem types are compared, and the one with the higher probability is selected as the primary problem in the candidate configuration scheme. If the final probability of the first-dimensional problem type is greater than that of the second and third-dimensional problem types, the problem type is insufficient performance. If the final probability of the second-dimensional problem type is greater than that of the first and third-dimensional problem types, the problem type is insufficient scalability. If the final probability of the third-dimensional problem type is greater than that of the first and second-dimensional problem types, the problem type is excessive cost.

7. The intelligent whole-machine configuration generation system based on machine learning according to claim 6, characterized in that, The specific method for calculating the probability of a three-dimensional problem type using the Softmax activation function includes: For the output value of the nth question type from the output layer, the dynamic weight of the nth question type, and the adjustment coefficient of the nth question type, the probability of the nth question type is calculated using the Softmax activation function; The calculation steps for the adjustment coefficient are as follows: for the initial adjustment coefficient, the exponential smoothing method is used to calculate the smoothing adjustment coefficient; the adaptive adjustment method is used to calculate the adaptive adjustment coefficient; and the smoothing adjustment coefficient and the adaptive adjustment coefficient are combined to calculate the final adjustment coefficient.

8. The intelligent whole-machine configuration generation system based on machine learning according to claim 7, characterized in that, When the problem type is insufficient performance, a dynamic optimization control model is used to adjust the configuration generation parameters to improve the performance of the configuration scheme, specifically including: When the problem type is insufficient performance, use performance testing tools to measure the actual performance indicators of the current configuration scheme, and calculate the performance gap by comparing the actual performance indicators with the target performance indicators. For the performance gap, use a dynamic optimization control model to adjust the weight of the configuration generation parameters to improve the performance of the configuration scheme to the target range.

9. The intelligent system for generating complete machine configuration based on machine learning according to claim 8, characterized in that, When the problem type is insufficient scalability, a dynamic optimization control model is used to adjust the configuration generation parameters to enhance the scalability of the configuration scheme, specifically including: An interface testing tool is used to detect the supported types and number of hardware interfaces in the configuration scheme, and the actual expansion capability is calculated based on the interface information. The expansion capability deviation is calculated based on the actual expansion capability and the target expansion capability. Based on the expansion capability deviation, a dynamic optimization control model is used to calculate the interface parameter adjustment amount, and the interface weight of the configuration generation parameters is adjusted to optimize the scalability of the configuration scheme.

Images