Fault prediction model training method, fault prediction method, device, storage medium and computer program product

Abstract

This application provides a fault prediction model training method, fault prediction method, device, storage medium, and computer program product. The method includes: converting text data samples corresponding to one or more second devices into text semantic vectors through a first model; constructing triple samples based on the text semantic vectors through the first model, and querying a second model based on the triple samples, wherein the second model is deployed on other devices besides the first device; receiving the text semantic evaluation results output by the second model for the triple samples, and adjusting the model parameters of the first model based on the text semantic evaluation results to obtain a trained first model; and determining a fault prediction model based on the trained first model and a classification model obtained after training an initial classification model based on text data samples.

Description

Technical Field

[0001] This application relates to the field of fault prediction technology, and in particular to a fault prediction model training method, fault prediction method, device, storage medium and computer program product. Background Technology

[0002] In the context of the rapid development of artificial intelligence technology, traditional server monitoring and fault prediction methods are gradually revealing their limitations. Some methods in these technologies often rely on professionals to deploy monitoring services, preprocess data, and adjust parameters, resulting in cumbersome and inefficient processes. Furthermore, these methods depend too heavily on experience in predictive accuracy and fault identification, such as weighting various indicators and setting thresholds. These methods not only lack intelligence in their implementation but also have low accuracy in fault prediction. Summary of the Invention

[0003] In view of this, this application aims to provide a fault prediction model training method, fault prediction method, device, storage medium, and computer program product, which can improve the intelligence and accuracy of fault prediction.

[0004] The technical solution of this application is implemented as follows:

[0005] In a first aspect, this application provides a fault prediction model training method, applied to a first device, wherein a first model and an initial classification model are deployed on the first device, the method comprising:

[0006] The acquired text data samples corresponding to one or more second devices are converted into text semantic vectors through the first model;

[0007] The first model constructs triplet samples based on text semantic vectors, and queries the second model based on the triplet samples, wherein the second model is deployed on other devices besides the first device;

[0008] Receive the text semantic evaluation results of the second model for the triplet samples, and adjust the model parameters of the first model based on the text semantic evaluation results to obtain the trained first model;

[0009] The fault prediction model is determined based on the first trained model and the classification model obtained after training the initial classification model based on text data samples.

[0010] Secondly, this application provides a fault prediction method applied to a first device, wherein the first device deploys a fault prediction model, the fault prediction model including a trained first model and a classification model, and the method includes:

[0011] Collect text data samples to be predicted from the second device;

[0012] The first model trained in the fault prediction model converts the text data samples to be predicted into semantic vectors of the text to be predicted, and inputs the semantic vectors of the text to be predicted into the classification model. The classification model outputs the fault prediction result for the second device. The fault prediction model is obtained according to the above fault prediction model training method.

[0013] Thirdly, this application provides a fault prediction model training device, the fault prediction model training device comprising:

[0014] The conversion unit is used to convert the acquired text data samples corresponding to one or more second devices into text semantic vectors through the first model;

[0015] The building unit is used to construct triplet samples based on text semantic vectors using the first model;

[0016] An input unit is used to query a second model based on the triplet sample, wherein the second model is deployed on a device other than the first device;

[0017] The training unit is used to receive the text semantic evaluation results output by the second model for the triplet samples, and adjust the model parameters of the first model based on the text semantic evaluation results to obtain the trained first model.

[0018] The determination unit is used to determine the fault prediction model based on the first trained model and the classification model obtained after training the initial classification model based on text data samples.

[0019] Fourthly, this application provides a fault prediction device, the fault prediction device comprising:

[0020] A collection unit is used to collect text data samples to be predicted from a second device;

[0021] The prediction unit is used to convert the text data sample to be predicted into a semantic vector of the text to be predicted through the first model trained in the fault prediction model, and input the semantic vector of the text to be predicted into the classification model, and output the fault prediction result for the second device through the classification model. The fault prediction model is obtained according to the above-mentioned fault prediction model training method.

[0022] Fifthly, this application provides a first device, the first device comprising: a processor and a memory; the processor implements the above-mentioned fault prediction model training method when executing a running program stored in the memory, or the processor implements the above-mentioned fault prediction method when executing a running program stored in the memory.

[0023] Sixthly, this application provides a storage medium storing a computer program thereon, which, when executed by a processor, implements the above-described fault prediction model training communication method, or, when executed by a processor, implements the above-described fault prediction method.

[0024] Eighthly, this application provides a computer program product, including a computer program that, when executed by a processor, implements the above-mentioned fault prediction model training, or, when executed by a processor, implements the above-mentioned fault prediction method.

[0025] This application provides a fault prediction model training method, fault prediction method, device, storage medium, and computer program product. The method includes: converting text data samples corresponding to one or more second devices into text semantic vectors through a first model; constructing triple samples based on the text semantic vectors using the first model, and querying a second model based on the triple samples, wherein the second model is deployed on other devices besides the first devices; receiving the text semantic evaluation results output by the second model for the triple samples, and adjusting the model parameters of the first model based on the text semantic evaluation results to obtain a trained first model; and determining a fault prediction model based on the trained first model and a classification model obtained after training an initial classification model based on the text data samples. Using the above implementation scheme, the acquired text data samples are transformed into vectors through the first model, and the vectors transformed by the first model are semantically evaluated by the second model. The results of the semantic evaluation by the second model are then used to optimize the first model. The entire process can complete the training of the first model without human intervention, resulting in a higher level of intelligence. Furthermore, because the trained first model outputs better text semantic vectors, it guides the classification model to achieve better classification results, thus significantly improving the accuracy of fault prediction. Attached Figure Description

[0026] Figure 1 A flowchart illustrating a fault prediction model training method provided in an embodiment of this application;

[0027] Figure 2 A flowchart illustrating a fine-tuning small model embedding layer is provided in an embodiment of this application.

[0028] Figure 3 A schematic diagram illustrating the process of training a fault prediction model using an entropy-based triplet sampling strategy, as provided in an embodiment of this application.

[0029] Figure 4 A flowchart illustrating a fault prediction method provided in an embodiment of this application;

[0030] Figure 5This is a schematic diagram of the structure of a fault prediction system provided in an embodiment of this application;

[0031] Figure 6 This is a schematic diagram of the composition structure of a fault prediction model training device provided in an embodiment of this application;

[0032] Figure 7 This is a schematic diagram of the composition structure of a fault prediction device provided in an embodiment of this application;

[0033] Figure 8 This is a schematic diagram of the composition structure of a first device provided in an embodiment of this application. Detailed Implementation

[0034] To gain a more detailed understanding of the features and technical content of the embodiments of this application, the technical solution of this application will be further described in detail below with reference to the accompanying drawings and specific embodiments. The accompanying drawings are for reference only and are not intended to limit the embodiments of this application.

[0035] Unless otherwise defined, all technical and scientific terms used in the embodiments of this application have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used in the embodiments of this application is for the purpose of describing the embodiments of this application only and is not intended to limit this application.

[0036] In the following description, references to "some embodiments" refer to a subset of all possible embodiments. It is understood that "some embodiments" may be the same or different subsets of all possible embodiments and may be combined with each other without conflict. It should also be noted that the terms "first / second / third" used in the embodiments of this application are merely for distinguishing similar objects and do not represent a specific ordering of objects. It is understood that "first / second / third" may be interchanged in a specific order or sequence where permitted, so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein.

[0037] When predicting server failures, the following methods are typically used:

[0038] Firstly, the first feature vector corresponding to the real-time log information is input into the anomaly detection model to obtain the detection result, and based on the detection result, the real-time anomaly log information is determined; based on the real-time anomaly log information, the system downtime and probability are predicted.

[0039] Secondly: Search for servers corresponding to the downtime risk cause tags in the preset downtime table. The preset downtime table records the correspondence between multiple servers and various downtime risk cause tags. Based on the search results, check the status of each server corresponding to the downtime risk cause tag. Based on the check results, determine the downtime server and send a fast recovery command to the downtime server.

[0040] Thirdly: Log in to the server's Baseboard Management Controller (BMC) system, obtain and check the fault information in the server's BMC logs; use the Zabbix tool to monitor the resource utilization of server components and issue alarms when it exceeds the preset threshold.

[0041] Fourth: Establish a remote monitoring service system, use the nginx_upstream_check_module module to monitor the service's running status in real time, periodically call the monitoring results of the nginx detection module to identify downed services, identify and confirm downed services based on monitoring thresholds, and determine whether the service needs to be restarted.

[0042] Fifth: Collect initial data from multiple electronic devices, perform feature statistics on the data based on device information and sampling time to obtain statistical data; use these statistical data and annotation results to train a model to predict whether the device will experience a memory failure leading to a crash in the future.

[0043] Sixth: Obtain the historical heartbeat interval, the upper limit of the false judgment probability, and calculate the heartbeat timeout duration of the detected node. If no heartbeat message is received from the detected node within the heartbeat timeout duration, the detected node is determined to be down.

[0044] However, with the rapid development of artificial intelligence technology, traditional server monitoring and fault prediction methods have gradually revealed their limitations. These methods primarily rely on professionals to deploy monitoring services, preprocess data, and adjust parameters, resulting in cumbersome and inefficient processes. Furthermore, these methods depend too heavily on experience in predictive accuracy and fault identification, lacking an end-to-end integrated solution. These factors limit their intelligence and accuracy.

[0045] To overcome the aforementioned limitations, this application proposes an innovative artificial intelligence model that uses neural networks to predict the likelihood of server downtime and identify solutions (such as the causes of downtime). This model leverages advanced language models to simplify cumbersome steps in traditional data preprocessing, reducing reliance on data integration (merging data from different sources into a consistent dataset) and data transformation (converting or normalizing data to a standard format, such as normalized or standardized numerical values). It also relaxes restrictions on the model's input data. Furthermore, it aims to enhance the intelligence and accuracy of downtime prediction through richer log data and a more powerful feature extractor (i.e., the first model in this application), reducing manually set evaluation metrics to minimize subjective interference.

[0046] The technological breakthroughs achieved in the embodiments of this application can be summarized as follows:

[0047] 1. Relax restrictions on the form of input data for the model: Without human intervention, the model can automatically collect and process data from multiple data sources and integrate it into text logs, reducing the reliance on professional technical personnel.

[0048] 2. Adaptive and continuous optimization: The model has the ability to learn and adapt, reducing its dependence on empirical parameters. It can continuously optimize the model's prediction accuracy based on new data, providing more accurate fault prediction and diagnosis.

[0049] 3. End-to-end solution: Provides a seamless, integrated processing flow, with high efficiency and consistency in the process from data input to fault prediction output, simplifying the entire monitoring and prediction task.

[0050] 4. Easy to integrate and operate: Designed for easy integration into relevant information technology (IT) infrastructure, users can operate it without professional knowledge, which greatly improves the practicality and accessibility of the downtime prediction model.

[0051] In summary, the model implemented in this application aims to achieve a breakthrough in the field of server monitoring and fault prediction, improving the accuracy and efficiency of prediction while reducing manual intervention, thus making fault management simpler and more efficient.

[0052] Based on the above, embodiments of this application provide a method for training a fault prediction model, such as... Figure 1 As shown, applied to a first device, on which a first model and an initial classification model are deployed, the method may include:

[0053] S101. The text data samples corresponding to one or more second devices are obtained and converted into text semantic vectors through the first model.

[0054] In the embodiments of this application, the first device may include a server (or server-side device) or other electronic devices. Specifically, the device may be selected according to the actual situation, and no specific limitation is made in the embodiments of this application.

[0055] In the embodiments of this application, the first model includes a small model, wherein the small model can specifically refer to a small model embedder model or an embedding layer model. For example, pre-trained embedding models such as Bidirectional Encoder Representations from Transformers (BERT), Generative Pre-trained Transformer 2 (GTP2), FastText, and Word2Vec are examples of such embedding models.

[0056] It should be noted that pre-trained embedding models such as BERT, GPT-2, FastText, and Word2Vec are widely used in numerous applications of Natural Language Processing (NLP). Compared to novel, ultra-large language models such as Generative Pre-trained Transformer 3 (GPT-3) and Chat Generative Pre-trained Transformer (ChatGPT), these models are not only more compact in terms of scale and computational resource consumption, but they also provide excellent performance in diverse application environments, especially in scenarios requiring rapid analysis of large amounts of text data. For the processing requirements of large amounts of log information in this application embodiment, a pre-trained small embedding model should be selected instead of an untrained, randomly initialized model to ensure optimization in efficiency and performance.

[0057] Therefore, embodiments of this application focus on exploring the potential of embedding layers in pre-trained small models, where the function of the embedding layer is to map text data to a vector representation in a high-dimensional space, effectively capturing the deep semantics of the text. This process is key to achieving large-scale text data processing, enabling full utilization of the advanced language understanding capabilities of embedding models while maintaining computational efficiency.

[0058] In the embodiments of this application, the initial classification model can refer to any classifier, wherein the classifier is cascaded with a small model for fault prediction.

[0059] In this application embodiment, the second device includes one or more managed machine nodes managed by the server, i.e., the server. The managed machine node can be any form of device, such as a virtualization device (virtual machine) and a physical device (physical machine).

[0060] In this embodiment, before converting the acquired text data samples corresponding to one or more second devices into text semantic vectors using a small model, the server needs to first acquire the text data of each managed machine node. Specifically, the acquisition of text data is implemented as follows: If one or more second devices are detected to be down, abnormal data generated during the operation of the one or more second devices is collected and converted into text data as text data samples; or, at preset intervals, operational data generated during the operation of one or more second devices is collected and converted into text data as text data samples.

[0061] In this embodiment of the application, in order to enhance the stability and response speed of IT infrastructure, an operation and maintenance platform is deployed on the first device. The operation and maintenance platform is used to comprehensively monitor and manage all managed machine nodes (i.e. servers, including virtual machines and physical machines, etc.) on the server side, and supports real-time extraction of system logs, performance indicators and resource usage data, so as to ensure a comprehensive understanding of the system status of managed machine nodes.

[0062] In this embodiment, the operation and maintenance platform employs a heartbeat mechanism monitoring strategy to ensure continuous monitoring of key performance indicators such as CPU load, memory utilization, disk I / O, and network latency of managed machine nodes. In addition, the operation and maintenance platform can utilize performance analysis tools (perf) to deeply analyze program function call stacks and their performance data, while simultaneously collecting dmesg logs.

[0063] It should be noted that the dmesg log is an important diagnostic information used in Linux systems to record kernel activity. It is stored in the kernel's circular buffer and mainly contains hardware detection during system startup, driver loading process, and kernel-level events and errors that occur during operation.

[0064] It should be noted that the data collected by the operation and maintenance platform or the data required by the fault prediction model can be customized by the user. That is, the operation and maintenance platform can collect any information that the user believes can play a key role in downtime prediction and analysis.

[0065] In this embodiment, when the operation and maintenance platform detects a server crash based on a heartbeat mechanism, it automatically triggers an emergency abnormal data collection process. The collected abnormal data may include the aforementioned key performance indicator data, in-depth analysis of the program function call stack and its performance data using the perf program, dmesg logs, etc., and the crashed server is immediately marked as "crashed". For each managed machine node (e.g., a server) collected each time, the abnormal data is written to a text file in string format using append mode to obtain text data under abnormal conditions. An index is created for each text data point, which serves as a text data sample.

[0066] Alternatively, for normally functioning servers, the operations and maintenance platform can automatically execute a process to collect operational data from managed machine nodes at preset intervals (e.g., half an hour). This means that operational data collection will be performed every half hour, recording only information within that time period. The operational data collected for each managed machine node (e.g., server) is still written to a text file in string format using append mode, resulting in text data under normal operating conditions. An index is then created for each text data point, serving as a text data sample.

[0067] It should be noted that the value of the preset time can be selected according to the actual situation, and no specific limitation is made in this embodiment.

[0068] It should be noted that runtime data may also include the key performance indicators mentioned above, data from in-depth analysis of the program's function call stack and its performance using the perf program, and dmesg logs, etc.

[0069] It should be noted that the specific abnormal data and operational data to be collected can be selected according to the actual situation, and no specific limitations are made in this application embodiment.

[0070] In this embodiment, the operation and maintenance platform is responsible for writing the collected running data and / or abnormal data of the managed machine nodes into a text file in string form with an append mode. After obtaining the text data, the text data is used as a text data sample and fed into the small model as input data through the operation and maintenance platform.

[0071] In this embodiment of the application, the operation and maintenance platform inputs the text data samples obtained by the above conversion into the small model. The small model, as an embedder model or an embedding layer model, maps the input text data samples to a vector representation in a high-dimensional space to obtain a text semantic vector (also known as an embedding vector), which is used to capture the deep semantics of the text.

[0072] S102. Construct triplet samples based on text semantic vectors using the first model, and query the second model based on the triplet samples, wherein the second model is deployed on other devices besides the first device.

[0073] In the embodiments of this application, the second model includes large models (also known as large language models (LLMs)). A large model is one whose number of parameters reaches a certain scale. Large models can demonstrate a deep understanding of language, a capability known as the "emergence" of the model. Therefore, compared with small models, large models represent a qualitative leap in semantic understanding and are an ideal choice for processing natural language tasks.

[0074] In this embodiment, after the first model maps text data samples into embedding vectors, triplet samples are constructed using the obtained embedding vectors. The smaller model is trained by asking questions of the larger model based on these triplet samples. The main reasons for choosing to train the smaller model through interaction between the smaller and larger models are as follows:

[0075] In many NLP tasks, pre-trained text representation models (i.e., embedder models) play a central role, converting text into vector form. Currently, some cutting-edge LLMs, such as the GPT series, have demonstrated exceptional language processing capabilities across multiple NLP domains. However, these models are typically only accessible through APIs; users cannot directly access the pre-trained model architecture and parameters, nor can they directly obtain the embedding vectors of the input text. This limits their application in specific tasks, such as system crash detection and recognition.

[0076] One possible solution is to input relevant information into LLMs or their APIs, and then perform a detailed analysis of the system outage based on the response messages. However, this approach presents several challenges: First, users lack control over these models, making customized task adaptation impossible. Second, because users cannot fine-tune them using their own data, they cannot benefit from the performance improvements resulting from data accumulation. Furthermore, as the number of managed machines increases, frequent and large-scale queries or calls to commercial large-scale models will lead to a rapid increase in costs, making practical implementation difficult from a cost perspective.

[0077] Due to limitations in cost, hardware, and deployment conditions, large language models typically cannot be directly accessed or used to perform other downstream tasks.

[0078] Therefore, to leverage the semantic understanding capabilities of large models at low cost, this application proposes a strategy: a triplet task is constructed using text semantic vectors derived from text data samples by a small model. For this triplet task, the large model's API is used to access the large model, guiding it to provide evaluation information about the triplet task as a key supervisory signal for adjusting the small model's neural network parameters. Specifically, the small model designs a specific problem—the final constructed triplet task—to guide the large language model in providing evaluation information about the text embedding vectors, thereby indirectly utilizing the large model's semantic processing capabilities to train the small model. This method aims to leverage LLMs to guide the performance optimization of the small model's embedding layer, enabling the small model to perform better in tasks such as crash detection and recognition.

[0079] Based on this, in the embodiments of this application, the proposed model training method utilizes a large model to optimize a small model. That is, the training strategy for the small model is to train the small model by leveraging the capabilities of the large model. The core idea is to improve the performance of the small model by utilizing the large model's response to the triplet task constructed by the small model. Here, a triplet consists of an anchor point, a positive example, and a negative example.

[0080] Therefore, in this embodiment of the application, to complete the training of the small model, the small model first needs to construct triplet samples based on the text semantic vector input by the operation and maintenance platform. One implementation method is as follows:

[0081] When there are multiple text semantic vectors, the first model is used to construct triplet samples based on the text semantic vectors. Specifically, this can be achieved as follows: the first model is used to cluster multiple text semantic vectors to obtain multiple groups of text semantic vectors; target text semantic vectors are selected from each group of text semantic vectors, and triplet samples are constructed based on the target text semantic vectors. Each target text semantic vector in the triplet sample belongs to a different group.

[0082] In this embodiment, when constructing the triplet task, firstly, the preliminary text semantic vectors of the text data samples, i.e., embedding vectors (which can be understood as sample vectors in the embedding vector space), have been obtained using a small embedding model in the aforementioned embodiments. Then, the small model clusters multiple embedding vectors using a clustering algorithm, which can yield multiple embedding vectors of different categories, i.e., divides multiple embedding vectors into multiple groups.

[0083] It should be noted that the clustering algorithm can be K-means clustering or other clustering algorithms. The specific choice should be made according to the actual situation, and no specific limitation is made in the embodiments of this application.

[0084] In this embodiment, a small model selects some highly similar embedding vectors (or instances, i.e., target text semantic vectors) from different categories to form a triplet sample t consisting of "anchor sample, candidate sample 1, and candidate sample 2". The triplet t can be expressed as the following formula (1):

[0085] (1)

[0086] Where 'a' is the anchor point. and There are two candidate samples, and t is a triplet sample (or triplet task).

[0087] It should be noted that the above selection method can be achieved by randomly selecting an embedding vector from each of the three different categories to form the triplet t.

[0088] In this embodiment, after the small model constructs the triplet sample t, the large model is accessed through the Large Language Model Application Programming Interface (LLM API). The LLM API is used to query the large model for the constructed triplet sample, such as "which sample is the anchor more similar to?". This question can be denoted as... The large model answers this question by providing feedback results for the "anchor point, positive sample, negative sample" triplet.

[0089] Among them, the evaluation method for large models can refer to the following formula (2):

[0090] (2)

[0091] Specifically, LLM is used to select samples c that are more similar to anchor point a. Using a as the anchor point and , The task t for candidate samples and the problem Together they form the triplet problem, which is addressed by the large model interface. Sure ( or One sample is a positive sample, and the other sample is a positive sample. or () is a negative sample.

[0092] It's important to note that the smaller model poses a question to the LLM based on the constructed triplet samples. This involves forming a triplet question based on the triplet samples and inputting it into the LLM. The LLM, using an abstract, high-dimensional feature perspective, judges the relative semantic similarity between candidate samples in the triplet and the anchor point. It determines which sample in the triplet is more similar to the anchor point, thus improving the semantic understanding ability of the smaller model by fine-tuning its network weights to approximate the performance of the larger model. Therefore, the triplet samples leverage the LLM's deep understanding of semantics to guide the embedder in learning text representations that better conform to natural language rules.

[0093] In this embodiment of the application, however, if the above-mentioned randomly constructed triplet samples are used and queried to LLM, the efficiency is low because a large number of triplet samples may not provide useful information, especially when the anchor, positive sample and negative sample are completely unrelated.

[0094] In one embodiment of this application, to utilize LLM more efficiently, another method for constructing triplet samples is proposed: an entropy-based triplet sampling strategy. The other method for constructing triplet samples is as follows:

[0095] When there are multiple text semantic vectors, the first model is used to construct triplet samples based on the text semantic vectors. Specifically, this can be achieved as follows: the first model is used to cluster the multiple text semantic vectors to obtain multiple sets of text semantic vectors; for each text semantic vector, the first model is used to obtain K sets of text semantic vectors that are semantically similar to each text semantic vector from the multiple sets of text semantic vectors, as well as the first value of each text semantic vector, where K is a positive integer greater than or equal to 2, and the first value represents the uncertain parameter of the category to which the text semantic vector belongs; based on the first value and the K sets of text semantic vectors, triplet samples are constructed.

[0096] In this embodiment, to select the most representative triples, the problem is modeled as finding the embedding vector with the highest uncertainty of belonging among different clusters based on entropy. The corresponding approach is to calculate the entropy value of each instance (i.e., the embedding vector) using the entropy formula. This is used to determine the uncertainty of each embedding vector in the vector space compared to other sample vectors.

[0097] In this embodiment of the application, if there are N text data samples in total, for each text data sample... Each text data sample is obtained by transformation through the embedder model f. Embedded vector representation z iThe N text data samples are used as input to the embedding model f. The embedding vector set Z of all text data samples is obtained by mapping through the embedding model f. The embedding vector set Z can be expressed as the following formula (3):

[0098] (3)

[0099] In this embodiment of the application, clustering (such as K-means) is performed based on the set of embedded vectors Z using a small model to obtain k clusters (groups) containing the embedded vectors.

[0100] It should be noted that the number of categories k can be selected according to the actual situation, and no specific limitation is made in this embodiment.

[0101] In this embodiment of the application, for each embedding vector, the nearest K (or which can be denoted as K) of each embedding vector is further determined. The entropy values ​​of the clusters and each embedding vector are as follows:

[0102] In this embodiment of the application, after clustering the embedded vector set Z to obtain k clusters, the centroid vector corresponding to each cluster is calculated. .in, The calculation is performed by simply averaging the embedding vectors within each dimension.

[0103] In this embodiment, for each embedding vector, a Student's t-distribution is used, combining the embedding vector and the centroid vector of each cluster. The softmax value of a given instance (embedding vector) can be calculated using the following formula (3):

[0104] (3)

[0105] in, For degrees of freedom, the value is 1. The identifier for each cluster is assigned a value from cluster 1 to cluster k.

[0106] In the embodiments of this application, for a certain embedding vector, the softmax value of the corresponding embedding vector to each cluster can be obtained by using the above formula.

[0107] In this embodiment of the application, the i-th embedding vector (z) is defined. i The nearest cluster of () is the one with the largest softmax value. of A cluster, here It is proportional to the total number of clusters k. The value of is determined as follows in formula (4):

[0108] (4)

[0109] in, For a fixed value, in this embodiment of the application, it is taken as 0.05, and max is a value that is taken as... The maximum value in the middle.

[0110] Based on the above method, the small model can obtain the closest embedding vector from k clusters. Clusters.

[0111] In this application embodiment, based on the most recent determined above Each cluster recalculates the softmax value (or probability) of a certain embedding vector, specifically using the following formula (5):

[0112] (5)

[0113] in, For the embedding vector i to belong to the nearest The probability of a cluster.

[0114] In this embodiment of the application, based on the recalculated probability described above The entropy value of a given embedding vector can be calculated. The specific calculation formula is as follows (6):

[0115] (6)

[0116] In the embodiments of this application, the entropy value of each embedding vector can be calculated based on the above formulas (5) and (6).

[0117] In this embodiment, based on the vector space representation transformed by the embedding model, the probability distribution of each embedding vector belonging to each category (cluster) is calculated, and the corresponding entropy is calculated accordingly. The higher the entropy value, the less clear the category affiliation of the embedding vector is.

[0118] Therefore, in this embodiment, the instances with the highest entropy values ​​are preferentially selected as anchors, as the categories of these instances are the most uncertain. Inquiring with the LLM about these difficult-to-classify instances typically yields the most valuable information. Then, for each anchor, one instance is extracted from each of the most likely categories to which the anchor belongs, forming a positive sample and a negative sample, thus creating a triplet sample. Constructing triplet samples in this way is more challenging but can more effectively leverage the role of the LLM in guiding the extraction of sample representations from the embedding layer of a small model.

[0119] Based on this implementation idea, in this embodiment, the entropy value corresponding to all embedding vectors is combined with the closest value of each embedding vector. When constructing triplet samples, the following method can be used: First, determine the text semantic vectors corresponding to the first values ​​in descending order as the first text semantic vectors in the triplet samples; from K groups of text semantic vectors similar to the text semantic vectors corresponding to the first values, arbitrarily select two groups of text semantic vectors, and then select one text semantic vector from each of the two groups to obtain the second and third text semantic vectors in the triplet samples; construct triplet samples based on the first, second, and third text semantic vectors.

[0120] In specific implementation, this application assumes that text semantic vectors with higher entropy values ​​are more valuable. Using text semantic vectors with high entropy values ​​as anchors to form triples is more informative and helps optimize the small model embedding layer. Therefore, this application chooses to sort the entropy values ​​corresponding to each text semantic vector, select the one with the highest entropy value, and prioritize using the text semantic vector with the highest entropy value as the anchor.

[0121] Furthermore, for each anchor point, two sample vectors are sampled from the two nearest clusters (if the number of nearest clusters is greater than 2, then two clusters are randomly sampled) to serve as candidate positive and negative samples, respectively.

[0122] It should be noted that the two sample vectors were taken from different clusters.

[0123] In this way, we obtain anchor points, positive samples, and negative samples, which are then used to form triplet samples.

[0124] It should be noted that the number of triplet samples required can be selected according to the actual situation, and no specific limitation is made in this embodiment.

[0125] It should be noted that after determining a triplet sample based on the maximum entropy value, the next triplet sample is determined using the same method based on the next (maximum entropy value) entropy value, until the number meets the preset number.

[0126] In this embodiment, after constructing triplet samples based on the triplet sampling strategy, a triplet question can be formed using the same method as the first implementation, and then queried to the large model to obtain the semantic evaluation result fed back by the large model. The specific query process will not be described in detail here.

[0127] Therefore, based on the foregoing embodiments, the process of constructing triplet samples using the entropy-based triplet sampling strategy in this application is summarized as follows:

[0128] Input: The log file (i.e., the text data sample in the embodiments of this application) is used as the input of this scheme. It is mapped to Z by a small model. The preset number of categories k, the required number of triples Q, and the number of reference clusters are set. ,in, The value can be referenced from formula (4).

[0129] Step 1: Cluster the embedded vector set Z to obtain k clusters.

[0130] Step 2: Calculate the average value of all points within k clusters to obtain the centroid of each cluster k. .

[0131] Step 3: Calculate the closest match for each instance according to formulas (3) to (4) above. Clusters.

[0132] Step 4: Calculate the entropy value h of each instance according to the formulas (5) to (6) above.

[0133] Step 5: Sort the entropy value h in descending order to obtain the index set Ind.

[0134] Step 8: When the set of triples { If q is less than the upper limit Q (i.e., the number of triplet samples set by the user), then proceed with the following steps 9 to 14.

[0135] Step 9: Traverse Ind. For each anchor point a in Ind, execute steps 10 to 14.

[0136] Step 10: Obtain anchor point a The nearest cluster.

[0137] Step 11: Randomly select two instances from each of these nearest clusters as positive samples. and negative samples .

[0138] Step 12: Forming triplet samples .

[0139] Step 13: If t is not in set { In, and Not equal to a If it is not equal to a, then add t to { In the set {}, the value of q is incremented; if t is in the set { In step}, the value of q remains unchanged and the process jumps to step 9 to continue the traversal.

[0140] Step 14: If the value of q is less than Q, jump back to step 8; otherwise, exit the loop.

[0141] Output: A set of Q triples {}, where q takes values ​​from 1 to Q. The goal is to output a set containing Q triplet samples.

[0142] It should be noted that the triplet sampling strategy designed in this embodiment is used to alleviate the dependence on large model interface calls.

[0143] It should be noted that additional instances can be added to the triples to create other tuples. Instead of using an entropy-based sampling strategy, all triple possibility spaces or subsets can be directly traversed. Triples can be constructed using various distance or metric methods (such as Euclidean distance, Mahalanobis distance, and cosine distance) to reduce the cost of querying large models.

[0144] S103. Receive the text semantic evaluation results output by the second model for the triplet samples, and adjust the model parameters of the first model based on the text semantic evaluation results to obtain the trained first model.

[0145] In this embodiment, the large model, for the triplet problem input by the small model, outputs an evaluation result on the semantic similarity between the candidate samples and the anchor points in the triplet. The text semantic evaluation result is then output to the small model. Based on the semantic similarity evaluation result of the triplet samples by the large model, the small model adjusts its parameters until it achieves the expected effect, thus completing the training of the small model.

[0146] In this embodiment, during the small model fine-tuning stage, the embedder model is fine-tuned using the semantic similarity prediction results of the large model for triplet samples to form a higher-quality embedding space. Referring to negative samples within the batch, for... The following optimization objective is set, as shown in the following formula (7):

[0147] (7)

[0148] in, This represents the similarity between anchor point a and candidate sample c, where j represents the index of the current candidate sample. This represents the set containing positive samples and all negative samples within the batch. It is the temperature coefficient. Represents a class.

[0149] In the embodiments of this application, in The effect is optimal when the value reaches its maximum.

[0150] In the embodiments of this application, the fine-tuned embedder can find more informative triple information, and can continue to use triple information with better information to continue fine-tuning, that is, to gradually improve performance in an iterative manner.

[0151] In summary, in this embodiment, a batch of high-quality triplet samples were obtained by querying the LLM (Limited Language Model), and these samples were used to fine-tune the embedding model to conform to the LLM's preference for text similarity judgment. The fine-tuned embedding model not only generates better text representation vectors, but can also be used to select the next batch of the most valuable triplet samples. Through this iterative process, the ability of the small model to understand natural language is continuously improved, so that the final output recognition result is more accurate.

[0152] This application exemplarily illustrates the process of fine-tuning the parameters of the small model described above. For example, suppose A, B, and C are different text segments selected based on the embedding vector representations of the small embedding model, and are "similar" data points belonging to different clusters in the embedding vector space. The small model constructs a "triple question" (e.g., "Please answer which of text segments A and B is more semantically similar to text segment C (anchor point)") to ask the large model, thereby obtaining an intuitive answer from the large model regarding the relationship between different data points (e.g., "Text segment A is semantically more similar to text segment C than text segment B"). The large model can then convert this intuitive answer into a conclusion for optimizing the parameters of the embedding neural network of the small model (e.g., "Text segment A is a positive sample of text segment C, and text segment B is a negative sample of text segment C"). In this way, after obtaining the semantic evaluation results output by the large model, the small model optimizes its model parameters, with the goal of making the vector representation of text segment C closer to text segment A and further away from text segment B.

[0153] It should be noted that the method of identifying downtime status through log information (i.e., input text data samples) proposed in this application aims to fine-tune the small model embedding layer based on the large model interface, thereby giving the small model a deep semantic understanding capability for downtime-related log information through the large model.

[0154] It should be noted that the embodiments of this application aim to improve the accuracy of downtime prediction and the efficiency of solution identification by combining the fast processing capabilities of a small model with the deep semantic understanding of a large model. In practical applications, the small model of this method can be replaced with other small models or other large models. Methods for converting text into machine-understandable vector representations include not only language models, but also common neural network-based machine learning models such as convolutional neural networks and long short-term memory. The choice of model depends on the specific task, data scale, and computing resources.

[0155] S104. Based on the first trained model and the classification model obtained after training the initial classification model based on text data samples, determine the fault prediction model.

[0156] In the embodiments of this application, the classification model may include any classifier.

[0157] In this embodiment, after the large model provides the text semantic evaluation result and the small model is fine-tuned, a simple multilayer perceptron (MLP) structure is constructed as a classifier. This classifier is cascaded with the small model embedder and trained and used for subsequent inference with the text dataset collected by the operation and maintenance platform.

[0158] In this embodiment of the application, after extracting the embedding vectors of the existing dataset and fine-tuning the embedder model, the classifier is trained. The training process of the classifier is as follows: set corresponding label information for the text data samples, wherein the label information represents the fault-related information corresponding to the text data samples; input the text semantic vectors and label information corresponding to the text data samples into the initial classification model, train the initial classification model to obtain the classification model, wherein the classification model is used to output the fault prediction result of the second device.

[0159] In this embodiment, to improve the efficiency of handling downtime events, after obtaining the text data samples, the "downtime" samples need to be manually labeled, and detailed solutions (such as possible reasons for the downtime) need to be recorded. These reasons are then broken down into actionable factors. If there are three reasons, each reason can be considered a factor. These factors are used as labels, with n+1 dimensions. The first n dimensions represent whether the fault cause contains a certain factor, and the last dimension represents the "downtime" or "not downtime" identifier.

[0160] In this embodiment, the above method yields n+1 dimensional label information for each text data sample. The text data samples and their corresponding label information form a long-term updated crash database, used to train a multi-label classification model. Thus, the prediction of crash incidents is transformed into a classification problem.

[0161] It should be noted that this method not only helps server maintenance personnel quickly identify downtime status, but also provides server managers with targeted and rapid-response downtime solutions.

[0162] In this embodiment of the application, since the text data samples are converted into text semantic vectors through the small model during training, after the text data samples are labeled, the text semantic vectors corresponding to the text data samples and the label information added to the text data samples are simultaneously input into the initial classification model for iterative training. The training is completed when the loss function value no longer decreases, and the final classification model is obtained.

[0163] It should be noted that the samples input into the initial classification model for training include both abnormal and normal samples, each with its own corresponding label information.

[0164] It should be noted that the loss function can be selected according to the actual situation, and no specific limitation is made in this embodiment.

[0165] It is understood that the fault prediction model training method provided in this application embodiment transforms the acquired text data samples into vectors through a first model, and then performs semantic evaluation on the vectors transformed by the first model through a second model. The first model is then optimized using the semantic evaluation results of the second model. The entire process can complete the training of the first model without human intervention, resulting in a higher level of intelligence. Furthermore, since the trained first model has the ability to output better text semantic vectors, it can guide the classification model to achieve better classification results. Therefore, it can significantly improve the accuracy of fault prediction.

[0166] Based on the above embodiments, this application also provides a flowchart for fine-tuning the small model embedding layer, such as... Figure 2 As shown. By feeding log files (i.e., text data samples) into a small model, the small model transforms the text data samples into a vector representation embedded in a vector space, such as... Figure 2 The system identifies the categories of triangles, ellipses, and circles in the model. Then, by querying the API of the large model, it obtains the text semantic evaluation results output by the large model. Based on these results, it fine-tunes the embedding layer of the small model until the iteration ends.

[0167] Based on the above embodiments, this application also provides a flowchart of training a fault prediction model using an entropy-based triplet sampling strategy, as shown below. Figure 3 As shown, log files (i.e., text data samples) are collected through the operation and maintenance platform and fed into a small model. The small model outputs vector representations of all text data samples in the embedding vector space, forming an embedding vector set. For the embedding vector set, an entropy-based triplet sampling strategy (i.e., steps 1 to 14 in the aforementioned embodiments) is used to construct triplet samples. Further, a triplet question is formed based on the triplet samples, and the API interface of the large model is called to query, obtaining the triplet answer (i.e., text semantic evaluation result) output by the large model. The model parameters of the small model are fine-tuned based on the triplet answer. After the small model is fine-tuned, the classifier is trained. The training method can be referred to in the aforementioned embodiments. After both the classifier and the small model are trained, the final trained fault prediction model is obtained.

[0168] Another embodiment of this application also provides a fault prediction method, such as... Figure 4 As shown, the method is applied to a first device, which deploys a fault prediction model. The fault prediction model includes a trained first model and a classification model. The method may include:

[0169] S401. Collect text data samples to be predicted from the second device.

[0170] In this embodiment of the application, the first model trained by the above implementation method can output a better text semantic vector. By combining the trained first model with the classification model, it can be used to predict faults in practical applications.

[0171] In this embodiment, during the actual fault prediction process, the server deploys a pre-trained first model and a classification model, which together constitute the fault prediction model. When performing fault prediction using this model, the input data is the text data of the managed machine nodes collected by the server.

[0172] In this embodiment, the collection of text data from managed machine nodes by the server can be achieved using an operation and maintenance platform deployed on the server. The specific process of collecting data and forming text data samples can be found in the aforementioned embodiments, and will not be repeated here.

[0173] It should be noted that the text data samples to be predicted include both normal text data samples and abnormal text data samples.

[0174] S402. Using the first model trained in the fault prediction model, the text data sample to be predicted is converted into a semantic vector of the text to be predicted, and the semantic vector of the text to be predicted is input into the classification model. The classification model outputs the fault prediction result for the second device. The fault prediction model is trained according to any of the aforementioned fault prediction model training methods.

[0175] In this embodiment, after the training phase is completed, the acquired text data to be predicted is first fed into the embedder model to be transformed into a semantic vector of the text to be predicted. The resulting semantic vector of the text to be predicted has better semantic representation. Then, the semantic vector of the text to be predicted is mapped into an n+1 dimensional vector by a classifier to obtain the inference result. Here, the first n dimensions represent the probabilities of each factor that may be included in the downtime solution, and the last 1 dimension represents the probability that a downtime will occur.

[0176] It should be noted that the training process of the fault prediction model can be found in the aforementioned embodiments, and will not be repeated here.

[0177] It is understood that the fault prediction method provided in this application embodiment transforms the acquired text data samples to be predicted into vectors through a first model. Because the trained first model has the ability to output better text semantic vectors, it guides the classification model to perform classification with better results, which can significantly improve the accuracy of fault prediction. Moreover, the whole process does not require human intervention, and the level of intelligence in fault prediction is higher.

[0178] Based on the above embodiments, the fault prediction system in this application embodiment can be represented as follows: Figure 5 The structure is shown below. An operations and maintenance platform is deployed on the server to manage and collect data from the target machines (managed machine nodes). The collected data is stored as strings and used as input data samples for a small model. This small model acts as an embedding model or embedding layer model, mapping text data samples to vector representations in a high-dimensional space, responsible for capturing the deep semantics of the text. This small model is then combined with a classifier to predict the probability of downtime and deduce the causes and solutions for downtime. Furthermore, the server has permission to call the interface of a large model to assist the small model in training and output better text semantic vectors.

[0179] In this application embodiment, by adopting the above embodiments, the final achievable effect is as follows:

[0180] After fine-tuning the small model during the fine-tuning phase, the fault prediction model in this embodiment has acquired the ability to operate independently. At this point, the large model and its interface (i.e., the LLM API) have fulfilled their functions and can be removed from the system. After training, the system can efficiently process real-time data and quickly determine the probability of failure, possible causes, and solutions. Specific results are as follows:

[0181] 1. The operations and maintenance platform automatically collects monitoring data from each server every half hour. This data is processed sequentially by a small model and a classifier to immediately generate a downtime probability assessment. By analyzing the output factor probabilities, the operations and maintenance team can quickly identify potential factors that may cause downtime. In other words, it achieves the ability to predict the probability and causes of server downtime in advance, assuming all servers are operating normally.

[0182] 2. Once the heartbeat mechanism detects a server downtime, the operations and maintenance platform immediately initiates an emergency data collection process. The collected data is rapidly input into the fault prediction model, which analyzes the data and provides solution factors for the downtime fault. These factors are based on a training database, providing targeted solutions for operations and maintenance personnel.

[0183] 3. After each prediction is completed, the prediction results are pushed to the front-end interface in real time through the operation and maintenance platform, and alarm information is displayed when necessary to ensure that the operation and maintenance team can obtain key information in a timely manner and take corresponding measures.

[0184] 4. The operation and maintenance platform supports users to manually trigger a single prediction as needed, or to perform one-click batch prediction on multiple machines, providing high flexibility and convenience.

[0185] It should be noted that this system can simultaneously perform the training process of the fault prediction model and the fault prediction process. When training the fault prediction model is not required, the large model portion can be directly removed.

[0186] In summary, the embodiments of this application represent an automated and intelligent fault prediction process that combines real-time monitoring and prediction, rapid response to downtime events, an intuitive user interface, and flexible prediction triggering methods. This not only reduces the workload of operations and maintenance personnel but also improves the response speed and processing capabilities to downtime events, providing strong protection for the stability of enterprise IT infrastructure.

[0187] Through the above embodiments, it can be seen that this application provides a method to simplify the data preprocessing process and maintain high accuracy in downtime prediction by utilizing pre-trained small and large model API interfaces (reducing human intervention and improving prediction accuracy and efficiency). The core idea of ​​this method is to obtain guidance for optimizing the performance of small models by querying large models through triplet tasks, supplemented by an entropy-based triplet sampling strategy to improve efficiency. The main innovations can be summarized as follows:

[0188] This approach transforms the problem of downtime prediction and identification into a classification problem within natural language processing. It leverages the extensive training corpus of large-scale models to reduce reliance on data integration and transformation. The main implementation process involves using pre-trained small models and API interfaces of large models for text data processing and analysis.

[0189] This paper proposes a scheme to optimize a smaller model by asking questions of the larger model through the assisted training approach of a large model interface. The main implementation process involves: the design and implementation of the triplet task, and the method of transforming the large model's answer into a method for optimizing the parameters of the small model's embedding neural network.

[0190] This paper proposes a challenging triplet construction scheme based on entropy values. The entropy of a sample is calculated to determine its importance in the sample set and to predict the value of the output answer of a large model, thus reducing time and computational costs. The main implementation process involves a triplet construction strategy based on entropy calculation, which selects the most important sample as the anchor point and samples positive and negative samples from the two closest clusters.

[0191] In this embodiment, a neural network model is used to predict the probability of server downtime and identify downtime solutions. Based on key implementation elements—a triplet task construction method and an entropy-based triplet sampling strategy—the final result is the rational utilization of large models, reduced model dependence on data integration and transformation, and real-time prediction of server downtime probability and analysis of downtime causes. Compared with related technologies, this embodiment has the following technical advantages:

[0192] This system innovatively transforms the problem of downtime prediction and identification into a classification problem within natural language processing, achieving an end-to-end automated downtime prediction model. Utilizing API interfaces for pre-trained small and large models, the system can efficiently process and analyze large amounts of text data, significantly improving the accuracy of downtime prediction and the efficiency of solution identification.

[0193] At the data level, this embodiment avoids the cumbersome and uncertainties of traditional preprocessing. Because the large model's training corpus is extensive, it can deeply understand the semantic information in the log data, thereby alleviating the reliance on data preprocessing and lowering the barrier to data use. Furthermore, by employing an entropy-based sampling strategy and triplet task construction, this embodiment fully utilizes the semantic understanding capabilities of the large model and optimizes the embedder of the small model, ensuring high-accuracy predictions even with limited data.

[0194] In terms of cost-effectiveness, the embodiments of this application adopt a similar technical approach to knowledge distillation, achieving significant performance improvements at a relatively low cost. By allowing smaller models to indirectly learn from larger models, smaller models acquire advanced semantic understanding capabilities without directly accessing the parameters of larger models. This method also considers solutions that improve the performance of smaller models while reducing their dependence on larger models, thus achieving a good balance between cost and performance.

[0195] In summary, the embodiments of this application provide an efficient, accurate, and economical outage prediction and identification solution through an end-to-end automated outage prediction model, a simplified data preprocessing process, and cost-effective knowledge distillation technology.

[0196] Secondly, because the technical solution of this application reduces unexpected downtime events and ensures business continuity through automated downtime prediction and identification, it is particularly important for enterprises that rely on high availability. It simplifies data preprocessing processes, reduces reliance on data integration and transformation, and improves the speed and efficiency of data processing. It reduces direct economic losses and indirect reputational damage caused by downtime, while automation reduces manual intervention and lowers labor costs. It also leverages the advancements in natural language processing technology to drive technological progress in the IT operations and maintenance field. Therefore, the embodiments of this application can be widely applied in the cloud computing field, providing an effective solution for current downtime operations and maintenance in the industry and compensating for the shortcomings of existing technical solutions.

[0197] Based on the above embodiments, another embodiment of this application provides a fault prediction model training device 1, such as... Figure 6 As shown, the fault prediction model training device 1 includes:

[0198] The conversion unit 10 is used to convert the text data samples corresponding to one or more second devices into text semantic vectors through the first model.

[0199] Construction unit 11 is used to construct triplet samples based on text semantic vectors using the first model.

[0200] Input unit 12 is used to query a second model based on the triplet sample, wherein the second model is deployed on a device other than the first device.

[0201] Training unit 13 is used to receive the text semantic evaluation results of the second model for the triplet samples, and adjust the model parameters of the first model based on the text semantic evaluation results to obtain the trained first model.

[0202] The determination unit 14 is used to determine the fault prediction model based on the first trained model and the classification model obtained after training the initial classification model based on text data samples.

[0203] In one embodiment, the text semantic vector data consists of multiple data points.

[0204] The fault prediction model training device 1 may also include: clustering units.

[0205] Clustering units are used to cluster multiple text semantic vectors using the first model to obtain multiple sets of text semantic vectors.

[0206] The construction unit 11 is also used to select target text semantic vectors from each group of text semantic vectors respectively, and to construct triplet samples based on the target text semantic vectors, wherein each target text semantic vector in the triplet sample belongs to a different group.

[0207] In one embodiment, the fault prediction model training device 1 may further include an acquisition unit.

[0208] The clustering unit is also used to cluster multiple text semantic vectors using the first model to obtain multiple sets of text semantic vectors.

[0209] The acquisition unit is used to, for each text semantic vector, acquire K sets of text semantic vectors that are semantically similar to each text semantic vector from multiple sets of text semantic vectors through the first model, as well as the first value of each text semantic vector, where K is a positive integer greater than or equal to 2, and the first value represents the uncertain parameter of the category to which the text semantic vector belongs.

[0210] The construction unit 11 is also used to construct triplet samples based on the first value and K sets of text semantic vectors.

[0211] In one embodiment, the determining unit 14 is further configured to determine the text semantic vectors corresponding to the first values ​​as the first text semantic vectors in the triplet samples in descending order of the first values.

[0212] The determining unit 14 is also used to arbitrarily select two sets of text semantic vectors from K sets of text semantic vectors that are similar to the text semantic vector corresponding to the first value, and select one text semantic vector from each of the two sets of text semantic vectors to obtain the second text semantic vector and the third text semantic vector in the triplet sample.

[0213] Construction unit 11 is also used to construct triplet samples based on the first text semantic vector, the second text semantic vector and the third text semantic vector.

[0214] In one embodiment, the determining unit 14 is further configured to set corresponding label information for the text data sample, wherein the label information characterizes the fault-related information corresponding to the text data sample.

[0215] Training unit 13 is also used to input the text semantic vector and label information corresponding to the text data sample into the initial classification model, train the initial classification model to obtain the classification model, wherein the classification model is used to output the fault prediction result of the second device.

[0216] In one embodiment, the acquisition unit is further configured to, upon detecting that one or more second devices have crashed, collect abnormal data generated during the operation of one or more second devices and convert the abnormal data into text data as a text data sample; or, at preset intervals, collect operating data generated during the operation of one or more second devices and convert the operating data into text data as a text data sample.

[0217] This application provides a fault prediction model training device. It converts text data samples corresponding to one or more second devices into text semantic vectors using a first model. Triple samples are constructed based on the text semantic vectors using the first model and input into a second model, which is deployed on devices other than the first devices. The device receives the text semantic evaluation results output by the second model for the triple samples and adjusts the model parameters of the first model based on these results to obtain a trained first model. A fault prediction model is determined based on the trained first model and a classification model obtained after training an initial classification model using text data samples. Therefore, this fault prediction model training device converts acquired text data samples into vectors using a first model, performs semantic evaluation on the vectors converted by the second model, and optimizes the first model using the semantic evaluation results of the second model. The entire process can be completed without human intervention, demonstrating a higher level of intelligence. Furthermore, because the trained first model outputs better text semantic vectors, it guides the classification model to achieve better classification results, thus significantly improving the accuracy of fault prediction.

[0218] Based on the above embodiments, another embodiment of this application provides a fault prediction device 2, such as... Figure 7 As shown, the fault prediction device 2 includes:

[0219] Collection unit 20 is used to collect text data samples to be predicted from the second device.

[0220] The prediction unit 21 is used to convert the text data sample to be predicted into a semantic vector of the text to be predicted through the first model trained in the fault prediction model, and input the semantic vector of the text to be predicted into the classification model, and output the fault prediction result for the second device through the classification model. The fault prediction model is obtained according to the above-mentioned fault prediction model training method.

[0221] This application provides a fault prediction device that acquires text data samples to be predicted from a second device; converts the text data samples into text semantic vectors through a first model trained in a fault prediction model, and inputs the text semantic vectors into a classification model, which then outputs a fault prediction result for the second device. The fault prediction model is trained using a fault prediction model training method. Therefore, the fault prediction device proposed in this application converts the acquired text data samples into vectors through a first model. Because the trained first model outputs better text semantic vectors, it guides the classification model to achieve better classification results, significantly improving the accuracy of fault prediction. Furthermore, the entire process requires no manual intervention, resulting in a higher level of intelligence in fault prediction.

[0222] Figure 8 This is a schematic diagram of the composition structure of a first device 3 provided in an embodiment of this application. In practical applications, based on the same disclosed concept of the above embodiments, such as... Figure 8 As shown, the first device 3 in this embodiment includes a processor 30, a memory 31, and a communication bus 32.

[0223] In specific embodiments, the aforementioned conversion unit 10, construction unit 11, input unit 12, training unit 13, determination unit 14, clustering unit, acquisition unit, collection unit 20, and prediction unit 21 can be implemented by a processor 30 located on the first device 3. The processor 30 can be at least one of the following: Application Specific Integrated Circuit (ASIC), Digital Signal Processor (DSP), Digital Signal Processing Device (DSPD), Programmable Logic Device (PLD), Field Programmable Gate Array (FPGA), CPU, controller, microcontroller, and microprocessor. It is understood that for different devices, the electronic devices used to implement the above processor functions can also be other types; this application does not impose specific limitations.

[0224] In this embodiment, when the first device 3 is used for fault prediction model training, the communication bus 32 is used to realize the connection communication between the processor 30 and the memory 31; when the processor 30 executes the running program stored in the memory 31, it implements the following fault prediction model training method:

[0225] The acquired text data samples corresponding to one or more second devices are converted into text semantic vectors by the first model; triple samples are constructed based on the text semantic vectors by the first model, and the second model is queried based on the triple samples, wherein the second model is deployed on other devices besides the first device; the text semantic evaluation results output by the second model for the triple samples are received, and the model parameters of the first model are adjusted based on the text semantic evaluation results to obtain the trained first model; the fault prediction model is determined based on the trained first model and the classification model obtained after training the initial classification model based on the text data samples.

[0226] In one embodiment, the text semantic vector data consists of multiple data points.

[0227] The processor 30 is further configured to cluster multiple text semantic vectors using a first model to obtain multiple sets of text semantic vectors; select target text semantic vectors from each set of text semantic vectors respectively, and construct triplet samples based on the target text semantic vectors, wherein each target text semantic vector in the triplet sample belongs to a different group.

[0228] In one embodiment, the processor 30 is further configured to cluster multiple text semantic vectors using a first model to obtain multiple sets of text semantic vectors; for each text semantic vector, the processor uses the first model to obtain K sets of text semantic vectors that are semantically similar to each text semantic vector from the multiple sets of text semantic vectors, as well as a first value for each text semantic vector, where K is a positive integer greater than or equal to 2, and the first value represents an uncertain parameter representing the category to which the text semantic vector belongs; and constructs triplet samples based on the first value and the K sets of text semantic vectors.

[0229] In one embodiment, the processor 30 is further configured to: sequentially determine the text semantic vectors corresponding to the first values ​​as the first text semantic vectors in the triplet sample according to the order of the first values ​​from largest to smallest; arbitrarily select two sets of text semantic vectors from K sets of text semantic vectors similar to the text semantic vectors corresponding to the first values, and select one text semantic vector from each of the two sets of text semantic vectors to obtain the second and third text semantic vectors in the triplet sample; and construct the triplet sample based on the first, second, and third text semantic vectors.

[0230] In one embodiment, the processor 30 is further configured to set corresponding label information for the text data sample, wherein the label information represents the fault-related information corresponding to the text data sample; input the text semantic vector corresponding to the text data sample and the label information into the initial classification model, train the initial classification model to obtain a classification model, wherein the classification model is used to output the fault prediction result of the second device.

[0231] In one embodiment, the processor 30 is further configured to, upon detecting that one or more second devices have crashed, collect abnormal data generated during the operation of one or more second devices and convert the abnormal data into text data as a text data sample; or, at preset intervals, collect operating data generated during the operation of one or more second devices and convert the operating data into text data as a text data sample.

[0232] In this embodiment of the application, when the first device 3 is used for fault prediction, the communication bus 32 is used to realize the connection communication between the processor 30 and the memory 31; when the processor 30 executes the running program stored in the memory 31, it implements the following fault prediction method:

[0233] Collect text data samples to be predicted for the second device; convert the text data samples to be predicted into semantic vectors of text to be predicted using the first model trained in the fault prediction model, and input the semantic vectors of text to be predicted into the classification model, and output the fault prediction result for the second device through the classification model. The fault prediction model is obtained according to the above fault prediction model training method.

[0234] Based on the above embodiments, this application provides a storage medium storing a computer program thereon. The computer-readable storage medium stores one or more programs, which can be executed by one or more processors and applied in a first device. The computer program implements the fault prediction model training method / fault prediction method as described above.

[0235] Based on the above embodiments, this application provides a computer program product, including a computer program that can be executed by one or more processors and applied in a first device. The computer program implements the fault prediction model training method / fault prediction method as described above.

[0236] It should be noted that, in the embodiments of this application, 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 a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.

[0237] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solutions of the embodiments of this application, or the parts that contribute to the related technology, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause an image display device (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of the embodiments of this application.

[0238] The above description is merely a specific implementation of the embodiments of this application, but the protection scope of this application is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in this application should be included within the protection scope of this application.

Claims

1. A method for training a fault prediction model, characterized in that, Applied to a first device, on which a first model and an initial classification model are deployed, the method includes: The acquired text data samples corresponding to one or more second devices are converted into text semantic vectors through the first model; The first model constructs triplet samples based on the text semantic vector, and queries the second model based on the triplet samples, wherein the second model is deployed on other devices besides the first device; Receive the text semantic evaluation result output by the second model for the triplet sample, and adjust the model parameters of the first model based on the text semantic evaluation result to obtain the trained first model; The first trained model is concatenated with the classification model obtained after training the initial classification model based on the text data samples to determine the fault prediction model.

2. The method of claim 1, wherein, The text semantic vector data consists of multiple data points. The step of constructing triplet samples based on the text semantic vectors using the first model includes: The first model is used to cluster multiple text semantic vectors to obtain multiple sets of text semantic vectors. Select target text semantic vectors from each group of text semantic vectors, and construct triplet samples based on the target text semantic vectors, wherein each target text semantic vector in the triplet sample belongs to a different group.

3. The method of claim 1, wherein, The text semantic vector data consists of multiple data points. The step of constructing triplet samples based on the text semantic vectors using the first model includes: The first model is used to cluster multiple text semantic vectors to obtain multiple sets of text semantic vectors. For each text semantic vector, the first model obtains K sets of text semantic vectors that are semantically similar to each text semantic vector from the multiple sets of text semantic vectors, as well as a first value for each text semantic vector, where K is a positive integer greater than or equal to 2, and the first value represents an uncertain parameter of the category to which the text semantic vector belongs; Based on the first value and the K sets of text semantic vectors, the triplet sample is constructed.

4. The method of claim 3, wherein, The construction of the triplet sample based on the first value and K sets of text semantic vectors includes: According to the order of the first value from largest to smallest, the text semantic vectors corresponding to the first value are determined as the first text semantic vectors in the triplet samples; From the K groups of text semantic vectors that are similar to the text semantic vector corresponding to the first value, arbitrarily select two groups of text semantic vectors, and select one text semantic vector from each of the two groups of text semantic vectors to obtain the second text semantic vector and the third text semantic vector in the triplet sample; The triplet sample is constructed based on the first text semantic vector, the second text semantic vector, and the third text semantic vector.

5. The method of claim 1, wherein, After adjusting the model parameters of the first model based on the text semantic evaluation result to obtain the trained first model, the method further includes: Set corresponding label information for the text data sample, wherein the label information represents the fault-related information corresponding to the text data sample; The text semantic vector and label information corresponding to the text data sample are input into the initial classification model, and the initial classification model is trained to obtain a classification model, wherein the classification model is used to output the fault prediction result of the second device.

6. The method of claim 1, wherein, Before converting the text data samples corresponding to one or more second devices into text semantic vectors through the first model, the method further includes: In the event that one or more second devices are detected to be out of service, abnormal data generated during the operation of the one or more second devices is collected and converted into text data as a text data sample. Alternatively, at preset intervals, operational data generated during the operation of the one or more second devices can be collected and converted into text data as text data samples.

7. A failure prediction method characterized by, The method is applied to a first device, wherein the first device deploys a fault prediction model, the fault prediction model comprising a trained first model and a classification model, the trained first model being cascaded with the classification model, the method comprising: Collect text data samples to be predicted from the second device; The first model trained in the fault prediction model converts the text data sample to be predicted into a text semantic vector to be predicted, and inputs the text semantic vector to be predicted into the classification model. The classification model outputs a fault prediction result for the second device, wherein the fault prediction model is obtained by the method according to any one of claims 1 to 6.

8. A first device, comprising: The first device includes a processor and a memory; the processor executes a running program stored in the memory to implement the method as described in any one of claims 1 to 6, or the processor executes a running program stored in the memory to implement the method as described in claim 7.

9. A storage medium having stored thereon a computer program, characterized in that When the computer program is executed by a processor, it implements the method as described in any one of claims 1 to 6, or when the computer program is executed by a processor, it implements the method as described in claim 7.

10. A computer program product, comprising a computer program, characterized in that, The computer program, when executed by a processor, implements the method as described in any one of claims 1 to 6, or the computer program, when executed by a processor, implements the method as described in claim 7.

Images