Memory fault maintenance system and method based on random forest model, electronic equipment, storage medium and computer program product

Abstract

The invention discloses a memory fault maintenance system and method based on a random forest model, electronic equipment, a storage medium and a computer program product, and relates to the technical field of fault diagnos.The memory fault maintenance system comprises a multi-source data collection module used for collecting multi-source data of a memory in real time, the multi-source data comprises hardware signals, software logs and performance index data; the random forest classification unit is connected with the multi-source data acquisition module, comprises a trained random forest model and is used for carrying out fault identification on the multi-source data through the trained random forest model to obtain fault information of the memory; and the intelligent maintenance unit is used for determining a repair strategy according to the fault information and executing the repair strategy so as to carry out fault maintenance on the memory.

Description

Technical Field

[0001] The present application relates to the field of high-performance computing technology, and in particular to a memory fault maintenance system and method based on a random forest model, an electronic device, a storage medium, and a computer program product. Background Art

[0002] With the rapid development of big data, cloud computing, and artificial intelligence technologies, the scale of data centers and high-performance computing systems continues to expand, posing unprecedented challenges to memory quality and stability. As a core component of computer systems, memory health directly impacts overall system performance and data processing accuracy. However, existing memory fault diagnosis and maintenance technologies face numerous limitations. Primarily, most memory fault monitoring and diagnosis rely on traditional threshold-based methods. These methods set thresholds for a series of hardware signals (such as ECC error rates, temperature, and voltage) and software logs, triggering corresponding alarms when these signals exceed normal ranges. However, these methods have significant limitations: they can only simply determine whether the memory is healthy or faulty, but cannot accurately distinguish specific fault types, such as hardware damage, memory leaks, or Row Hammer attacks. Consequently, fault identification suffers from a high rate of false positives, hindering targeted remediation actions. Furthermore, the fault diagnosis and repair process relies heavily on the expertise and real-time intervention of operations and maintenance personnel. When a fault occurs, experienced engineers must analyze log files and monitoring data to determine the nature of the fault and develop a remediation strategy, a time-consuming and inefficient process.

[0003] In related technologies, memory failures are judged using traditional threshold methods, which use hardware signal monitoring and software log printing to record the health status of the memory. This method requires manual experience analysis. This method cannot distinguish specific fault types, and has insufficient classification accuracy and a high misjudgment rate. Currently, no effective solution has been proposed. Summary of the Invention

[0004] The present application provides a memory fault maintenance system and method, electronic device, storage medium, and computer program product based on a random forest model, in order to at least solve the problem in the related art that memory faults are determined using a traditional threshold determination method, which uses hardware signal monitoring and software log printing to record the health status of the memory, requires manual experience analysis, cannot distinguish specific fault types, has insufficient classification accuracy, and has a high misjudgment rate.

[0005] The present application provides a memory fault maintenance system based on a random forest model, comprising: a multi-source data acquisition module for collecting multi-source data of a memory in real time, wherein the multi-source data includes: hardware signals, software logs, and performance indicator data; a random forest classification unit, connected to the multi-source data acquisition module, comprising a trained random forest model, for performing fault identification on the multi-source data through the trained random forest model to obtain fault information of the memory; and an intelligent maintenance unit, for determining a repair strategy based on the fault information, and executing the repair strategy to perform fault maintenance on the memory.

[0006] The present application also provides a memory fault maintenance method based on a random forest model, which is applied to the above-mentioned memory fault maintenance system based on a random forest model, including: collecting the multi-source data of the memory in real time through the multi-source data acquisition module; performing fault identification on the multi-source data through the trained random forest model to obtain the fault information; determining the repair strategy according to the fault information, and executing the repair strategy to perform fault maintenance on the memory.

[0007] The present application also provides an electronic device, comprising: a memory for storing a computer program; and a processor for implementing the steps of any of the above-mentioned memory fault maintenance methods based on a random forest model when executing the computer program.

[0008] The present application also provides a computer-readable storage medium, in which a computer program is stored. When the computer program is executed by a processor, the steps of any of the above-mentioned memory fault maintenance methods based on the random forest model are implemented.

[0009] The present application also provides a computer program product, including a computer program, which, when executed by a processor, implements the steps of any of the above-mentioned memory fault maintenance methods based on the random forest model.

[0010] Through this application, a multi-level, intelligent memory fault diagnosis and maintenance system was constructed. The multi-source data acquisition module integrates hardware signals, software logs and performance indicators in real time, and uses a maturely trained random forest classification unit to identify the fault type with high precision. The intelligent maintenance unit then automatically matches and executes the optimal repair strategy, realizing the automation and intelligence of the entire process from data collection to fault maintenance, significantly improving the diagnostic efficiency and maintenance accuracy. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] In order to more clearly illustrate the embodiments of the present application, the following is a brief introduction to the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0012] Figure 1 This is a hardware structure block diagram of a memory fault maintenance system based on a random forest model according to an embodiment of the present application;

[0013] Figure 2 This is a structural block diagram of a memory fault maintenance system based on a random forest model according to an embodiment of the present application (I);

[0014] Figure 3 This is a structural block diagram of a memory fault maintenance system based on a random forest model according to an embodiment of the present application (II);

[0015] Figure 4 This is a structural block diagram of an optional memory fault visualization maintenance system based on a random forest model according to an embodiment of the present application;

[0016] Figure 5 This is a flowchart of a memory fault maintenance method based on a random forest model according to an embodiment of the present application. DETAILED DESCRIPTION

[0017] The following will be combined with the accompanying drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are only part of the embodiments of this application, not all of them. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0018] It should be noted that, in the description of this application, the terms "comprises," "includes," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or device comprising a series of elements includes not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article, or device. The terms "first," "second," etc., in this application are used to distinguish similar objects, and are not used to describe a particular order or sequence.

[0019] In order to enable those skilled in the art to better understand the present application, the present application is further described in detail below with reference to the accompanying drawings and specific implementation methods.

[0020] In conjunction with the specific application environment architecture or specific hardware architecture on which the execution of the random forest model-based memory fault maintenance system depends, the specific application environment architecture or specific hardware architecture is described herein.

[0021] The method embodiments provided in the embodiments of the present application can be executed in a server device or a similar computing device. Taking running on a server device as an example, Figure 1 This is a hardware structure diagram of a memory fault maintenance system based on a random forest model according to an embodiment of the present application. Figure 1 As shown, the server device may include one or more ( Figure 1 Only one is shown) a processor 102 (the processor 102 may include but is not limited to a microprocessor MCU or a programmable logic device FPGA and other processing devices) and a memory 104 for storing data, wherein the above-mentioned server device may also include a transmission device 106 for communication functions and an input and output device 108. It will be understood by those skilled in the art that Figure 1 The structure shown is only for illustration and does not limit the structure of the above server device. Figure 1 More or fewer components than shown, or with Figure 1 Different configurations shown.

[0022] The memory 104 can be used to store computer programs, for example, software programs and modules of application software, such as the computer program corresponding to the startup method of the operating system in the embodiment of the present application. The processor 102 executes various functional applications and data processing by running the computer program stored in the memory 104, that is, implementing the above-mentioned method. The memory 104 may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 104 may further include a memory remotely located relative to the processor 102, and these remote memories can be connected to the server device via a network. Examples of the above-mentioned network include but are not limited to the Internet, an intranet, a local area network, a mobile communication network, and a combination thereof.

[0023] The transmission device 106 is used to receive or send data via a network. A specific example of the aforementioned network may include a wireless network provided by a communication provider of the server device. In one embodiment, the transmission device 106 includes a network interface controller (NIC), which can be connected to other network devices via a base station to enable communication with the Internet. In another embodiment, the transmission device 106 may be a radio frequency (RF) module, which is used to communicate with the Internet wirelessly.

[0024] The following is an explanation of the professional terms that appear in this application:

[0025] Memory ECC (Error-Correcting Code): Error-correcting code (ECC) is a technology used to detect and correct data errors in memory. ECC memory is widely used in critical applications (such as servers and workstations) to ensure data integrity and system stability.

[0026] A cluster is a group of independent computers connected by a high-speed network. These computers form a group and are managed as a single system. When a client interacts with the cluster, it behaves like a single server. Cluster configurations are used to improve availability and scalability.

[0027] In this embodiment, a memory fault maintenance system based on a random forest model is provided. Figure 2 This is a structural block diagram of a memory fault maintenance system based on a random forest model according to an embodiment of the present application. Figure 2 As shown, the system includes:

[0028] The multi-source data acquisition module 22 is used to collect multi-source data in the memory in real time, wherein the multi-source data includes: hardware signals, software logs and performance indicator data;

[0029] A random forest classification unit 24 is connected to the multi-source data acquisition module and includes a trained random forest model, and is used to perform fault identification on the multi-source data using the trained random forest model to obtain the fault information in the memory;

[0030] The intelligent maintenance unit 26 is configured to determine a repair strategy according to the fault information and execute the repair strategy to perform fault maintenance on the memory.

[0031] Through the above system, hardware signals, software logs and performance indicators are integrated in real time through the multi-source data acquisition module, and the maturely trained random forest classification unit is used to identify the fault type with high precision. The intelligent maintenance unit then automatically matches and executes the optimal repair strategy, realizing the automation and intelligence of the entire process from data collection to fault maintenance, significantly improving diagnostic efficiency and maintenance accuracy.

[0032] As an optional embodiment, the system further includes a dynamic visualization unit 28, such as Figure 3 As shown, the dynamic visualization unit is connected to the random forest classification unit and is used to display the fault information and / or the health information of the memory in real time.

[0033] The system integrates a dynamic visualization unit 28, such as Figure 3As shown, this unit is closely connected to the random forest classification unit and plays a key role in converting complex fault diagnosis results into intuitive visual information. The design concept of the dynamic visualization unit is to improve the speed and accuracy of operation and maintenance personnel's understanding of memory health status and enhance decision support capabilities. The specific implementation method is as follows:

[0034] 1. Real-time fault information display:

[0035] 1.1. 3D Memory Topology Display: The dynamic visualization unit uses 3D graphics technology to construct a physical layout model of the server's memory, clearly identifying the location of each DIMM slot and its corresponding bank structure. Once the random forest classification unit detects a fault, the affected memory area is highlighted in a prominent color (for example, red indicates a critical fault) within the 3D model, visually demonstrating the fault's location and severity.

[0036] 1.2. Heatmap Update: A time-series heatmap is set up within the unit to reflect the frequency and distribution of faults in real time. Using different colored heat points, operations and maintenance personnel can clearly see which time periods or memory areas frequently experience faults, allowing them to quickly identify fault trends and patterns.

[0037] 2. Visualization of health information:

[0038] 2.1 Health Dashboard: The unit provides a dynamically updated health dashboard that integrates multiple metrics, including ECC error rate, temperature fluctuation, and voltage deviation, to calculate a real-time memory health score. When the score falls below a set threshold, the dashboard issues an alert, prompting the operations team to take immediate action.

[0039] 2.2. Historical data analysis: In addition to displaying the current status, the dynamic visualization unit can also retrieve historical data for comparison, presenting health trends over a period of time, helping operations personnel identify potential signs of deterioration or cyclical problems, and providing a basis for preventive maintenance.

[0040] 3. User interaction design:

[0041] 3.1. Interactive Query: Users can interact with the 3D model by clicking or moving the mouse to obtain detailed fault information and health scores of specific memory areas, including detailed records of ECC errors and temperature change curves.

[0042] 3.2. Customized View: Based on different maintenance requirements, users can customize the indicator combination and time range to be viewed, and flexibly adjust the display content of heat maps and dashboards to focus on the most important monitoring information.

[0043] 3.3. Intelligent Decision-Making: Combined with the recommendation strategies of the intelligent maintenance unit, the dynamic visualization unit can help operation and maintenance personnel quickly understand the fault type and provide visual guidance for repair suggestions, such as operational prompts for isolating the fault area, simplifying the decision-making process and improving maintenance efficiency.

[0044] Through the above embodiments, the dynamic visualization unit 28 not only improves the speed at which operation and maintenance personnel perceive memory faults, but also enhances the depth and breadth of fault analysis, providing strong support for efficient and accurate fault maintenance strategies.

[0045] In an exemplary embodiment, the random forest classification unit is further used to: perform a preprocessing operation on the multi-source data to obtain preprocessed multi-source data, wherein the preprocessing operation includes at least one of the following: data cleaning, feature normalization; train an initial random forest model based on the preprocessed multi-source data; use the initial random forest model to evaluate the contribution of multiple features in the preprocessed multi-source data according to multiple preset indicators to obtain the contribution of the multiple features, wherein the multiple contribution degrees are respectively used to indicate the contribution of the multiple features to the fault classification, and the multiple preset indicators are related to the fault classification; the multiple features are evaluated according to the size of the multiple contribution degrees. Sorting to obtain a plurality of sorted features; selecting a target number of features with the highest ranking from the sorted plurality of features, and determining the target number of features as key features; retraining the initial random forest model according to the key features, and adjusting the model parameters of the initial random forest model according to the key features to obtain the trained random forest model, wherein the model parameters are used to indicate the classification performance of the model, and the model parameters include: the number of decision trees, and the maximum depth of the decision tree; evaluating the classification accuracy of the trained random forest model through a validation data set, and determining that the model training is completed when it is determined that the classification accuracy of the trained random forest model is greater than a preset threshold.

[0046] The random forest classification unit in this application not only takes on the task of identifying memory failures, but also deeply involves the key steps of data preprocessing, model training and optimization to ensure the classification accuracy and reliability of the model. The following is a detailed description of this embodiment:

[0047] 1. Data Preprocessing: The classification unit first performs data cleaning on the collected multi-source data, removing outliers, missing values, and irrelevant data to ensure the accuracy of subsequent analysis. For continuous features (such as temperature and voltage), feature normalization techniques are applied to convert all feature values ​​to the same scale (such as 0-1), eliminating dimensionality effects and improving model training efficiency and classification performance.

[0048] 2. Initial model training: Utilize preprocessed multi-source data as a training set, including information from multiple dimensions such as hardware signals, software logs, and performance metrics. By setting model parameters (such as the number of decision trees and maximum depth), a preliminary random forest model is trained. The goal is to learn the ability to distinguish different fault types from multi-source data.

[0049] 3. Feature Contribution Evaluation and Selection: Using the initial random forest model, combined with pre-set metrics closely related to fault classification (such as the Gini coefficient and feature importance score), we evaluate the contribution of each feature and identify which features play a key role in fault classification. Based on the calculated contribution, all features are ranked and the top-ranked key features are selected. This process helps reduce model complexity while maintaining or improving classification performance.

[0050] 4. Model parameter optimization and training completion: Based on key features, the initial model parameters (such as the number and depth of decision trees) are re-adjusted to achieve better classification results. The random forest model is retrained using the training dataset containing the key features. The model's classification accuracy is then evaluated using the validation dataset to ensure that its accuracy exceeds the preset threshold, demonstrating that the model can reliably identify various memory faults.

[0051] 5. Model evaluation and deployment: Once the model's classification accuracy reaches or exceeds the preset threshold, the model training is considered complete and can be deployed into the dynamic maintenance system for real-time fault classification.

[0052] Through this series of implementation steps, the random forest classification unit can effectively learn key patterns for fault classification from multi-source data. At the same time, through feature selection and model parameter optimization, it improves the model's classification accuracy and processing efficiency, providing solid technical support for real-time identification and maintenance of memory faults.

[0053] Furthermore, the random forest classification unit is also used to: perform outlier detection on the multi-source data, eliminate outliers detected in the multi-source data, and fill missing values ​​in the multi-source data after eliminating outliers to obtain cleaned multi-source data; determine the continuous features in the cleaned multi-source data, and normalize the continuous features to obtain normalized multi-source data; divide the normalized multi-source data into a training data set and a verification data set, and train the initial random forest model through the training data set, wherein the preprocessed multi-source data includes the training data set and the verification data set.

[0054] Before processing multi-source data, the Random Forest classifier undergoes a series of sophisticated data preprocessing steps to ensure the quality of model training and classification accuracy. The following are the specific implementation details for data cleaning, feature normalization, and dataset segmentation:

[0055] 1. Outlier Detection and Removal: The Random Forest Classifier first uses statistical methods or machine learning algorithms (such as Isolation Forest and Z-Score) to detect outliers in the collected multi-source data. Outliers are generally defined as observations that deviate significantly from the normal range. They may be caused by measurement error, equipment failure, or other abnormal conditions. Once an outlier is identified, the Classifier removes it from the original dataset to prevent it from misleading model training and ensure that the model learns typical, rather than exceptional, behavioral patterns.

[0056] 2. Missing Value Filling: For values ​​marked as missing during the preprocessing process, the random forest classification unit uses an appropriate method to fill in the missing values. Common filling strategies include mean / median filling and model-based prediction filling. In this embodiment, because the random forest model itself has a certain ability to handle missing values, missing values ​​can be filled through its built-in out-of-bag (OOB) estimation, which not only ensures data integrity but also fully utilizes the model characteristics.

[0057] 3. Normalization of Continuous Features: Identify continuous features (e.g., temperature, voltage, ECC error rate, etc.) in the cleaned data and apply normalization to these continuous features. The purpose of normalization is to convert feature values ​​of different dimensions or ranges to the same scale. A common method is linear normalization, which maps feature values ​​to a range between 0 and 1.

[0058] 4. Dataset Segmentation and Model Training: The normalized multi-source data is split into a training dataset and a validation dataset. The ratio can be adjusted based on actual needs, but generally follows the principle of using 70%-80% for training and the remainder for validation and testing. The training dataset is used to train the random forest model. The goal is to enable the model to distinguish different types of memory failures through data learning. The initial random forest model training process involves the creation of multiple decision trees, with each tree trained using a portion of the features and data. This parallel processing method helps improve the diversity and robustness of the model.

[0059] By implementing the above steps, the random forest classification unit can not only purify data at the source, removing noise and anomalies, but also standardize the data format to make it more suitable for model learning. The resulting initial random forest model has the ability to accurately identify memory faults based on multi-dimensional data, laying a solid foundation for subsequent fault classification and intelligent maintenance.

[0060] Optionally, the intelligent maintenance unit is further used to: perform priority evaluation on multiple fault types to obtain the priorities of the multiple fault types, wherein the priority of the fault type is proportional to the urgency; set repair strategies for the multiple fault types according to the priorities of the multiple fault types to obtain multiple repair strategies, wherein the multiple fault types correspond one-to-one to the multiple repair strategies.

[0061] The intelligent maintenance unit quantifies the urgency of different fault types identified by the random forest classification unit. The urgency is generally proportional to the impact of the fault on system stability and performance loss. For example, hardware damage, which may cause data loss or system crash, is ranked as the highest urgency level. Memory leaks, while not causing major problems in the short term, can affect resource utilization efficiency and are ranked as medium. Row Hammer attacks, due to their potential security threats, require immediate response and are considered the most urgent.

[0062] Based on this quantification of urgency, the intelligent maintenance unit generates a fault priority list, sorting different types of faults by their urgency. This process ensures that, given limited resources, faults with the greatest impact on system operation are prioritized.

[0063] The intelligent maintenance unit also has a pre-built policy library containing preset repair solutions for each fault type. For example, a repair strategy for hardware damage might include immediately replacing a faulty memory module or disabling the relevant memory area; a repair strategy for a memory leak might involve restarting a specific process or optimizing memory management configuration; and a strategy for responding to a Row Hammer attack might focus on data refresh and access control.

[0064] When a fault message is received, the intelligent maintenance unit quickly retrieves and matches the most appropriate repair strategy from a policy library based on a fault priority list. It then automatically executes repair actions without human intervention, such as isolating the faulty memory area through a kernel module or remotely updating the memory controller firmware via the IPMI protocol, enabling rapid response and troubleshooting.

[0065] Furthermore, the intelligent maintenance unit possesses self-learning and adaptive capabilities. Based on feedback from troubleshooting results, it continuously optimizes the mapping between fault types and repair strategies, gradually improving strategy matching accuracy and troubleshooting efficiency. For the most urgent fault types (such as Row Hammer attacks), the intelligent maintenance unit updates its repair strategies more frequently to address evolving security threats and attack methods, ensuring the system's protection capabilities remain up to date.

[0066] Through the priority evaluation and strategy setting of fault types by the intelligent maintenance unit, this application achieves a seamless connection from fault identification to fault handling, which not only speeds up the speed of fault handling, but also ensures that when resources are limited, the faults that have the most serious impact on system operation can be handled first, greatly improving the efficiency of maintenance work and the overall stability of the system.

[0067] Furthermore, the intelligent maintenance unit is also used to: upon receiving the fault information, determine the multiple faults contained in the fault information; determine the repair order of the multiple faults according to the priorities of the multiple fault types, and determine the multiple target repair strategies corresponding to the multiple faults; and execute the multiple target repair strategies in sequence according to the repair order.

[0068] When the intelligent maintenance unit receives fault information output by the random forest classification module, it first parses the information to identify the various fault types contained therein. This task relies on the output of the random forest model: the different fault types and their confidence levels obtained after classifying multi-source data. The intelligent maintenance unit further extracts detailed information about the fault, including the specific location of the fault (such as the DIMM slot number and bank identifier), the severity of the fault (such as the specific values ​​of error rate, temperature, and voltage fluctuation), and the software process or operational behavior related to the fault.

[0069] The intelligent maintenance unit dynamically assesses and prioritizes each fault type based on its urgency and impact on overall system performance. This evaluation mechanism ensures that the most urgent and severe faults receive priority treatment. For each identified fault type, the intelligent maintenance unit searches and matches the corresponding remediation strategy based on a pre-defined strategy library. This strategy may include hardware replacement, software optimization, system configuration adjustments, or safety measures, depending on the nature of the fault and the circumstances.

[0070] Based on the matching results of fault priorities and repair strategies, the intelligent maintenance unit generates a comprehensive repair plan, clearly defining the order in which faults must be repaired, making repair operations both efficient and orderly. High-priority faults are handled first, while lower-priority faults are repaired sequentially as resources allow.

[0071] The intelligent maintenance unit automatically executes repair strategies according to a predetermined repair sequence, without requiring human intervention. For example, in the event of hardware damage, it immediately generates a hardware replacement work order and locates the faulty area. In the event of a memory leak, it may restart related processes or adjust the memory allocation strategy. While executing the repair strategy, the intelligent maintenance unit continuously monitors changes in the fault status to ensure the effectiveness of the repair operation. Once the repair is complete, the system automatically evaluates the repair results, updates the fault record, and reports it to the operation and maintenance personnel, completing the closed-loop maintenance process.

[0072] Through this embodiment, the intelligent maintenance unit demonstrated its powerful capabilities in fault information analysis, repair strategy optimization and automated execution, providing an efficient and intelligent solution for memory failures in scenarios such as data centers, industrial control equipment and cloud computing platforms, significantly improving maintenance efficiency and system availability.

[0073] Optionally, the dynamic visualization unit is integrated with an interactive function, which is used for the target object to interact with the memory fault maintenance system. The dynamic visualization unit is also used to: receive a visualization parameter setting request sent by the target object based on the interactive function, wherein the visualization parameter setting request carries visualization parameters, and the visualization parameters include at least one of the following: the display form of the fault information and / or the health information, and the display time window; respond to the visualization parameter setting request, and update the parameter settings of the dynamic visualization unit according to the visualization parameters.

[0074] In the memory fault maintenance system of this application, the dynamic visualization unit not only provides real-time display of fault and health information, but also integrates interactive functions, allowing the target object (usually operation and maintenance personnel or system administrators) to customize the view according to their needs and enhance their understanding of the system status. The following is a detailed description of this embodiment:

[0075] The dynamic visualization unit is designed with a user-friendly and highly customizable user interface, allowing the target object to send visualization parameter setting requests through this interface. These requests can be modified in real time or pre-set to adapt to different monitoring and analysis needs. The request contains specific visualization parameters, such as the display format of fault information and health information (3D topology map, heat map, dashboard, etc.), the display time window (such as the last 1 hour, 24 hours, or a custom time period), and other factors that may affect the view presentation, such as color coding, chart style, etc.

[0076] When the dynamic visualization unit receives a request to set visualization parameters, it immediately parses the parameters in the request and adjusts its display settings to meet the new requirements. For example, if the request sets a time window for displaying fault frequency within the last 24 hours, the dynamic visualization unit will update the heat map to reflect the distribution of faults within this time period. After the parameter update is completed, the dynamic visualization unit will provide real-time feedback to the target object, displaying the updated view. This immediate response mechanism ensures that operations and maintenance personnel can quickly obtain the required fault analysis perspective, improving the efficiency of troubleshooting.

[0077] To facilitate subsequent use, the dynamic visualization unit also supports saving user parameter settings to form personalized view templates. This means that maintenance personnel can quickly switch to the preset display mode at different times or during different maintenance phases without having to re-set the settings.

[0078] When maintenance personnel need to locate a specific fault, they can use interactive functions to zoom in on the details of the fault area, such as displaying the temperature change curve of each DIMM slot in the area and the ECC error rate trend, so as to more accurately determine the cause of the fault.

[0079] Interactions also allow users to export the data in their current view or share it with other team members. This is crucial for team collaboration and remote technical support, ensuring everyone has a unified and comprehensive understanding of the system status.

[0080] Through the interactive functions and parameter setting update mechanism of the dynamic visualization unit, this application provides a highly flexible and responsive tool for monitoring and maintaining memory faults, effectively supporting the work of operation and maintenance personnel, making fault diagnosis not only more intuitive, but also more accurate and efficient.

[0081] In an exemplary embodiment, the present application proposes an optional memory fault visualization maintenance system based on a random forest model, the system structure is as follows: Figure 4 As shown, it includes the following core modules:

[0082] 1. Multi-source data acquisition module: real-time acquisition of hardware signals (ECC errors, temperature, voltage) and software logs (process memory usage, performance counters).

[0083] 2. Random forest classification module: Builds a classification model based on the training data set and outputs the probability of fault type.

[0084] Among them, the implementation of the random forest classification module is specifically as follows:

[0085] 2.1. Data collection. Data sources include hardware layer data and software layer data. Hardware layer data includes ECC error rate (single-bit / multi-bit error count), DIMM slot temperature (accuracy ±1°C), and memory supply voltage fluctuation (threshold ±5%). Software layer data includes process memory usage (obtained in real time through / proc / meminfo), operating system logs (error details recorded by the EDAC module), performance counters (memory access frequency statistics, bank activation interval), etc.

[0086] 2.2. Feature Construction. We selected 10 key features (i.e., the key features mentioned above), covering hardware, software, and performance dimensions, as shown in Table 1:

[0087] Table 1

[0088]

[0089] 2.3 Data preprocessing: This includes normalization, missing value processing, and class balancing. Missing values ​​can be filled using the out-of-bag (OOB) error estimate provided by random forests. Class balancing involves performing SMOTE oversampling on minority class samples (such as Row Hammer attacks).

[0090] 2.4 Model training and optimization:

[0091] (1) Model parameter settings are shown in Table 2:

[0092] Table 2

[0093] Parameter name Value illustrate Number of decision trees 100 Balancing accuracy and computational efficiency Maximum tree depth 10 Preventing overfitting Feature subset size √n n = total number of features (10), each tree uses 3-4 features Splitting criteria Gini coefficient Minimize impurities

[0094] (2) Training process:

[0095] A. Dataset division: training set (70%), validation set (15%), and test set (15%).

[0096] B. Cross-validation: Use 5-fold cross-validation to optimize hyperparameters (such as the number of trees and depth).

[0097] C. Feature importance assessment: Calculate feature weights based on the Gini impurity decrease (e.g., ECC error rate weight accounts for 40%).

[0098] 2.5 Online Reasoning and Real-time Classification

[0099] A. Reasoning process:

[0100] a. Collect multi-source data in real time and generate feature vectors (dimension = 10).

[0101] b. Input the random forest model, and each decision tree votes independently.

[0102] c. Aggregate the results and output the probability distribution of fault types (e.g., hardware damage probability 85%, memory leak probability 12%).

[0103] B. Performance optimization:

[0104] a. Parallel computing: Using multi-threading to traverse multiple decision trees simultaneously, reducing inference time to <10ms.

[0105] b. Model lightweighting: Prune low-importance features (such as voltage deviation weight <5%) to reduce computational overhead.

[0106] 2.6 Model Update and Incremental Learning

[0107] A. Regular update: inject new fault samples every week and retrain the model.

[0108] B. Incremental learning: retain the historical decision tree structure and only generate subtrees for new data to avoid global retraining.

[0109] 3. Dynamic visualization module: Displays fault information through 3D memory topology maps, heat maps, and health dashboards.

[0110] 4. Intelligent maintenance module: Combines knowledge graphs to recommend repair strategies, supporting one-click isolation and automated operations.

[0111] 4.1. Construct a knowledge graph. The constructed knowledge graph is shown in Table 3:

[0112] Table 3

[0113] Fault type Repair strategy Priority Hardware damage Replace the memory module high Memory leaks Restart the process or forcefully release memory middle Row Hammer Attack Refresh adjacent row data and prohibit process access urgent

[0114] 4.2. Automated operation:

[0115] A. One-click isolation: prohibit allocation of faulty memory pages through kernel modules (such as Linux Kernel Module).

[0116] B. Firmware upgrade: Remotely update the memory controller microcode based on the IPMI protocol.

[0117] Obviously, the embodiments described above are only part of the embodiments of the present application, rather than all the embodiments. In order to better understand the above method, the above process is described below in conjunction with the embodiments, but it is not intended to limit the technical solutions of the embodiments of the present application. Specifically:

[0118] Example 1: Hardware damage diagnosis and repair:

[0119] 1. Data collection: DIMM slot B2 temperature rises to 75°C (normal ≤ 60°C), ECC error rate exceeds the threshold for 3 consecutive hours (>10 -4 ).

[0120] 2. Model inference: Random forest output: 92% probability of hardware damage and 5% probability of memory leak.

[0121] 3. Visual interaction: In the 3D topology diagram, slot B2 is marked in red, and its health score drops to 40.

[0122] 4. Maintenance decision: The system automatically generates a work order: "Replace the B2 memory module immediately" and locks the fault area.

[0123] Example 2: Real-time processing of memory leaks:

[0124] 1. Data collection: The memory usage of process X continues to increase from 60% to 95%, with no release trend.

[0125] 2. Model reasoning: After the feature vector is input, it is determined to be a memory leak (confidence level 88%).

[0126] 3. Visual interaction: The process X area in the heat map displays an orange diffusion animation, and the health score drops to 55 points.

[0127] 4. Maintenance decision: The user drags the process to the isolation area, and the system forcibly releases memory and generates a log.

[0128] Example 3: Row Hammer attack defense:

[0129] 1. Data collection: The performance counter detects an abnormal access frequency of a certain memory row (1.5×10 6 times / second).

[0130] 2. Model reasoning: Combining temperature and access frequency, it is determined to be a Row Hammer attack (confidence level 96%).

[0131] 3. Visual interaction: The corresponding Bank area flashes an alarm in the 3D model, and the attack source process ID (PID: 7890) is displayed.

[0132] 4. Maintenance decision: The system automatically refreshes the adjacent row data and prohibits memory access rights for PID 7890.

[0133] Through the description of the above implementation methods, those skilled in the art can clearly understand that the method according to the above embodiment can be implemented by means of software plus the necessary general hardware platform, and of course it can also be implemented by hardware, but in many cases the former is a better implementation method.

[0134] The embodiment of the present application also provides a memory fault maintenance method based on a random forest model. Figure 5 is a flowchart of a memory fault maintenance method based on a random forest model according to an embodiment of the present application, such as Figure 5 As shown, the method includes the following steps:

[0135] Step S502, collecting the multi-source data in the memory in real time through the multi-source data acquisition module;

[0136] Step S504, performing fault identification on the multi-source data using the trained random forest model to obtain the fault information;

[0137] Step S506: determining the repair strategy according to the fault information, and executing the repair strategy to perform fault maintenance on the memory.

[0138] Through the above method, hardware signals, software logs and performance indicators are integrated in real time through the multi-source data acquisition module, and the maturely trained random forest classification unit is used to identify the fault type with high precision. The intelligent maintenance unit then automatically matches and executes the optimal repair strategy, realizing the automation and intelligence of the entire process from data collection to fault maintenance, significantly improving diagnostic efficiency and maintenance accuracy.

[0139] For the description of the features in the embodiment corresponding to the memory fault maintenance method based on the random forest model, please refer to the relevant description of the embodiment corresponding to the memory fault maintenance system based on the random forest model, which will not be repeated here.

[0140] An embodiment of the present application also provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute the steps in any of the above-mentioned memory fault maintenance method embodiments based on the random forest model.

[0141] An embodiment of the present application further provides a computer-readable storage medium storing a computer program, wherein the computer program is configured to execute the steps of any of the above-mentioned memory fault maintenance method embodiments based on a random forest model when running.

[0142] In an exemplary embodiment, the computer-readable storage medium may include, but is not limited to, various media that can store computer programs, such as a USB flash drive, a read-only memory (ROM), a random access memory (RAM), a mobile hard disk, a magnetic disk, or an optical disk.

[0143] An embodiment of the present application further provides a computer program product, which includes a computer program. When the computer program is executed by a processor, the steps in any of the above-mentioned embodiments of the memory fault maintenance system based on the random forest model are implemented.

[0144] An embodiment of the present application also provides another computer program product, including a non-volatile computer-readable storage medium, which stores a computer program. When the computer program is executed by a processor, it implements the steps in any of the above-mentioned memory fault maintenance method embodiments based on the random forest model.

[0145] Professionals may further appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of the two. In order to clearly illustrate the interchangeability of hardware and software, the above description has generally described the components and steps of each example according to their functions. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professionals and technicians may use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0146] The above is a detailed introduction to the memory fault maintenance system and method based on the random forest model, electronic device, storage medium, and computer program product provided by the present application. Specific examples are used herein to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method of the present application and its core idea. It should be pointed out that for ordinary technicians in this technical field, without departing from the principles of the present application, several improvements and modifications can be made to the present application, and these improvements and modifications also fall within the scope of protection of the claims of the present application.

Claims

1. A memory fault maintenance system based on a random forest model, characterized in that: include: A multi-source data acquisition module is used to collect multi-source data in the memory in real time, wherein the multi-source data includes: hardware signals, software logs and performance indicator data; a random forest classification unit, connected to the multi-source data acquisition module, comprising a trained random forest model, and configured to perform fault identification on the multi-source data using the trained random forest model to obtain the fault information stored in the memory; An intelligent maintenance unit is used to determine a repair strategy according to the fault information and execute the repair strategy to perform fault maintenance on the memory.

2. The memory fault maintenance system based on the random forest model according to claim 1, characterized in that: The system further comprises: A dynamic visualization unit is connected to the random forest classification unit and is used to display the fault information and / or the health information of the memory in real time.

3. The memory fault maintenance system based on random forest model according to claim 1, characterized in that: The random forest classification unit is also used to: Performing a preprocessing operation on the multi-source data to obtain preprocessed multi-source data, wherein the preprocessing operation includes at least one of the following: data cleaning, feature normalization; Training an initial random forest model based on the preprocessed multi-source data; Using the initial random forest model, evaluating the contribution of multiple features in the preprocessed multi-source data according to multiple preset indicators to obtain contribution of the multiple features, wherein the multiple contribution degrees are respectively used to indicate the contribution of the multiple features to the fault classification, and the multiple preset indicators are related to the fault classification; Sorting the plurality of features according to the magnitude of the plurality of contribution degrees to obtain a plurality of sorted features; Selecting a target number of features ranked top from the plurality of ranked features, and determining the target number of features as key features; Retraining the initial random forest model according to the key features, and adjusting model parameters of the initial random forest model according to the key features to obtain the trained random forest model, wherein the model parameters are used to indicate the classification performance of the model, and the model parameters include: the number of decision trees and the maximum depth of the decision trees; The classification accuracy of the trained random forest model is evaluated using a validation data set. When it is determined that the classification accuracy of the trained random forest model is greater than a preset threshold, the model training is determined to be complete.

4. The memory fault maintenance system based on the random forest model according to claim 3, characterized in that: The random forest classification unit is also used to: Performing outlier detection on the multi-source data, removing outliers detected in the multi-source data, and filling missing values ​​in the multi-source data after removing outliers to obtain cleaned multi-source data; Determining continuity features in the cleaned multi-source data, and normalizing the continuity features to obtain normalized multi-source data; The normalized multi-source data is divided into a training data set and a validation data set, and the initial random forest model is trained using the training data set, wherein the preprocessed multi-source data includes the training data set and the validation data set.

5. The memory fault maintenance system based on random forest model according to claim 1, characterized in that: The intelligent maintenance unit is further used for: Performing priority evaluation on multiple fault types to obtain priorities of the multiple fault types, wherein the priorities of the fault types are proportional to the urgency; Repair strategies are set for the multiple fault types according to their priorities, to obtain multiple repair strategies, wherein the multiple fault types correspond to the multiple repair strategies in a one-to-one manner.

6. The memory fault maintenance system based on random forest model according to claim 5, characterized in that: The intelligent maintenance unit is further used for: Upon receiving the fault information, determining multiple faults included in the fault information; Determining a repair order for the multiple faults according to the priorities of the multiple fault types, and determining multiple target repair strategies corresponding to the multiple faults; The multiple target repair strategies are executed sequentially according to the repair order.

7. The memory fault maintenance system based on random forest model according to claim 2, characterized in that: The dynamic visualization unit is integrated with an interactive function, wherein the interactive function is used for a target object to interact with the memory fault maintenance system. The dynamic visualization unit is further used to: Receiving a visualization parameter setting request sent by the target object based on the interactive function, wherein the visualization parameter setting request carries visualization parameters, and the visualization parameters include at least one of the following: a display form of the fault information and / or the health information, and a display time window; In response to the visualization parameter setting request, the parameter setting of the dynamic visualization unit is updated according to the visualization parameter.

8. A memory fault maintenance method based on a random forest model, characterized in that: The memory fault maintenance system based on the random forest model as claimed in any one of claims 1 to 7 comprises: Collect the multi-source data in the memory in real time through the multi-source data acquisition module; Performing fault identification on the multi-source data using the trained random forest model to obtain the fault information; The repair strategy is determined according to the fault information, and the repair strategy is executed to perform fault maintenance on the memory.

9. An electronic device, characterized in that: include: memory for storing computer programs; A processor is configured to implement the steps of the memory fault maintenance method based on the random forest model as claimed in claim 8 when executing the computer program.

10. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a computer program, wherein when the computer program is executed by the processor, the steps of the memory fault maintenance method based on the random forest model as claimed in claim 8 are implemented.

Images