Intelligent cloud file storage method of power plant based on cloud computing and medium

Abstract

The invention provides an intelligent cloud file storage method for a power plant based on cloud computing and a medium, and the method comprises the steps: extracting a target text implicit representation from a to-be-analyzed operation log text, and enabling the to-be-analyzed operation log text to comprise interested contents; and performing iterative optimization on the target text implicit representation and the contrast core text item implicit representation obtained by any assignment starting based on the core text index model to obtain the target core text item implicit representation of the interested content. And then, based on the implicit representation of the target core text item, determining to obtain a text paragraph, existing in the running log text to be analyzed, of the core text item in the interested content, marking the core text item to obtain a marked running log text, and storing the marked running log text. That is to say, the core text index model is obtained by performing self-guidance learning through iteration, so that not only can the detection precision be improved, but also the detection efficiency is improved.

Description

Technical Field

[0001] The present application relates to the field of data processing, and in particular, to an intelligent cloud archive storage method and medium for a power plant based on cloud computing. Background Art

[0002] With the rapid development of information technology and industrial automation technology, the operation and maintenance management of power plants increasingly rely on large-scale data processing and analysis capabilities. As a key infrastructure for energy supply, the massive operation logs generated in the daily operation of power plants are crucial for troubleshooting, performance optimization and safety management. However, traditional log analysis methods often rely on manual reading and analysis, which is not only inefficient but also prone to errors, and it is difficult to meet the high requirements of modern power plants for real-time and accuracy. At present, although some automated log analysis tools have been developed, most of these tools are based on simple keyword matching or rule engines, which are difficult to effectively process complex and changeable operation log texts. Especially when faced with unstructured or semi-structured log data, the accuracy and efficiency of these tools are often greatly reduced. In addition, since the operation logs of power plants usually contain a large number of professional terms and complex scene descriptions, traditional statistical or shallow machine learning methods are difficult to capture the deep semantic information and contextual relationships in the logs. In order to overcome the above technical difficulties, the industry has begun to explore the use of advanced artificial intelligence technologies such as deep learning to improve log analysis methods. However, when existing deep learning models are applied to the analysis of power plant operation logs, the training phase of the model often requires a complex debugging process, resulting in insufficient efficiency. Summary of the invention

[0003] The object of the present invention is to provide a method and medium for storing intelligent cloud archives of a power plant based on cloud computing. The embodiment of the present application is implemented as follows:

[0004] In a first aspect, a method for storing intelligent cloud archives of a power plant based on cloud computing is applied to a cloud computing server, the method comprising: obtaining a power plant operation status operation log text uploaded by at least one intelligent terminal device of the target power plant to form a to-be-analyzed operation log text; extracting an implicit representation of a target text from the to-be-analyzed operation log text, wherein the to-be-analyzed operation log text includes content of interest; iteratively optimizing the target text implicit representation and the control core text item implicit representation obtained by any assignment start based on a core text index model to obtain an implicit representation of a target core text item of the content of interest, wherein the target core text item implicit representation represents an implicit representation of a core text item detected in the content of interest contained in the to-be-analyzed operation log text; wherein the core text index model is obtained by performing p rounds of iterative optimization on each operation log text template according to an initialized core text index model, and in the ath core text index model after completing the ath round of iterative optimization, the implicit representation of the bth template obtained by the bth round of iterative optimization is optimized. The a-th template implicit representation bigram is optimized to obtain the a-th template implicit representation bigram, and the weights and biases in the a-th core text index model are updated according to the implicit representation error between the b-th template implicit representation bigram and the a-th template implicit representation bigram, and the method stops when the preset stopping requirements are met, wherein 1≤a≤p, b=a-1, the a-th template implicit representation bigram includes the a-th template text implicit representation and the a-th reference template core text item implicit representation, the a-th template text implicit representation is obtained by a round of iterative optimization based on the initial template text implicit representation extracted from the running log text template, and the a-th reference template core text item implicit representation is obtained by a round of iterative optimization based on the initial reference template core text item implicit representation obtained by arbitrary assignment startup; based on the target core text item implicit representation, the text paragraph where the core text item in the content of interest exists in the running log text to be analyzed is determined, and the core text item is marked to obtain a marked running log text, and the marked running log text is stored.

[0005] In a second aspect, the present application provides an intelligent cloud archive storage device for a power plant based on cloud computing, the method comprising: a log text acquisition module, used to acquire a power plant operation status operation log text uploaded by at least one intelligent terminal device of the target power plant to form a to-be-analyzed operation log text; an implicit representation extraction module, used to extract an implicit representation of a target text from the to-be-analyzed operation log text, wherein the to-be-analyzed operation log text includes content of interest; a core feature determination module, used to iteratively optimize the target text implicit representation and the control core text item implicit representation obtained by any assignment start based on a core text index model to obtain a target core text item implicit representation of the content of interest, wherein the target core text item implicit representation represents an implicit representation of a core text item detected in the content of interest contained in the to-be-analyzed operation log text; wherein the core text index model is obtained by performing p rounds of iterative optimization on each operation log text template according to the initialized core text index model, and in the ath core text index model after completing the ath round of iterative optimization, the implicit representation of the target core text item obtained by the bth round of iterative optimization is performed. The b-th template implicit representation bigram completes iterative optimization to obtain the a-th template implicit representation bigram, and updates the weights and biases in the a-th core text index model according to the implicit representation error between the b-th template implicit representation bigram and the a-th template implicit representation bigram, and stops when the preset stopping requirements are met, wherein 1≤a≤p, b=a-1, the a-th template implicit representation bigram includes the a-th template text implicit representation and the a-th reference template core text item implicit representation, the a-th template text implicit representation is obtained by performing a round of iterative optimization based on the initial template text implicit representation extracted from the running log text template, and the a-th reference template core text item implicit representation is obtained by performing a round of iterative optimization based on the initial reference template core text item implicit representation obtained by arbitrary assignment startup; a log text storage module is used to determine the text paragraphs in the running log text to be analyzed where the core text item in the content of interest exists based on the target core text item implicit representation, mark the core text item to obtain a marked running log text, and store the marked running log text.

[0006] In a third aspect, the present application provides a cloud computing server, comprising: one or more processors; a memory; one or more computer programs; wherein the one or more computer programs are stored in the memory and configured to be executed by the one or more processors, and when the one or more computer programs are executed by the processors, the method described in the first aspect above is implemented.

[0007] In a fourth aspect, the present application provides a computer-readable storage medium having a computer program stored thereon. When the computer program runs on a processor, the processor can execute the method described in the first aspect above.

[0008] The beneficial effects of the present application include at least: the present application extracts an implicit representation of a target text from a run log text to be analyzed, includes content of interest in the run log text to be analyzed, iteratively optimizes the implicit representation of the target text and the implicit representation of a control core text item obtained by arbitrarily assigning a value based on a core text index model, and obtains an implicit representation of a target core text item of the content of interest, wherein the implicit representation of the target core text item represents an implicit representation of a core text item detected and obtained in the content of interest contained in the run log text to be analyzed, and the core text index model is obtained by performing p rounds of iterative optimization on each run log text template according to an initialized core text index model, and in the ath core text index model after completing the ath round of iterative optimization, the ath core text index model obtained by the bth round of iterative optimization is optimized. The a template implicit representation tuple is iteratively optimized to obtain the a template implicit representation tuple, and the weight and bias in the a core text index model are updated according to the implicit representation error between the b template implicit representation tuple and the a template implicit representation tuple, and the process stops when the preset stopping requirements are met, 1≤a≤p, b=a-1, the a template implicit representation tuple includes the a template text implicit representation and the a reference template core text item implicit representation, the a template text implicit representation is obtained by a round of iterative optimization based on the initial template text implicit representation extracted from the running log text template, and the a reference template core text item implicit representation is obtained by a round of iterative optimization based on the initial reference template core text item implicit representation obtained by arbitrary assignment startup. Then, based on the target core text item implicit representation, the text paragraphs where the core text item in the content of interest exists in the running log text to be analyzed are determined, and the core text item is marked to obtain the marked running log text, and the marked running log text is stored. That is to say, the present application obtains a core text index model through iterative self-guided learning to determine the process of text paragraphs where core text items in the content of interest included in the run log text to be analyzed exist in the run log text to be analyzed, which can not only improve the detection accuracy, but also improve the detection efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in describing the embodiments of the present application.

[0010] Figure 1 It is a flow chart of an intelligent cloud archive storage method for a power plant based on cloud computing provided in an embodiment of the present application.

[0011] Figure 2 It is a schematic diagram of the functional module architecture of the intelligent cloud archive storage device for a power plant based on cloud computing provided in an embodiment of the present application.

[0012] Figure 3 It is a schematic diagram of the composition of a cloud computing server provided in an embodiment of the present application. DETAILED DESCRIPTION

[0013] The following describes the embodiments of the present application in conjunction with the drawings in the embodiments of the present application. The terms used in the implementation method part of the embodiments of the present application are only used to explain the specific embodiments of the present application, and are not intended to limit the present application.

[0014] The execution subject of the intelligent cloud archive storage method for power plants based on cloud computing in the embodiment of the present application is a cloud computing server, including but not limited to a single network server, a server group composed of multiple network servers, or a cloud composed of a large number of computers or network servers in cloud computing, wherein cloud computing is a kind of distributed computing, a super virtual computer composed of a group of loosely coupled computer sets. Among them, the cloud computing server can be run alone to implement the present application, and can also be connected to the network and implement the present application through interactive operations with other cloud computing servers in the network. Among them, the network where the cloud computing server is located includes but is not limited to the Internet, wide area network, metropolitan area network, local area network, VPN network, etc.

[0015] The present application embodiment provides a cloud computing-based intelligent cloud archive storage method for a power plant, which is applied to a cloud computing server, such as Figure 1 As shown, the method includes:

[0016] Step S100: Acquire the operation log text of the power plant operation status uploaded by at least one smart terminal device of the target power plant to form the operation log text to be analyzed.

[0017] As a real-time scenario, assume that a large power group has multiple power plants distributed in different regions. In order to monitor and ensure the stable operation of these power plants, each power plant is equipped with a variety of intelligent terminal devices, such as sensors, controllers, and data loggers. These devices collect the operating status data of the power plant in real time, including but not limited to the temperature, pressure, speed, power generation, fuel consumption and other information of the generator set, and convert these data into operation log text.

[0018] Whenever smart terminal devices (such as temperature sensors, pressure gauges, etc.) complete a data sampling, they will automatically upload the collected data to the power plant's data center or cloud computing server through wired or wireless methods (such as 4G / 5G networks, Wi-Fi or dedicated industrial Ethernet). The format of data upload is usually a standard log format, which contains key information such as timestamp, device ID, parameter name, parameter value, etc. For example, a typical log record may look like this: "2023-04-0112:00:00, Turbine1_TempSensor, 500℃", indicating that at 12 noon on April 1, 2023, the temperature sensor reading of turbine 1 was 500 degrees Celsius. The cloud computing server listens to the data streams from smart terminal devices in various power plants through predefined API interfaces or message queues (such as Kafka, RabbitMQ).

[0019] When receiving new operation log text, the cloud computing server first verifies and cleans the data to ensure the integrity and accuracy of the data. For example, it checks whether the timestamp is valid and whether the parameter value is within a reasonable range.

[0020] The data after preliminary processing are integrated into a unified format to form the operation log text to be analyzed. These texts may contain operation records of multiple power plants and multiple equipment at different time points.

[0021] To facilitate subsequent processing, the cloud computing server can further organize these texts, such as grouping them by power plant, equipment type or time period.

[0022] The log text to be analyzed is securely stored in the database on the cloud computing platform to ensure data reliability and accessibility. These databases may use a distributed architecture, such as Hadoop HDFS or Amazon S3, to support large-scale data storage and efficient query. At the same time, cloud computing servers will regularly back up this data to prevent data loss or damage.

[0023] Through such a process, step S100 ensures the timely and accurate collection of power plant operation status data, providing a solid foundation for subsequent data analysis and intelligent decision-making. In subsequent steps, the cloud computing server will use this data, combined with machine learning models (such as LSTM recurrent neural networks for time series prediction, or natural language processing models such as BERT for text mining), to further explore the value of data and improve the operation and maintenance efficiency and safety of power plants.

[0024] Step S200: extracting an implicit representation of a target text from the proposed analysis operation log text, wherein the proposed analysis operation log text includes content of interest.

[0025] The operation log text to be analyzed refers to the collection of power plant operation status log texts that are prepared for in-depth analysis after preliminary screening and processing. These texts usually contain a variety of content such as the operation status, parameter changes, warning information, fault records, etc. of power plant equipment. For example, "2023-04-01 12:00, Turbine 1, RPM: 3000, Temp: 500℃, Warning: High Temperature" is a record in the operation log text to be analyzed, which records the speed, temperature and high temperature warning information of turbine 1 at a specific time point.

[0026] The implicit representation of the target text refers to converting the key information or semantic content in the text into a form that can be directly processed and understood by the computer, usually a high-dimensional vector or tensor. This representation captures the deep semantic features of the text, not just the surface text.

[0027] Interesting content refers to information in the operation log text that is of great value for power plant operation and maintenance management, fault diagnosis, performance optimization, etc. Such information includes abnormal status of equipment, parameters outside the normal range, specific warnings or error messages, etc. For example, in the above log text, "Warning: High Temperature" is one of the interesting contents, because it indicates that the turbine may have an overheating problem, which requires the attention and processing of the operation and maintenance personnel.

[0028] Specifically, the cloud computing server performs the following operations to complete step S200: First, the cloud computing server receives and processes the operation log text to be analyzed from step S100. These texts contain a variety of contents such as operation data, fault records, maintenance information, etc. of various equipment in the power plant. The data volume is huge and the format is diverse. In order to extract valuable information from these unstructured texts, the cloud computing server adopts specific NLP technology. Then, the cloud computing server uses a pre-trained word embedding model (such as Word2Vec, GloVe, or BERT's Token Embeddings) to convert each word or phrase in the text into a high-dimensional vector, which is the implicit representation of the word or phrase. This conversion enables the cloud computing server to understand the semantic relationship between words, and then capture the contextual information in the text.

[0029] For example, in a log record "2023-04-01 14:00, Turbine 3 overheated, automatically shut down", the cloud computing server will first convert each word (such as "Turbine", "overheated", "automatically", "shut down") into a corresponding word vector. Subsequently, using deep learning models such as the Attention Mechanism or Convolutional Neural Network (CNN), the cloud computing server can identify the key phrase "Turbine 3 overheated" because it is closely related to the equipment operation status of the power plant and is the content of interest. In order to more accurately represent this key information, the cloud computing server can further use a recurrent neural network (RNN) or its variants (such as LSTM, GRU) to process the entire sentence or paragraph, thereby generating a more advanced implicit representation vector that not only contains the information of the keywords, but also incorporates the semantic features of the entire context. In addition, for certain specific tasks (such as fault prediction and anomaly detection), the cloud computing server may also combine domain knowledge bases or expert cloud computing servers to enhance the accuracy and relevance of the implicit representation of the text through rule matching or conditional reasoning. Finally, after processing in step S200, the cloud computing server obtains a series of implicit representations of the target text, which accurately capture the interesting content in the run log text to be analyzed, providing strong data support for subsequent analysis and storage. These implicit representations will be passed as input to the core text index model in step S300 to further explore the data value and optimize storage efficiency.

[0030] Step S300: Iteratively optimize the implicit representation of the target text and the implicit representation of the control core text item obtained by any assignment based on the core text index model to obtain the target core text item implicit representation of the content of interest, wherein the target core text item implicit representation represents the implicit representation of the core text item detected in the content of interest contained in the run log text to be analyzed.

[0031] In step S300, the cloud computing server uses a pre-trained core text index model to deeply process the implicit representation of the target text obtained from step S200 to accurately identify and characterize the core text items of the content of interest that are critical to the operation and maintenance management of the power plant.

[0032] Specifically, the cloud computing server first initializes a reference core text item implicit representation, which is usually done by random assignment (i.e., arbitrary assignment start) to ensure that the model does not fall into a local optimal solution during the iterative optimization process. This reference representation is used as a benchmark and is input into the core text index model together with the target text implicit representation. The core text index model itself is, for example, a complex neural network architecture that combines advanced components such as recurrent neural networks (such as LSTM), convolutional neural networks (CNNs), or self-attention mechanisms (such as Transformers). These models are designed to process sequence data (such as text) and can learn the intrinsic structure and patterns of the data from them. During the iterative optimization process, the model repeatedly adjusts its internal parameters (such as weights and biases) to minimize the objective function (such as the cross entropy loss function), thereby improving the model's recognition accuracy for the target text implicit representation. This optimization process usually involves a backpropagation algorithm that adjusts the model parameters based on the difference between the model's prediction results and the true labels.

[0033] The optimized implicit representation of the target core text item will more accurately reflect the key information in the original text, providing strong support for subsequent log analysis, fault warning, performance evaluation and other tasks. For example, this implicit representation can be used to build a real-time monitoring cloud computing server for power plants. Once a text pattern similar to "Turbine overheating" is detected, the cloud computing server can immediately trigger an alarm and take corresponding countermeasures.

[0034] It should be noted that due to the complexity of the core text index model and the diversity of power plant operation logs, the specific process and effect of iterative optimization will be affected by many factors, including the initial parameter settings of the model, the quality and quantity of training data, the selection of optimization algorithms, etc. Therefore, in practical applications, the model needs to be carefully adjusted and optimized according to specific circumstances.

[0035] Step S400: determining the text paragraphs in the core text item in the content of interest in the run log text to be analyzed based on the implicit representation of the target core text item, marking the core text item to obtain marked run log text, and storing the marked run log text.

[0036] In step S400, the cloud computing server uses the implicit representation of the target core text item obtained from step S300 to accurately locate and mark the text paragraph where the core text item of the content of interest in the operation log text to be analyzed is located, and then generates a marked operation log text and stores it securely on the cloud platform.

[0037] Specifically, the cloud computing server first searches and matches the original operation log text according to the semantic features and location information contained in the implicit representation of the target core text item. This process may involve string matching algorithms, regular expression matching, or more advanced text parsing techniques, depending on the form and complexity of the implicit representation of the target core text item. Take a typical power plant operation log as an example: "2023-04-15 14:30, Turbine 2, Warning: Oil pressure low, please check filters and replenish oil as necessary. System operating normally otherwise." In this log, "Oil pressure low" is identified as the core text item of interest, and its implicit representation has been optimized in step S300 to the extent that it can accurately represent this key information. In step S400, the cloud computing server successfully locates the text paragraph containing "Oil pressure low": "Warning: Oil pressure low, please check filters and replenish oil as necessary." by comparing the implicit representation of the target core text item with each paragraph in the log text. The cloud computing server will then mark the paragraph, which can be done by highlighting, adding specific tags or annotations, etc., to facilitate subsequent review and analysis.

[0038] After the tagging is completed, the cloud computing server will generate a tagged operation log text. This text not only retains all the information of the original log, but also intuitively highlights the location of key information through tags, greatly improving the readability and practicality of the log. Finally, this tagged operation log text is securely stored on the cloud platform, using the high availability and scalability of cloud computing to ensure the persistent preservation and fast access of data.

[0039] By executing step S400, the power plant operation and maintenance personnel can more easily obtain key information in the operation log and take necessary measures in time to deal with potential problems or risks, thereby ensuring the safe and stable operation of the power plant. At the same time, the storage of the marked operation log text also provides a valuable data source for subsequent data analysis and mining, which helps the power plant to continuously optimize the operation and maintenance strategy and improve the operation efficiency.

[0040] In an embodiment of the present application, the core text index model is obtained by performing p rounds of iterative optimization on each run log text template based on the initialized core text index model. In the ath core text index model that completes the ath round of iterative optimization, the bth template implicit representation bigram obtained by the bth round of iterative optimization is iteratively optimized to obtain the ath template implicit representation bigram, and the weights and biases in the ath core text index model are updated according to the implicit representation error between the bth template implicit representation bigram and the ath template implicit representation bigram, and the process stops when the preset stopping requirements are met, wherein 1≤a≤p, b=a-1, the ath template implicit representation bigram includes the ath template text implicit representation and the ath reference template core text item implicit representation, the ath template text implicit representation is obtained by performing a round of iterative optimization based on the initial template text implicit representation extracted from the run log text template, and the ath reference template core text item implicit representation is obtained by performing a round of iterative optimization based on the initial reference template core text item implicit representation obtained by starting with arbitrary assignment.

[0041] The training process of the core text indexing model is a key step to ensure that the model can accurately extract and index key information from the power plant operation logs. This process involves iterative learning of a large number of operation log text templates, and continuously optimizing the model's parameters to improve its ability to identify core text items.

[0042] First, the cloud computing server initializes a core text index model. This model is, for example, a complex neural network structure, such as a Transformer-based encoder-decoder architecture, which can learn and generate effective implicit representations from text data. During initialization, the weights and biases of the model are usually set to random values ​​or predefined default values. Next, the cloud computing server begins to iteratively train the model using operation log text templates. These templates are carefully selected from historical operation logs and contain various typical scenarios and key information in power plant operation. The training process is divided into multiple rounds (set as p rounds), each of which aims to further optimize the performance of the model. In the a-th round of iterative optimization (where 1≤a≤p), the cloud computing server first loads the b-th template implicit representation tuple obtained after the a-1th round (i.e., the b-th round, because b=a-1) iterative optimization. This tuple consists of two parts: the b-th template text implicit representation and the b-th control template core text item implicit representation. The former is the result of b rounds of optimization of the initial text representation extracted from the running log text template, and the latter is the implicit representation of the control core text item obtained by arbitrary assignment startup (i.e. random initialization) and optimized for the same number of rounds. Then, the cloud computing server uses the current core text index model to further iteratively optimize these two implicit representations. The optimization process may include steps such as forward propagation, loss calculation, back propagation, and parameter update. Specifically, the model attempts to predict the core text items in the current text, compares them with the known control core text items, and calculates a loss value (such as cross entropy loss), which measures the difference between the model prediction and the actual situation.

[0043] The loss value is then used to adjust the model's weights and biases through the back-propagation algorithm to reduce future prediction errors. This adjustment process is based on gradient descent, that is, updating the parameter values ​​along the negative gradient direction of the loss function with respect to the model parameters. The specific update formula is, for example:

[0044]

[0045] Among them, θ represents the model parameters (weights and biases), L represents the loss function, and η is the learning rate, which controls the step size of parameter updates. After a round of iterative optimization, the cloud computing server obtains the implicit representation bigram of the a-th template, including a more accurate implicit representation of the a-th template text and the implicit representation of the a-th control template core text item. At the same time, according to the implicit representation error between the b-th template implicit representation bigram and the a-th template implicit representation bigram (such as measured by calculating the Euclidean distance or cosine similarity between the two), the cloud computing server will further adjust the parameters in the core text index model to minimize this error. When the model performance reaches the preset stopping requirements (such as the loss value is lower than a certain threshold, the accuracy on the validation set is no longer significantly improved, etc.), the training process ends. At this point, the cloud computing server obtains a fully trained core text index model that can accurately extract and index core text items from the power plant operation log. Through this process, the cloud computing server not only improves the model's ability to understand text in a specific field, but also enhances its generalization and robustness in practical applications.

[0046] In a possible implementation, the step S300, iteratively optimizing the implicit representation of the target text and the implicit representation of the reference core text item obtained by any assignment start based on the core text index model to obtain the implicit representation of the target core text item of the content of interest, may include:

[0047] The following process is completed in the core text index model:

[0048] Step S310: Load the xth target text implicit representation and the xth comparison core text item implicit representation output by the xth iterative optimization component in the core text index model into the x+1th iterative optimization component in the core text index model, wherein the core text index model includes t iterative optimization components, 1≤x≤t.

[0049] When the cloud computing server executes step S310, the input target text implicit representation has been preliminarily processed by the first x iteration optimization components of the core text index model. The target text implicit representation here is obtained by converting the power plant operation log text through natural language processing (NLP) technology. It contains the semantic information of the log text, but has not yet accurately focused on the core text items of interest.

[0050] After the xth iterative optimization component completes its task, it outputs two important results: the xth target text implicit representation and the xth contrast core text item implicit representation. The xth target text implicit representation is the latest understanding of the target text content in the current iteration round, while the xth contrast core text item implicit representation is a reference representation corresponding to the real core text item, which is generated, for example, by random initialization or other means, and is used to assist model learning during the training process. Subsequently, step S310 loads these outputs as inputs to the x+1th iterative optimization component in the core text index model. This component will continue to process the input more deeply to further refine and strengthen the key information in the text. For example, if the xth component is a Transformer encoder layer based on an attention mechanism, it may have given higher weights to the key parts of the input text; the x+1th component may, on this basis, use a more complex neural network structure (such as stacked Transformer layers, LSTM layers, or convolutional layers) to capture more subtle semantic features and contextual relationships. During the loading process, the cloud computing server ensures the integrity and consistency of the data. At the same time, according to the requirements of the model architecture, it may be necessary to adjust the format or dimension of the data to meet the input requirements of the x+1th iterative optimization component. The transmission and processing of this data is completed automatically without human intervention. It is worth noting that the core text index model usually contains multiple (set to t) such iterative optimization components, which process the input data in turn until all components are executed. Therefore, step S310 is not only a key step in a single iteration, but also a guarantee for the continuous progress of the entire iterative optimization process. Through such a series of iterative optimization processes, the core text index model can gradually approach an accurate understanding of the content of interest in the power plant operation log, and finally output an implicit representation of the target core text item, providing strong support for subsequent data storage, analysis and utilization.

[0051] Step S320: In the x+1th iterative optimization component, the xth target text implicit representation and the xth comparison core text item implicit representation are iteratively optimized to obtain the x+1th target text implicit representation and the x+1th comparison core text item implicit representation.

[0052] In step S320, the cloud computing server passes the xth target text implicit representation and the xth comparison core text item implicit representation output by the xth iterative optimization component as input to the x+1th iterative optimization component. This component is, for example, a complex neural network layer, such as a Transformer-based encoder layer, an LSTM layer, or a convolutional neural network layer combined with an attention mechanism. These neural network layers perform in-depth analysis and processing of input data through their specific algorithms and parameters.

[0053] Taking the Transformer encoder layer as an example, this layer first uses the self-attention mechanism to process the implicit representation of the input. The self-attention mechanism allows the model to refer to the information of all positions in the input sequence when processing the information at each position, thereby capturing the long-distance dependencies in the text. In the x+1th iterative optimization component, the self-attention mechanism calculates the attention weights between the feature vectors in the implicit representation of the xth target text and the implicit representation of the xth control core text item, and weighted sums the feature vectors according to these weights to generate a new set of feature vectors. Next, this layer can apply a positional encoding to preserve the order information of the elements in the input sequence, because the Transformer model itself does not understand the order of the input. The positional encoding is added to the feature vector generated in the previous step to obtain a set of feature vectors containing position information.

[0054] Subsequently, these feature vectors pass through a series of feed-forward neural networks, which usually contain two linear transformation layers and a ReLU activation function. The feed-forward neural network further performs nonlinear transformation on the feature vectors to extract higher-level features.

[0055] After the above processing, the x+1th iterative optimization component will output the x+1th target text implicit representation and the x+1th comparison core text item implicit representation. These two implicit representations are more refined and accurate than the input because they have been deeply optimized through complex neural network layers.

[0056] Specifically, the x+1th target text implicit representation may contain a series of feature vectors that are more focused on the interesting content in the power plant operation log, such as features related to equipment failures, performance anomalies, etc. Although the x+1th control core text item implicit representation is still randomly initialized, after this round of iterative optimization, the gap between it and the real core text item implicit representation has been narrowed, providing a better starting point for subsequent iterations.

[0057] It should be noted that the entire iterative optimization process is a cyclic process, and the output of the x+1th iterative optimization component will become the input of the next iterative optimization component until all t iterative optimization components are executed. Through such continuous iteration and optimization, the core text index model can gradually approach an accurate understanding of the content of interest in the power plant operation log.

[0058] Step S330: when x+1=t, the implicit representation of the x+1th control core text item is used as the implicit representation of the target core text item.

[0059] Step S330 is an important judgment and execution point in the iterative optimization process of the core text index model. It marks the end of the entire iterative process and determines the final optimization result as the implicit representation of the target core text item. In the iterative optimization process of the core text index model, the cloud computing server processes the input target text implicit representation and the control core text item implicit representation through t iterative optimization components in turn. Each component will be further optimized based on the output of the previous component to generate a new implicit representation. This process is cyclic until all components have been traversed. When the iteration variable x increases to make x+1 equal to the total number of components t, it means that all predetermined iterative optimization components have completed the processing of the input data. At this time, step S330 is triggered, and the cloud computing server regards the current (i.e., the output of the tth component) control core text item implicit representation as the final target core text item implicit representation. Although the control core text item implicit representation is randomly initialized at the beginning of the iteration, it gradually approaches the core implicit representation of the content of real interest in the target text after layer-by-layer processing and optimization of multiple iterative optimization components. In the scenario of intelligent cloud archive storage in power plants, the content of interest may include but is not limited to equipment fault alarms, abnormal performance indicators, changes in key operating parameters, etc.

[0060] Specifically, if the target text is about the operation log of a generator set, which contains the description of "the temperature of the generator is too high, and the cloud computing server is automatically started to cool down", then through the iterative optimization of the core text index model, the implicit representation of the target core text item will be able to highly represent the key information that the temperature of the generator is too high. This implicit representation is, for example, a collection of feature vectors, each of which corresponds to the semantic features of a key word or phrase in the text, and together constitutes an accurate description of the core text item.

[0061] Therefore, in step S330, the cloud computing server does not perform further calculation or optimization, but directly uses the implicit representation of the control core text item output by the last iterative optimization component as the final result. This result can then be used in subsequent data analysis, storage or retrieval tasks, providing strong support for the operation and maintenance management of the power plant.

[0062] Step S340: when x+1<t, the obtained x+1th target text implicit representation and the x+1th control core text item implicit representation are loaded into the x+2th iterative optimization component to perform the x+2th iterative optimization.

[0063] Step S340 ensures the continuity of the entire iteration process until the preset number of iterations t is reached. In the cloud computing-based intelligent cloud archive storage scenario of power plants, the execution of this step is crucial for accurately extracting key information from massive operation logs.

[0064] When executing step S340, the cloud computing server first checks whether the current iteration round x+1 is less than the total iteration number t. If the condition is met, that is, there are more iterative optimization components that need to process input data, then the cloud computing server will continue to execute the iterative optimization process.

[0065] In this step, the cloud computing server takes the implicit representation of the x+1th target text and the implicit representation of the x+1th comparison core text item output by the x+1th iterative optimization component as input and loads them into the x+2th iterative optimization component. These two implicit representations are the results of the previous round of iterative optimization. They have passed the complex processing of the x+1th component and contain richer and more accurate text information.

[0066] The x+2th iterative optimization component is, for example, a complex model containing a multi-layer neural network structure, which further analyzes and optimizes the implicit representation of the input. This component can use convolutional layers to extract local features in the text, use recurrent layers to capture temporal dependencies in sequence data, or use attention mechanisms to focus on the most critical parts of the text.

[0067] Taking the Transformer encoder layer as an example, the x+2th component can use the self-attention mechanism to allow the model to refer to the information of all positions in the input sequence when processing the information at each position, thereby capturing the global dependencies in the text. Through the multi-head attention mechanism, the model can process information from different representation subspaces in parallel, further enhancing its ability to understand the text content.

[0068] Inside the x+2th iterative optimization component, the computing cloud computing server will perform a series of complex calculations, including linear transformation, activation function application, normalization operations, etc., to generate new implicit representations. These new implicit representations will more accurately reflect the key information in the text and provide strong support for subsequent data processing and analysis. After completing the processing of the x+2th iterative optimization component, the cloud computing server will obtain the x+2th target text implicit representation and the x+2th control core text item implicit representation. These two new implicit representations will then be passed as input to the next iterative optimization component (if any) to continue the iterative optimization process.

[0069] By continuously repeating step S340 until x+1 equals t, the cloud computing server can ensure that the core text index model fully iterates and optimizes the input text. The resulting implicit representation of the target core text item will accurately reflect the key information in the text, providing powerful data support for the operation and maintenance management of the power plant.

[0070] In a possible implementation, the step S320, in the x+1th iterative optimization component, iteratively optimizing the xth target text implicit representation and the xth comparison core text item implicit representation to obtain the x+1th target text implicit representation and the x+1th comparison core text item implicit representation, may include:

[0071] The following process is completed in the x+1th iterative optimization component:

[0072] Step S321: In the first iterative optimization module of the x+1th iterative optimization component, linearly map the log text sub-implicit representation output by the xth iterative optimization component to obtain the first log text sub-implicit representation; linearly map the control core text item sub-implicit representation output by the xth iterative optimization component to obtain the first control core text item sub-implicit representation.

[0073] In step S321, the cloud computing server performs preliminary processing on the log text sub-implicit representation and the control core text item sub-implicit representation output by the x-th iterative optimization component by means of linear mapping to generate a new implicit representation, laying the foundation for subsequent more complex optimization. Specifically, when the cloud computing server executes step S321, it first focuses on the output results of the x-th iterative optimization component. These outputs include two parts: the log text sub-implicit representation and the control core text item sub-implicit representation. The log text sub-implicit representation is usually a high-dimensional vector that captures the semantic information of a sub-paragraph or key word in the power plant operation log; while the control core text item sub-implicit representation is a random initialization vector corresponding to the true core text item implicit representation, which is used to guide model learning during the iteration process.

[0074] To further refine this information in the x+1th component, the cloud computing server applies a linear mapping within the first iterative optimization module. A linear mapping is a basic mathematical transformation that transforms an input vector into a new output vector via a weight matrix and a bias vector. In this scenario, a linear mapping is used to perform a preliminary spatial transformation on the input sub-implicit representation to make it more suitable for subsequent optimization steps.

[0075] Assume that the log text output of the x-th iteration optimization component is implicitly represented as where d x is the dimension of the vector; in contrast to the core text term, it is implicitly represented as In the first iterative optimization module, the cloud computing server defines two sets of weight matrices W text ∈R dx+1×dx and W core ∈R dx+1×dx , and two sets of bias vectors b text ∈R dx+1 and b core ∈R dx+1 , where d x+1 is the dimension of the new implicit representation, which may be different from the dimension of the input vector.

[0076] Then, the cloud computing server calculates the first log text implicit representation by the following formula: and the first comparison core text item implicitly represents

[0077]

[0078] These two newly generated implicit representations are then used as the output of the first iterative optimization module and may be further passed to other iterative optimization modules within the component for deeper optimization.

[0079] Through such linear mapping processing, the cloud computing server can perform a preliminary transformation of the input sub-implicit representation in a simple and effective way, laying the foundation for subsequent nonlinear transformation and feature extraction. This processing method not only retains the main features of the input information, but also provides more optimization space for the model by introducing new dimensions and linear combinations.

[0080] Step S322: In the e-th iterative optimization module of the x+1-th iterative optimization component, the f-th log text sub-implicit representation and the f-th control core text item sub-implicit representation output by the f-th iterative optimization module of the x+1-th iterative optimization component are loaded into the e-th iterative optimization module in the x+1-th iterative optimization component, where 2≤e, f=e-1.

[0081] In step S322, the cloud computing server is responsible for using the output of the previous iterative optimization module (the fth module, where f=e-1) as the input of the current iterative optimization module (the eth module) to achieve continuous data processing and optimization. Specifically, within the x+1th iterative optimization component, there are multiple iterative optimization modules, which are arranged in sequence, and each module performs specific processing on the input data and passes the processing results to the next module.

[0082] Taking the scenario of intelligent cloud archive storage in a power plant as an example, suppose the x+1th iterative optimization component is processing an operation log text about abnormal generator temperature. In this log, key information (i.e., core text items) may include words or phrases such as "generator temperature" and "abnormal increase". During the iterative optimization process, each module will try to extract more representative features from these words or phrases to more accurately represent the key information in the log.

[0083] In step S322, the cloud computing server first obtains the output of the fth iterative optimization module (i.e., the previous module), which includes the fth log text sub-implicit representation and the fth comparison core text item sub-implicit representation. These two implicit representations capture the semantic information of a certain part of the log text and the current state of the random initialization information corresponding to the core text item.

[0084] The cloud computing server then loads these two implicit representations as inputs into the e-th iterative optimization module. Here, e is an integer greater than f (since f = e-1, e is at least 2), indicating that the data is flowing forward along the module chain. Inside the e-th module, the cloud computing server further processes these inputs, which may include linear transformation, nonlinear activation, feature extraction, application of attention mechanisms, and other operations, depending on the design and purpose of the module. These operations are designed to extract more valuable features from the input data in order to more accurately represent the core text items.

[0085] It is worth noting that step S322 not only realizes the transfer of data between modules, but also implies the dependencies and optimization order between modules. Since the output of each module is calculated based on its input, the arrangement order and internal processing logic of the modules have an important impact on the final optimization result. By continuously repeating step S322 and subsequent optimization steps (such as steps S323 and S324), the cloud computing server can gradually extract the most critical and representative information in the log text and store it in the core text index model in the form of implicit representation. These implicit representations not only help subsequent log retrieval and analysis tasks, but also provide strong data support for the operation and maintenance management of power plants.

[0086] Step S323: In the e-th iterative optimization module, linearly map the f-th log text sub-implicit representation to obtain a first mapping feature vector, and use the first mapping feature vector as the e-th log text sub-implicit representation output by the e-th iterative optimization module; and linearly map the f-th control core text item sub-implicit representation to obtain a second mapping feature vector; based on the first mapping feature vector and the second mapping feature vector, obtain the e-th control core text item sub-implicit representation output by the e-th iterative optimization module.

[0087] Step S323 describes how to process the input log text sub-implicit representation and control core text item sub-implicit representation in the e-th iterative optimization module, and generate new implicit representations for use in subsequent steps. In the cloud computing server, when the e-th iterative optimization module of the x+1-th iterative optimization component is executed, it first receives two inputs from the f-th module (where f=e-1): the f-th log text sub-implicit representation and the f-th control core text item sub-implicit representation. These two inputs represent the intermediate representations of the log text and the control core text item in the current iteration round in the model.

[0088] The processing of step S323 can be divided into the following key steps:

[0089] The cloud computing server first performs a linear mapping on the f-th log text implicit representation. The linear mapping usually involves a weight matrix and a bias vector The first mapping eigenvector is calculated by the following formula

[0090]

[0091] in, is the implicit representation of the log text output by the fth module, is the first mapping feature vector obtained after linear mapping. This vector captures higher-level feature information in the log text.

[0092] In some cases, the first mapping feature vector It can be directly used as the log text sub-implicit representation output by the e-th iterative optimization module However, in more complex models, nonlinear activation functions (such as ReLU, Sigmoid, etc.) or other transformation steps may be required for further processing. However, to simplify the explanation, it is assumed that as output.

[0093] Similarly, the cloud computing server performs a linear mapping on the implicit representation of the f-th core text item to obtain the second mapping feature vector The weight matrix and bias vector used in this process may be different from those used in processing log text, and are denoted as and

[0094]

[0095] in, It is the implicit representation of the control core text item output by the f-th module.

[0096] Finally, the cloud computing server is based on the first mapping feature vector and the second mapping eigenvector To generate the implicit representation of the core text item output by the e-th iterative optimization module This step may involve a variety of operations, such as concatenation, summation, dot product, or more complex nonlinear transformations. For illustration, we can assume a simple fusion method, such as weighted summation.

[0097] Through the above steps, the cloud computing server completes the processing in the e-th iterative optimization module and generates new log text sub-implicit representations and control core text item sub-implicit representations. These representations will serve as inputs for the next round of iterations and continue to participate in the optimization process of the model.

[0098] Step S324: When the e-th iterative optimization module is the last iterative optimization module in the x+1-th iterative optimization component, the e-th log text sub-implicit representation is used as the x+1-th target text implicit representation obtained by executing the x+1-th iterative optimization component, and the e-th comparison core text item sub-implicit representation is used as the x+1-th comparison core text item implicit representation obtained by executing the x+1-th iterative optimization component.

[0099] In step S324, based on the position of the currently processed iterative optimization module, it is decided when to use the intermediate processing result as the final output of the component. The core text indexing model processes the input log text through multiple iterative optimization components to extract key information. Each iterative optimization component contains multiple iterative optimization modules, which process the input data in turn, gradually refining and optimizing the implicit representation. When the data flows through the last iterative optimization module, the output of the module is regarded as the final result of the entire component.

[0100] In the cloud computing server, when processing the e-th iterative optimization module of the x+1-th iterative optimization component, the cloud computing server will first check whether the module is the last module in the component. This judgment is usually based on the design parameters or module count of the component. If it is the last module (that is, no other subsequent modules can receive its output), the following operations are performed:

[0101] Determine the implicit representation of the x+1th target text: The eth log text sub-implicit representation output by the eth iterative optimization module is directly used as one of the final outputs of the x+1th iterative optimization component, that is, the x+1th target text implicit representation. This implicit representation integrates the processing results of all modules in the component on the input log text and is the model's latest understanding of the key information of the current log text.

[0102] Determine the implicit representation of the x+1th control core text item: Similarly, the eth control core text item sub-implicit representation output by the eth iterative optimization module is used as another final output of the x+1th iterative optimization component, that is, the x+1th control core text item implicit representation. Although this representation is introduced as a random initialization vector corresponding to the real core text item during the iteration process, after iterative optimization of multiple modules, it has gradually approached the implicit representation of the real core text item.

[0103] For example, suppose the x+1th iterative optimization component contains three iterative optimization modules (e=1, 2, 3), and the third module (i.e., e=3) is currently being processed. When the third module completes its iterative optimization task, the 3rd log text sub-implicit representation and the 3rd comparison core text item sub-implicit representation output by it will be regarded as the x+1th target text implicit representation and the x+1th comparison core text item implicit representation, respectively, because these representations are the final results obtained after all modules in the component have been processed.

[0104] Through step S324, the cloud computing server ensures that each iterative optimization component can output meaningful implicit representations, which will serve as inputs for subsequent processing steps (such as steps S330 and S340) and continue to participate in the overall optimization process of the core text index model. Ultimately, when all iterative optimization components have completed processing, the model will be able to generate accurate implicit representations of target core text items to support efficient storage and retrieval of the power plant intelligent cloud archive.

[0105] In a possible implementation, before extracting the implicit representation of the target text from the to-be-analyzed operation log text, the method further includes an initialization step of a core text index model, which may specifically include:

[0106] Step S200A: extract the implicit representation of the initial template text from the obtained u-th running log text template, and obtain the implicit representation of the initial comparison template core text item obtained by any assignment startup, 1≤u≤q.

[0107] In the cloud computing-based intelligent cloud archive storage cloud computing server for power plants, the cloud computing server first obtains a series of operation log text templates from the database of the power plant. These templates represent various typical scenarios in the daily operation of the power plant, such as equipment startup, normal operation, fault alarm, etc., which are of great significance for the model to learn the characteristics of the power plant operation log. For each operation log text template obtained (numbered as the uth, where 1≤u≤q, q is the total number of templates), the cloud computing server first applies natural language processing technology (NLP) to extract its initial template text implicit representation. This step usually involves text vectorization, that is, converting the text into a high-dimensional vector form that can be directly processed by the computer. These vectors capture the key semantic information in the text, enabling the cloud computing server to understand and analyze the text content.

[0108] Specifically, the cloud computing server can use a pre-trained word embedding model (such as Word2Vec, GloVe, or BERT) to convert each word in the text into a corresponding word vector. Then, through some aggregation strategy (such as average pooling, weighted average, or more complex attention mechanism), these word vectors are combined into a single vector as the initial implicit representation of the template text. Although this vector cannot completely restore all the information of the original text, it is sufficient to capture the main features and meaning of the text.

[0109] At the same time, in order to provide a benchmark corresponding to the implicit representation of the real core text items, the cloud computing server also needs to generate the initial control template core text item implicit representation. Since there is no real core text item for reference at this stage, this representation is obtained by starting with arbitrary assignment (i.e., random initialization). Specifically, the cloud computing server can randomly generate a vector with the same dimension as the initial template text implicit representation but random content as the control representation. This vector has no practical meaning in the initialization stage, but in the subsequent iterative optimization process, it will serve as a target to guide the model to gradually learn the real core text item implicit representation.

[0110] Through the above steps, the cloud computing server generates a pair of initial implicit representations for each operation log text template: the initial template text implicit representation and the initial control template core text item implicit representation. These two sets of representations will be used as input data for the initialization of the core text index model and participate in the subsequent iterative optimization process. During the iterative process, the model will gradually learn how to extract implicit representations that are closer to the real core text items from the initial template text implicit representation, thereby improving the model's ability to understand and analyze the power plant operation log.

[0111] The following process is completed cyclically for the implicit representation of the initial template text and the implicit representation of the initial comparison template core text item, and the optimization stops when p rounds of iteration are reached:

[0112] Step S200B: in the ath core text index model that has completed the ath round of iterative optimization, iterative optimization is performed on the bth template implicit representation bigram obtained by the bth round of iterative optimization to obtain the ath template implicit representation bigram, when a is equal to 1, the bth template implicit representation bigram obtained by the bth round of iterative optimization represents the initial template implicit representation bigram, and the initial template implicit representation bigram includes the initial template text implicit representation and the initial comparison template core text item implicit representation;

[0113] Step S200B involves further optimizing the template implicit representation based on the completed iteration rounds. In each iteration, the cloud computing server processes the template implicit representation using the current core text index model. These template implicit representations are initially extracted from the run log text template through step S200A, including the initial template text implicit representation and the initial control template core text item implicit representation, which together constitute the initial template implicit representation tuple. As the iteration proceeds, these representations will be continuously optimized to more accurately reflect the key information in the text.

[0114] Specifically, in step S200B, after completing the a-th round of iterative optimization, the cloud computing server will obtain the a-th core text index model. This model has accumulated a lot of learning experience through the previous a-1 rounds of iterations and can process text data more accurately. At this time, the cloud computing server needs to use this optimized model to further iteratively optimize the b-th template implicit representation tuple obtained by the b-th round of iterative optimization.

[0115] It is worth noting that round b and round a here are not completely independent. In fact, at the beginning of round a, the cloud computing server needs to use the template implicit representation tuple obtained by iterative optimization in round b (actually round a-1, because b = a-1) as input. When a is equal to 1, this tuple is the initial template implicit representation tuple, that is, the set of data containing the initial template text implicit representation and the initial reference template core text item implicit representation.

[0116] In the iterative optimization process, the cloud computing server inputs the implicit representation binary of the bth template into the ath core text index model. This model is, for example, a complex neural network structure, which contains components such as multiple hidden layers, activation functions, and loss functions. Through mechanisms such as forward propagation and back propagation, the model processes the input data and gradually adjusts its internal parameters (such as weights and biases) to minimize the loss function value and improve the model's ability to fit text data.

[0117] After a new round of iterative optimization, the cloud computing server will obtain the a-th template implicit representation tuple. This new tuple contains the implicit representation of the template text after the a-th round of iterative optimization and the implicit representation of the core text item of the control template. Compared with the b-th template implicit representation tuple, the representations in the a-th template implicit representation tuple are more accurate and effective because they have been optimized through further processing by the a-th core text index model. This process will be repeated until the preset iteration round p is reached. In each round of iteration, the cloud computing server will use the model and optimization results obtained in the previous round of iteration to guide the optimization process of the current round. In this way, the core text index model can gradually learn the inherent laws and feature representation methods of text data, providing strong support for the subsequent power plant operation log analysis.

[0118] Step S200C: determining a template implicit representation difference amount between the b-th template implicit representation bigram and the a-th template implicit representation bigram according to an implicit representation error between the b-th template implicit representation bigram and the a-th template implicit representation bigram;

[0119] In the cloud computing server, after completing the a-th round of iterative optimization, a new set of template implicit representation tuples is obtained, namely the a-th template implicit representation tuple. This tuple contains the optimized template text implicit representation and the reference template core text item implicit representation. In order to evaluate the effect of this round of iteration, the cloud computing server needs to compare the difference between the tuples of the current round (a-th round) and the tuples of the previous round (b-th round, where b=a-1). This is the core task of step S200C.

[0120] Specifically, step S200C first calculates the implicit representation error between the implicit representation binary of the b-th template and the implicit representation binary of the a-th template. This error is usually measured by comparing the similarity or distance between the two groups of representations. In vector space, distance is an intuitive and effective measurement method. Commonly used distance calculation methods include Euclidean distance, Manhattan distance, cosine similarity, etc.

[0121] Taking the Euclidean distance as an example, assuming that the template text in the b-th template implicitly represents the binary is implicitly represented as a vector The core text items of the template are implicitly represented as vectors The ath template implicitly represents the corresponding vectors in the two-tuples are and Then the difference between the template implicit representation binary group of the bth template and the template implicit representation binary group of the ath template (taking the Euclidean distance as an example) can be calculated by the following formula:

[0122]

[0123] Among them, ∥·∥ 2 Represents the calculation of Euclidean distance, d is the dimension of the vector, and Respectively, the template text of round a and round b implicitly represents the value of the i-th element in the vector. Similarly, and Represents the value of the corresponding element in the reference template core text item implicitly represents the vector.

[0124] In practical applications, the cloud computing server can calculate the difference between the implicit representation of the template text and the implicit representation of the core text item of the reference template separately, or merge them into a comprehensive difference (for example, by weighted summation). This difference reflects the change in model performance during the iterative optimization process. If the difference is small, it means that the output of the model does not change much in two consecutive iterations, which may mean that the model is close to convergence; if the difference is large, it means that there is still a lot of room for optimization.

[0125] Through the calculation in step S200C, the cloud computing server can quantitatively evaluate the effect of each round of iterative optimization and provide important feedback information for the subsequent training process. This helps the cloud computing server to adjust the training strategy more intelligently and improve the accuracy and efficiency of the core text index model.

[0126] Step S200D: fusing the implicit representation differences of the first a templates to obtain the ath implicit representation debugging cost value;

[0127] The purpose of step S200D is to meaningfully integrate the template implicit representation differences generated in each round of iteration (i.e., the output of step S200C) to obtain an indicator that can reflect the current performance of the model - the ath implicit representation debugging cost value.

[0128] When the cloud computing server executes step S200D, it has calculated the difference in implicit representation of the template generated in each round of iterations in the previous a rounds of iterations through step S200C. These differences may include the difference in implicit representation of the template text and the difference in implicit representation of the reference template core text item, which respectively measure the degree of change of the implicit representation of the same template text and reference core text item in two consecutive rounds of iterations.

[0129] In order to obtain a comprehensive evaluation index, the cloud computing server integrates these differences. The integration method can be a simple arithmetic average, a weighted average, or other more complex aggregation methods. Here, the weighted summation is used as an example.

[0130] First, assume that for the a-th iteration, the cloud computing server has calculated the set of implicit representation differences of the template text for the previous a-th iteration:

[0131] {Differencetext,1,Differencetext,2,…,Differencetext,a};

[0132] The core text item of the comparison template implicitly represents a collection of differences:

[0133] {Differencecore,1,Differencecore,2,…,Differencecore,a}.

[0134] Then, the cloud computing server can assign a set of weights {α1, α2, …, αa} and {β1, β2, …, βa} to the two sets of differences respectively. These weights can be set according to the actual situation, for example, they can be assigned based on the importance of the difference to the model performance. Next, the cloud computing server performs weighted summation on the implicit representation difference of the template text and the implicit representation difference of the core text item of the control template, respectively, to obtain two sets of weighted sums.

[0135] Finally, in order to obtain a unified implicit representation debugging cost value, the cloud computing server can further fuse the above two sets of weighted sums. The fusion method can be a simple arithmetic average or other aggregation functions designed according to actual needs. In this way, the cloud computing server obtains the ath implicit representation debugging cost value, which reflects the overall performance change trend of the model during the first a rounds of iterations. By comparing the debugging cost values ​​of different iterations, the cloud computing server can evaluate the convergence of the model and then decide whether to continue iterative optimization or adjust the optimization strategy. In the cloud computing-based power plant intelligent cloud archive storage scenario, the significance of this step is to provide a quantifiable monitoring indicator for model training. By real-time monitoring of the changes in the debugging cost value, the cloud computing server can promptly discover and solve problems that may arise during the training process, ensuring that the model can converge to the optimal state stably and efficiently, thereby providing more accurate and reliable support for the operation log analysis of the power plant.

[0136] Step S200E: If the implicit representation debugging cost value determined based on the implicit representation difference amounts of all templates obtained after the first a rounds of iterative optimization cannot meet the cost threshold, then update the weights and biases in the a-th core text index model to obtain the a+1-th core text index model; complete the a+1-th round of iterative optimization in the a+1-th core text index model.

[0137] In the cloud computing server, as the iterative optimization proceeds, each time a round of iteration is completed, the cloud computing server will evaluate the current performance of the model based on the difference in the implicit representation of the template calculated during the previous a rounds of iterations. These differences are calculated by step S200C and merged into an implicit representation debugging cost value in step S200D. This cost value reflects the degree of optimization of the implicit representation of the template text and the reference template core text items during the iteration process. Next, in step S200E, the cloud computing server will compare this implicit representation debugging cost value with a preset cost threshold. The cost threshold is a standard set according to actual needs and is used to determine whether the model has reached a sufficient degree of optimization. If the implicit representation debugging cost value is greater than the cost threshold, it means that the current model performance has not yet reached a satisfactory standard and it is necessary to continue iterative optimization.

[0138] At this point, the cloud computing server will update the weights and biases in the a-th core text index model based on the results of the previous a-round iterations. Weights and biases are key parameters in a neural network model, which determine how the model responds to input data and the accuracy of the output results. The process of updating these parameters usually relies on a back-propagation algorithm, which guides the adjustment direction of the parameters based on the difference between the model's predicted results and the actual results (i.e., loss or error). After updating the weights and biases, the cloud computing server obtains a new model version, the a+1-th core text index model. This new model inherits the optimization results of the previous a-round iterations, and further adjusts and optimizes them on this basis. Subsequently, the cloud computing server will continue to perform the iterative optimization process on the a+1-th core text index model, i.e., enter the a+1-th round of iterations.

[0139] In the a+1th iteration, the cloud computing server will repeat the previous steps, including using the new model to process the template text and compare the template core text items, calculate the implicit representation difference, evaluate the model performance, etc. As the iterations continue, the performance of the model will gradually improve, and the implicit representation debugging cost will gradually decrease. When the implicit representation debugging cost finally meets the cost threshold, it means that the model has reached the expected optimization level, and the iteration process will stop.

[0140] Step S200F: If the implicit representation debugging cost value determined based on all template implicit representation differences obtained after the previous a rounds of iterative optimization meets the cost threshold, the a-th round of iterative optimization is determined to be the p-th round of iterative optimization.

[0141] Step S200F ensures that the model can reach the expected performance standard after a sufficient number of iterations, thereby avoiding unnecessary waste of computing resources. When step S200F is executed in the cloud computing server, the first a rounds of iterative optimization have been completed, and the template implicit representation differences calculated during these iterations are merged into implicit representation debugging cost values ​​through step S200E. This cost value reflects the performance of the model in the current iteration round.

[0142] Next, the cloud computing server will compare this implicit representation debugging cost value with the preset cost threshold. The cost threshold is a standard set according to actual needs to evaluate whether the model has achieved a satisfactory degree of optimization. If the implicit representation debugging cost value meets (i.e. is less than or equal to) the cost threshold, then it can be considered that the current model performance is good enough and no further iterative optimization is required.

[0143] At this time, step S200F is triggered, and the cloud computing server determines that the ath round of iterative optimization is the last round of iterative optimization in the entire initialization process, that is, the pth round of iterative optimization. Here, p is a pre-set maximum number of iterations, but in the actual execution process, if the model can meet the performance requirements before reaching p rounds, then the iteration can be terminated in advance, thereby saving computing resources.

[0144] After determining the number of iterations, the cloud computing server can save and use the currently optimized core text index model as the initialized model. This model has gone through multiple iterations and has the ability to extract key information from the power plant operation logs, which can provide strong support for subsequent log analysis and storage.

[0145] It is worth noting that although step S200F determines the end of iterative optimization, the optimization process of the entire model does not entirely depend on this step. In actual applications, the cloud computing server may also make a comprehensive judgment on whether to continue iteration based on other factors (such as time constraints, resource usage, etc.). In addition, with the continuous addition of new data and changes in model application scenarios, the initialized model may need further online learning or regular updates to adapt to new needs.

[0146] In a possible implementation, the step S200C, determining the template implicit representation difference amount between the b-th template implicit representation bigram and the a-th template implicit representation bigram according to the implicit representation error between the b-th template implicit representation bigram and the a-th template implicit representation bigram, may include:

[0147] Step S200C1: determining the difference between the implicit representation of the b-th template text in the b-th template implicit representation binary and the implicit representation of the a-th template text in the a-th template implicit representation binary to obtain the difference of the b-th template implicit representation;

[0148] Step S200C2: Determine the difference between the implicit representation of the bth control template core text item in the bth template implicit representation tuple and the implicit representation of the ath control template core text item in the ath template implicit representation tuple to obtain the difference of the bth control template implicit representation.

[0149] In the iterative optimization process of the core text index model, the implicit representation of the template text is an internal encoding method of the model for key information in the power plant operation log. As the iteration proceeds, these implicit representations will gradually approach the real semantic features, thereby more accurately reflecting the content of the log text. The purpose of step S200C1 is to quantify this approximation process, that is, to calculate the difference between the implicit representation of the template text in the b-th iteration and the a-th iteration.

[0150] Assume that the template text obtained after the bth round of iterative optimization is implicitly represented as a vector Where d is the dimension of the vector, which represents the position of the text in the implicit space. Similarly, the template text obtained after the a-th round of iterative optimization is implicitly represented as the vector In order to quantify the difference between these two vectors, a variety of distance metrics can be used, among which the most commonly used is the Euclidean distance.

[0151] In some cases, we may be more concerned with the directional difference between vectors rather than the absolute distance. In this case, cosine similarity can be used as a metric. In the cloud computing server for intelligent cloud archive storage of power plants, the implicit representation of template text may represent a specific device state or operating parameter. For example, a log about the temperature of a generator may be encoded as an implicit representation vector, which contains information in multiple dimensions such as temperature values ​​and change trends. As iterations proceed, this vector will be gradually optimized to more accurately reflect the key information in the log.

[0152] Assume that in the bth iteration, the model encodes a log about the generator temperature being too high and obtains the implicit representation vector Then, in the ath iteration, this vector is further optimized to By calculating the Euclidean distance between the two, we can evaluate whether the model has a deeper understanding of the log between two iterations, that is, whether it has captured the key information in the log more accurately. If the calculated distance is small, it means that the implicit representations obtained in the two iterations are very close, and the model may be close to convergence; conversely, if the distance is large, it means that there is still a lot of room for optimization.

[0153] Similar to the implicit representation of the template text, the implicit representation of the core text item of the control template is a random initialization vector introduced by the model in the iterative optimization process to guide learning. As the iteration proceeds, this vector will gradually approach the real implicit representation of the core text item, thus playing a key role in the training process. The purpose of step S200D2 is to quantify this approximation process, that is, to calculate the difference between the implicit representation of the core text item of the control template in the b-th iteration and the a-th iteration.

[0154] Similar to step S200D1, the same distance measurement method may be used to calculate the difference between the implicit representations of the core text items of the reference template.

[0155] In the cloud computing server for intelligent cloud archive storage of power plants, although the implicit representation of the core text items of the control template is randomly initialized at first, it will gradually approach the true core text item representation during the iterative optimization process. This approximation process helps the model to more accurately identify the key information fragments (i.e., core text items) in the log. By calculating the Euclidean distance or other distance metrics between two vectors, the convergence of the implicit representation of the core text items of the control template during the iteration process of the model can be evaluated. If the distance gradually decreases and tends to be stable, it means that the model has successfully guided the implicit representation of the core text items of the control template to approach the true core text item representation; conversely, if the distance fluctuates greatly or continues to increase, it may mean that the model has encountered difficulties in the optimization process or needs to adjust the optimization strategy.

[0156] Step S200C monitors the learning progress of the model and evaluates the effect of iterative optimization by calculating the difference between the implicit representation of the template text and the implicit representation of the core text item of the reference template during the iteration process.

[0157] In a possible implementation, the step S200D of fusing the first a template implicit representation differences to obtain the ath implicit representation debugging cost value may include:

[0158] Step S200D1: fusing the previous a template implicit representation differences to obtain a template implicit representation debugging cost value, and fusing the previous a reference template implicit representation differences to obtain a reference implicit representation debugging cost value;

[0159] Step S200D2: The template implicit representation debugging cost value and the reference implicit representation debugging cost value are merged to obtain the ath implicit representation debugging cost value.

[0160] In the iterative optimization process, each round of iteration will generate a set of template implicit representation difference values ​​and a set of reference template implicit representation difference values ​​(as described in step S200C). These difference values ​​reflect the degree of approximation of the model to the implicit representation of the template text and the implicit representation of the reference template core text item in the iteration. The task of step S200D1 is to merge these difference values ​​to obtain two independent debugging cost values: the template implicit representation debugging cost value and the reference implicit representation debugging cost value.

[0161] Assume that in the first a rounds of iterations, the differences in the implicit representation of the templates generated in each round of iteration are Dtemplate1, Dtemplate2, ..., Dtemplatea. These differences can be obtained by calculating the distance (such as Euclidean distance) between the implicit representation vectors of the template text. In order to merge these differences into a single debugging cost value, the cloud computing server can use a variety of methods, such as arithmetic mean, weighted mean, geometric mean, etc.

[0162] Similar to the template implicit representation, the comparison template implicit representation will also produce differences in each round of iteration, which are denoted as D control1 ,D control2 ,...,D controla These differences reflect the changes in the implicit representation of the core text items of the control template during the iteration process. Similarly, the cloud computing server can use methods such as arithmetic averaging to merge these differences into the debugging cost value of the control implicit representation.

[0163] In the early stages of iteration, because the model has not yet been fully learned, the difference between the template implicit representation and the control implicit representation may be large. As the iteration progresses, these differences will gradually decrease, indicating that the model is gradually converging. By calculating the template implicit representation debugging cost C templatea and compare the implicit representation debug cost value C controla ,The cloud computing server can quantitatively evaluate the learning progress and ,effect of the model during the iteration.

[0164] After calculating the template implicit representation debugging cost value and the reference implicit representation debugging cost value respectively, the task of step S200D2 is to further merge the two cost values ​​to obtain the ath implicit representation debugging cost value Ca. This cost value comprehensively reflects the degree of approximation of the implicit representation of the template text and the reference template core text item in the iterative process, and is an important indicator for evaluating the overall performance of the model.

[0165] There are many ways to fuse the template implicit representation debugging cost value and the control implicit representation debugging cost value, the most common ones are arithmetic mean, weighted average, maximum value, minimum value, etc. The choice of fusion method depends on the specific application scenario and evaluation requirements. Here, it is assumed that the template implicit representation and the control implicit representation have equal importance in evaluating model performance, so a simple arithmetic average is used for fusion. However, in practical applications, if a certain type of implicit representation is considered to be more important in the evaluation, it can be assigned a higher weight.

[0166] In the cloud computing server for intelligent cloud archive storage of power plants, template implicit representation and control implicit representation may have different importance in evaluating model performance. For example, if the main task of the model is to accurately identify the operating status of the generator set (i.e., template text implicit representation), then the template implicit representation debugging cost value can be given a higher weight when fused.

[0167] Assuming that the weighted average method is used for fusion, and the template implicit representation debugging cost value is assigned a weight α, and the control implicit representation debugging cost value is assigned a weight 1-α, then the a-th implicit representation debugging cost value C a The calculation formula becomes:

[0168] C a =αC templatea +(1-α)C controla ;

[0169] Step S200E calculates the ath implicit representation debugging cost by fusing the template implicit representation difference generated in the previous a rounds of iterations and the control template implicit representation difference. This cost comprehensively reflects the learning progress and effect of the model in the iteration process, and provides an important basis for subsequent training decisions. In the actual application of the cloud computing server for intelligent cloud archive storage in power plants, by accurately calculating the implicit representation debugging cost and adjusting the training strategy in time, the accuracy and efficiency of the model can be further improved, thereby better supporting the operation and maintenance management of power plants.

[0170] In a possible implementation, in step S200B, after completing the ath core text index model of the ath round of iterative optimization, performing iterative optimization on the bth template implicit representation bigram obtained by the bth round of iterative optimization to obtain the ath template implicit representation bigram, the method further includes:

[0171] Step S200B1: inputting the implicit representation of the ath control template core text item in the ath template implicit representation tuple into the ath dense network component to obtain the ath core text item inference distribution paragraph.

[0172] Step S200B1 further processes the template implicit representation using a dense network component to predict the possible position of the core text item in the text. In the cloud computing server, after completing the a-th round of iterative optimization, a set of optimized template implicit representation tuples will be obtained, which include the a-th template text implicit representation and the a-th reference template core text item implicit representation. Step S200C1 focuses on processing the a-th reference template core text item implicit representation in this tuple. This implicit representation is a high-dimensional vector that captures the characteristics of the reference template core text item in the implicit space. However, this vector itself does not directly provide the specific location information of the core text item in the original text. In order to obtain this information, the cloud computing server inputs this implicit representation into a dense network component. A dense network component (dense layer) is a fully connected neural network layer in which each neuron is connected to all neurons in the previous layer. In this scenario, the dense network component receives the a-th reference template core text item implicit representation as input and extracts deeper features through a series of nonlinear transformations (such as activation functions) and linear combinations.

[0173] After being processed by the dense network component, the output is no longer a simple vector, but a paragraph of reasoning distribution that represents the possible positions of the core text item in the text. This distribution paragraph may be given in the form of a probability distribution, where each position (such as a word or phrase in the text) corresponds to a probability value, indicating the likelihood of the position being a core text item.

[0174] For example, suppose that a power plant operation log describes a fault condition of a generator set, in which "the temperature of the generator is too high and has been automatically shut down" is a core text item. In step S200C1, the cloud computing server inputs the implicit representation corresponding to this core text item into the dense network component. After processing, the output is, for example, a probability distribution indicating that the two phrases "the temperature of the generator is too high" and "has been automatically shut down" have a high probability of being recognized as part of the core text item in the text.

[0175] The key to this process is that the dense network component can automatically extract the location features of key information from complex text data by learning the mapping relationship between the input implicit representation and the location of the core text items. This capability is crucial for the power plant intelligent cloud archive storage cloud computing server, because it allows the cloud computing server to quickly locate and extract key content in the operation log, providing strong support for subsequent fault analysis, performance evaluation and other tasks.

[0176] Step S200B2: Calculate the inferred distribution paragraphs of the a-th core text item and the core text item prior distribution paragraphs in the u-th operation log text template to obtain the inferred difference amount of the a-th core text item.

[0177] In the cloud computing server, after the processing of step S200B1, the inference distribution paragraph of the a-th core text item has been obtained, which is a probability distribution representing the possible position of the core text item in the text. At the same time, for the u-th operation log text template, the prior distribution paragraph of its core text item has been determined in advance based on domain knowledge or manual annotation, that is, the real or expected position of the core text item in the actual text.

[0178] The core task of step S200B2 is to compare the differences between the two distribution paragraphs to quantitatively evaluate the accuracy of the model prediction. To achieve this goal, the cloud computing server uses a suitable metric to calculate the difference between the two distributions, that is, the inference difference of the a-th core text item. In practical applications, there are a variety of metrics to choose from, such as Kullback-Leibler divergence (KL divergence), Jensen-Shannon divergence, cross entropy, etc. Here, KL divergence is used as an example for explanation, because KL divergence is a common method to measure the difference between two probability distributions P and Q, and is particularly suitable for evaluating the difference between the model predicted distribution and the true distribution.

[0179] The calculation formula of KL divergence is:

[0180]

[0181] Where X is the set of all possible events or positions, P(x) is the probability of position x in the inference distribution paragraph of the a-th core text item, and Q(x) is the probability of position x in the prior distribution paragraph of the core text item in the u-th running log text template.

[0182] Assume that there is a running log text template describing a certain fault process of a generator set, in which "generator bearing temperature is too high" is a core text item. Through step S200C1, the cloud computing server has given the inference distribution of the possible positions of this core text item in the text. At the same time, based on domain knowledge or expert annotation, it is known that in the actual text, the statement "generator bearing temperature is too high" does exist and is located at a specific position in the text.

[0183] In step S200B2, the cloud computing server will use KL divergence (or other suitable metrics) to calculate the difference between the inference distribution and the prior distribution. The smaller the difference, the more accurate the model's prediction; conversely, the larger the difference, the greater the deviation between the model's prediction and the actual situation. By calculating this difference, the cloud computing server can monitor the model's prediction performance for the core text item position in real time and make adjustments as needed during the iterative optimization process. This is of great significance for improving the accuracy and efficiency of power plant operation log analysis.

[0184] Step S200B3: Fusing the inference differences of the first a core text items to obtain the inference debugging cost value of the ath core text item.

[0185] In the cloud computing server, after the calculation of step S200B2, the core text item reasoning difference amount in each round of the previous a rounds of iterations has been obtained. These difference amounts quantify the difference between the core text item position distribution predicted by the model and the true or prior position distribution in each round of iteration. The task of step S200C3 is to fuse these difference amounts to obtain a comprehensive evaluation indicator-the a-th core text item reasoning debugging cost value. The fusion process usually involves some form of aggregation or weighted averaging of the difference amounts. The specific way of aggregation depends on the nature of the difference amount and the evaluation target. In practical applications, common aggregation methods include arithmetic mean, weighted mean, geometric mean, etc. In the scenario of intelligent cloud archive storage in power plants, the significance of this step is to provide a quantifiable monitoring indicator for the iterative optimization process of the model. By comparing the core text item reasoning debugging cost values ​​in different iteration rounds, the cloud computing server can evaluate the convergence trend and stability of the model for the prediction of the core text item position. If the debugging cost value gradually decreases and tends to be stable with the increase of iteration rounds, it means that the prediction performance of the model is gradually improving and becoming mature; on the contrary, if the debugging cost value fluctuates greatly or continues to increase, it may be necessary to adjust the training strategy or optimization algorithm of the model. For example, suppose that an operation log of a power plant describes the fault handling process of a certain generator set, which contains multiple key core text items (such as fault phenomenon, handling measures, etc.). During the iterative optimization process of the model, the cloud computing server will gradually learn the position characteristics of these core text items in the text, and calculate the inference difference in each round of iteration through step S200B2. Then, in step S200B3, these differences are merged into a debugging cost value to evaluate the prediction performance of the current model. If the debugging cost value is small, it means that the model can accurately predict the position of the core text item; if the debugging cost value is large, it means that the model needs further learning and optimization.

[0186] Step S200B4: Fusing the a-th implicit representation debugging cost value and the a-th core text item reasoning debugging cost value to obtain the a-th target cost value.

[0187] In the cloud computing server, after the calculations in the aforementioned steps, the ath implicit representation debugging cost value and the ath core text item reasoning debugging cost value have been obtained respectively. The implicit representation debugging cost value reflects the degree of optimization of the implicit representation of the text by the model during the iteration process, while the core text item reasoning debugging cost value measures the accuracy of the model's prediction of the core text item position. These two cost values ​​evaluate the performance of the model from different dimensions. The task of step S200B4 is to fuse these two cost values ​​to obtain a more comprehensive evaluation indicator - the ath target cost value. The fusion process usually involves some form of aggregation or weighted averaging of the two cost values, and the specific method of aggregation depends on the evaluation objectives and actual needs.

[0188] Taking weighted average as an example, assuming that the ath implicit representation debugging cost is C implicita , the inference debugging cost of the a-th core text item is C positiona , and the weights assigned to these two cost values ​​are α and 1-α (the value range of α is between 0 and 1), then the a-th target cost value C targeta It can be calculated by the following formula:

[0189]

[0190] In this formula, the setting of the weight α depends on the relative importance of implicit representation optimization and core text item position prediction accuracy in the evaluation objectives. If the optimization of implicit representation is considered more important, α can be set to a larger value; conversely, if the prediction accuracy of the core text item position is more important, α can be set to a smaller value. In the scenario of intelligent cloud archive storage in power plants, the target cost value provides a comprehensive indicator for evaluating model performance for cloud computing servers. By comparing the target cost values ​​in different iteration rounds, the cloud computing server can intuitively understand the overall optimization trend of the model during the iteration process. If the target cost value gradually decreases with the increase of iteration rounds, it means that the model is constantly improving in both implicit representation optimization and core text item position prediction; conversely, if the target cost value fluctuates greatly or continues to increase, it may be necessary to deeply analyze the cause and adjust the optimization strategy. For example, suppose that an operation log of a power plant records in detail the discovery, diagnosis and handling process of a certain equipment failure. During the iterative optimization process of the core text index model, the cloud computing server gradually improved the implicit representation optimization degree and core text item position prediction accuracy of this log. Through the calculation in step S200B4, the cloud computing server obtains the target cost value of each iteration. If the target cost value shows a clear downward trend as the iteration proceeds, it can be determined that the model is gradually approaching the optimal solution, providing more reliable technical support for the operation log analysis of the power plant.

[0191] Step S200B5: If the a-th target cost value cannot meet the cost threshold, then update the weights and biases in the a-th core text index model and the a-th dense network component to obtain the a+1-th core text index model and the a+1-th dense network component; complete the a+1-th round of iterative optimization in the a+1-th core text index model, and obtain the a+1-th core text item inference distribution paragraph in the a+1-th dense network component.

[0192] In the cloud computing server, after the calculation of step S200B4, the ath target cost value has been obtained, which comprehensively evaluates the performance of the model in two aspects: implicit representation optimization and core text item position prediction. Step S200B5 will first compare this target cost value with the preset cost threshold. The cost threshold is a standard set according to actual needs, which is used to determine whether the performance of the current model has reached a satisfactory level. If the ath target cost value is greater than the cost threshold (that is, the performance of the model has not yet reached the preset standard), then the cloud computing server will decide to continue optimizing the model.

[0193] The specific process of optimization includes updating the weights and biases in the a core text index model and the a dense network component. These two components are key parts of the model, and their parameters determine the model's predictive ability and generalization performance. Through the back-propagation algorithm (a common neural network training method), the cloud computing server adjusts these parameters based on the difference between the current model's predicted results and the actual results, in the hope of achieving better performance in the next round of iterations.

[0194] After the parameter update is completed, the cloud computing server obtains the a+1th core text index model and the a+1th dense network component. These two new models inherit the optimization results in the previous round of iterations and are further adjusted on this basis. Subsequently, the cloud computing server will continue to perform the iterative optimization process in the a+1th core text index model, that is, enter the a+1th iteration. In this round of iterations, the a+1th dense network component will receive the new template implicit representation as input and generate the a+1th core text item inference distribution paragraph, that is, the possible position of the predicted core text item in the text.

[0195] For example, suppose that an operation log of a power plant records in detail an abnormal condition of the generator set and its handling process. During the iterative optimization process of the core text index model, if the target cost value after the a-th iteration is still higher than the cost threshold, it means that the current model is still insufficient in extracting key information and predicting the location of core text items. At this time, the cloud computing server will start a new round of iterative optimization to improve the performance of the model by adjusting the parameters of the core text index model and dense network components. In the a+1-th iteration, the updated model will try again to extract key information from the operation log and predict the location of core text items in the hope of obtaining more accurate results.

[0196] This process will be repeated until the target cost value is lower than the cost threshold. At this point, it can be considered that the performance of the model has reached the preset standard, and the iterative optimization can be stopped and the model can be applied to the actual power plant intelligent cloud archive storage cloud computing server.

[0197] Step S200B6: If the a-th target cost value satisfies the cost threshold, determining the a-th round of iterative optimization to be the p-th round of iterative optimization.

[0198] In the cloud computing server, after the decision-making process of step S200C5, if the ath target cost value meets the preset cost threshold, it means that the performance of the current model in terms of implicit representation optimization and core text item position prediction has reached a satisfactory level, and no more iterative optimization is required. At this time, step S200C6 is triggered, and the cloud computing server will determine that the ath round of iterative optimization is the last round of the entire iterative process, that is, the pth round of iterative optimization. Here p is a pre-set upper limit of the number of iterations, but in the actual execution process, the model may not need to reach this upper limit to meet the performance requirements. By setting the cost threshold, the cloud computing server can terminate the iteration in advance when the model performance meets the standard, thereby saving computing resources and accelerating the training process.

[0199] For example, suppose a power plant is using a cloud computing-based intelligent cloud archive storage cloud computing server to manage its operation logs. These logs contain a large amount of critical data such as equipment status information, operation records, and possible fault reports. In order to quickly extract useful information from this massive amount of data, the power plant uses a core text indexing model to automatically identify and index key text items.

[0200] During the iterative optimization process of the model, the cloud computing server improves its performance by continuously adjusting the model parameters. As the iteration proceeds, the optimization degree of the model for the implicit representation of the text and the prediction accuracy of the core text item position gradually increase, resulting in a continuous decrease in the target cost value. When the target cost value after the a-th iteration is lower than the preset cost threshold for the first time, the cloud computing server determines that the model has met the standard according to the decision logic of step S200C6, and therefore determines that the a-th iteration is the final p-th iteration optimization.

[0201] At this point, the cloud computing server will save the parameters and status of the current model and use it in subsequent text analysis and indexing tasks. Since the model has been fully trained and optimized, it can accurately and efficiently process the operation log data of the power plant and provide timely and accurate information support for operation and maintenance personnel. At the same time, due to the timely termination of the iterative process, the cloud computing server also avoids unnecessary waste of computing resources and improves overall efficiency and economic benefits.

[0202] Based on Figure 1 Based on the same principle as the method shown in , the present application also provides an intelligent cloud archive storage device 10 for a power plant based on cloud computing, such as Figure 2 As shown, the device 10 comprises:

[0203] The log text acquisition module 11 is used to acquire the operation log text of the power plant operation status uploaded by at least one intelligent terminal device of the target power plant to form the operation log text to be analyzed;

[0204] An implicit representation extraction module 12, configured to extract an implicit representation of a target text from the to-be-analyzed operation log text, wherein the to-be-analyzed operation log text includes content of interest;

[0205] The core feature determination module 13 is used to iteratively optimize the implicit representation of the target text and the implicit representation of the control core text item obtained by any assignment startup based on the core text index model to obtain the target core text item implicit representation of the content of interest, wherein the target core text item implicit representation represents the implicit representation of the core text item detected and obtained in the content of interest contained in the operation log text to be analyzed;

[0206] Wherein, the core text index model is obtained by performing p rounds of iterative optimization on each running log text template according to the initialized core text index model, and in the ath core text index model that completes the ath round of iterative optimization, the implicit representation bigram of the bth template obtained by the bth round of iterative optimization is iteratively optimized to obtain the ath template implicit representation bigram, and the weights and biases in the ath core text index model are updated according to the implicit representation error between the bth template implicit representation bigram and the ath template implicit representation bigram, and the process stops when the preset stopping requirements are met, wherein 1≤a≤p, b=a-1, the ath template implicit representation bigram includes the ath template text implicit representation and the ath reference template core text item implicit representation, the ath template text implicit representation is obtained by performing a round of iterative optimization on the initial template text implicit representation extracted from the running log text template, and the ath reference template core text item implicit representation is obtained by performing a round of iterative optimization on the initial reference template core text item implicit representation obtained by starting with arbitrary assignment;

[0207] The log text storage module 14 is used to determine the text paragraph where the core text item in the content of interest exists in the run log text to be analyzed based on the implicit representation of the target core text item, mark the core text item, obtain the marked run log text, and store the marked run log text.

[0208] The above embodiment introduces the intelligent cloud archive storage device 10 of the power plant based on cloud computing from the perspective of the virtual module. The following introduces a cloud computing server from the perspective of the physical module, as shown below: The embodiment of the present application provides a cloud computing server, such as Figure 3 As shown, the cloud computing server 100 includes: a processor 101 and a memory 103. The processor 101 and the memory 103 are connected, such as through a bus 102. Optionally, the cloud computing server 100 may also include a transceiver 104. It should be noted that in actual applications, the transceiver 104 is not limited to one, and the structure of the cloud computing server 100 does not constitute a limitation on the embodiments of the present application.

[0209] The cloud computing server provided in the embodiment of the present application includes: one or more processors; a memory; one or more computer programs, wherein the one or more computer programs are stored in the memory and configured to be executed by the one or more processors, and when the one or more programs are executed by the processor, the above-mentioned intelligent cloud archive storage method for the power plant based on cloud computing is implemented.

[0210] An embodiment of the present application further provides a computer-readable storage medium on which a computer program is stored. When the computer program runs on a processor, the processor can execute corresponding contents in the aforementioned method embodiment.

[0211] It should be understood that although the various steps in the flowchart of the accompanying drawings are displayed in sequence as indicated by the arrows, the above is only a partial implementation method of the present application. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principle of the present application. These improvements and modifications should also be regarded as the scope of protection of the present application.

Claims

1. An intelligent cloud archive storage method for a power plant based on cloud computing, characterized in that: Applied to a cloud computing server, the method comprises: Acquire a power plant operation status operation log text uploaded by at least one intelligent terminal device of the target power plant to form an operation log text to be analyzed; Extracting an implicit representation of a target text from the to-be-analyzed operation log text, wherein the to-be-analyzed operation log text includes content of interest; Iteratively optimizing the target text implicit representation and the control core text item implicit representation obtained by arbitrary assignment based on the core text index model to obtain the target core text item implicit representation of the content of interest, wherein the target core text item implicit representation represents the implicit representation of the core text item detected and obtained in the content of interest contained in the operation log text to be analyzed; Wherein, the core text index model is obtained by performing p rounds of iterative optimization on each running log text template according to the initialized core text index model, and in the ath core text index model that completes the ath round of iterative optimization, the implicit representation bigram of the bth template obtained by the bth round of iterative optimization is iteratively optimized to obtain the ath template implicit representation bigram, and the weights and biases in the ath core text index model are updated according to the implicit representation error between the bth template implicit representation bigram and the ath template implicit representation bigram, and the process stops when the preset stopping requirements are met, wherein 1≤a≤p, b=a-1, the ath template implicit representation bigram includes the ath template text implicit representation and the ath reference template core text item implicit representation, the ath template text implicit representation is obtained by performing a round of iterative optimization on the initial template text implicit representation extracted from the running log text template, and the ath reference template core text item implicit representation is obtained by performing a round of iterative optimization on the initial reference template core text item implicit representation obtained by starting with arbitrary assignment; Based on the implicit representation of the target core text item, determine the text paragraph where the core text item in the content of interest exists in the run log text to be analyzed, mark the core text item to obtain marked run log text, and store the marked run log text.

2. The method according to claim 1, characterized in that The step of iteratively optimizing the implicit representation of the target text and the implicit representation of the control core text item obtained by any assignment start based on the core text index model to obtain the implicit representation of the target core text item of the content of interest includes: The following process is completed in the core text index model: Loading the obtained x-th target text implicit representation and x-th comparison core text item implicit representation output by the x-th iterative optimization component in the core text index model into the x+1-th iterative optimization component in the core text index model, wherein the core text index model includes t iterative optimization components, 1≤x≤t; In the x+1th iterative optimization component, the xth target text implicit representation and the xth comparison core text item implicit representation are iteratively optimized to obtain the x+1th target text implicit representation and the x+1th comparison core text item implicit representation; When x+1=t, the x+1th reference core text item implicit representation is used as the target core text item implicit representation; When x+1<t, the obtained x+1th target text implicit representation and the x+1th control core text item implicit representation are loaded into the x+2th iterative optimization component to perform the x+2th iterative optimization.

3. The method according to claim 2, characterized in that In the x+1th iterative optimization component, the xth target text implicit representation and the xth comparison core text item implicit representation are iteratively optimized to obtain the x+1th target text implicit representation and the x+1th comparison core text item implicit representation, including: The following process is completed in the x+1th iterative optimization component: In the first iterative optimization module of the x+1th iterative optimization component, linear mapping is performed on the log text sub-implicit representation output by the xth iterative optimization component to obtain the first log text sub-implicit representation; linear mapping is performed on the control core text item sub-implicit representation output by the xth iterative optimization component to obtain the first control core text item sub-implicit representation; In the e-th iterative optimization module of the x+1-th iterative optimization component, the f-th log text sub-implicit representation and the f-th comparison core text item sub-implicit representation output by the f-th iterative optimization module of the x+1-th iterative optimization component are loaded into the e-th iterative optimization module in the x+1-th iterative optimization component, wherein 2≤e, f=e-1; In the e-th iterative optimization module, linear mapping is performed on the f-th log text sub-implicit representation to obtain a first mapping feature vector, and the first mapping feature vector is used as the e-th log text sub-implicit representation output by the e-th iterative optimization module; and linear mapping is performed on the f-th control core text item sub-implicit representation to obtain a second mapping feature vector; based on the first mapping feature vector and the second mapping feature vector, the e-th control core text item sub-implicit representation output by the e-th iterative optimization module is obtained; In the case that the e-th iterative optimization module is the last iterative optimization module in the x+1-th iterative optimization component, the e-th log text sub-implicit representation is used as the x+1-th target text implicit representation obtained by executing the x+1-th iterative optimization component, and the e-th control core text item sub-implicit representation is used as the x+1-th control core text item implicit representation obtained by executing the x+1-th iterative optimization component.

4. The method according to claim 1, characterized in that Before extracting the implicit representation of the target text from the to-be-analyzed operation log text, the method further includes an initialization step of a core text index model, including: Extract the initial template text implicit representation from the obtained u-th running log text template, and obtain the initial comparison template core text item implicit representation obtained by any assignment start, 1≤u≤q; The following process is completed cyclically for the implicit representation of the initial template text and the implicit representation of the initial comparison template core text item, and the optimization stops when p rounds of iteration are reached: In the ath core text index model that has completed the ath round of iterative optimization, iterative optimization is completed on the bth template implicit representation bigram obtained by the bth round of iterative optimization to obtain the ath template implicit representation bigram, when a is equal to 1, the bth template implicit representation bigram obtained by the bth round of iterative optimization represents the initial template implicit representation bigram, and the initial template implicit representation bigram includes the initial template text implicit representation and the initial comparison template core text item implicit representation; Determining a template implicit representation difference amount between the b-th template implicit representation bigram and the a-th template implicit representation bigram according to an implicit representation error between the b-th template implicit representation bigram and the a-th template implicit representation bigram; The implicit representation differences of the first a templates are fused to obtain the ath implicit representation debugging cost value; If the implicit representation debugging cost value determined according to the implicit representation difference amounts of all templates obtained after the previous a rounds of iterative optimization cannot meet the cost threshold, then the weights and biases in the a-th core text index model are updated to obtain the a+1-th core text index model; Completing the a+1th round of iterative optimization in the a+1th core text index model; If the implicit representation debugging cost value determined based on all template implicit representation differences obtained after the previous a rounds of iterative optimization meets the cost threshold, the a-th round of iterative optimization is determined to be the p-th round of iterative optimization.

5. The method according to claim 4, characterized in that The step of determining the template implicit representation difference amount between the b-th template implicit representation binary and the a-th template implicit representation binary according to the implicit representation error between the b-th template implicit representation binary and the a-th template implicit representation binary comprises: Determine the difference between the implicit representation of the b-th template text in the b-th template implicit representation binary and the implicit representation of the a-th template text in the a-th template implicit representation binary to obtain the difference of the b-th template implicit representation; The difference between the implicit representation of the bth control template core text item in the bth template implicit representation tuple and the implicit representation of the ath control template core text item in the ath template implicit representation tuple is determined to obtain the difference of the bth control template implicit representation.

6. The method according to claim 5, characterized in that The step of fusing the first a template implicit representation differences to obtain the ath implicit representation debugging cost value includes: The previous a template implicit representation differences are merged to obtain the template implicit representation debugging cost value, and the previous a reference template implicit representation differences are merged to obtain the reference implicit representation debugging cost value; The template implicit representation debugging cost value and the reference implicit representation debugging cost value are merged to obtain the ath implicit representation debugging cost value.

7. The method according to claim 4, characterized in that In the ath core text index model that has completed the ath round of iterative optimization, after completing iterative optimization on the bth template implicit representation bigram obtained by the bth round of iterative optimization and obtaining the ath template implicit representation bigram, the method further includes: Input the implicit representation of the ath control template core text item in the ath template implicit representation tuple into the ath dense network component to obtain the ath core text item inference distribution paragraph; Calculating the inferred distribution paragraph of the a-th core text item and the prior distribution paragraph of the core text item in the u-th running log text template to obtain the inferred difference amount of the a-th core text item; The inference differences of the first a core text items are integrated to obtain the inference debugging cost value of the a-th core text item; The ath implicit representation debugging cost value and the ath core text item reasoning debugging cost value are merged to obtain the ath target cost value; If the a-th target cost value cannot meet the cost threshold, the weights and biases in the a-th core text index model and the a-th dense network component are updated to obtain the a+1-th core text index model and the a+1-th dense network component; the a+1-th round of iterative optimization is completed in the a+1-th core text index model, and the a+1-th core text item reasoning distribution paragraph is obtained in the a+1-th dense network component; If the a-th target cost value satisfies the cost threshold, the a-th round of iterative optimization is determined to be the p-th round of iterative optimization.

8. An intelligent cloud archive storage device for a power plant based on cloud computing, characterized in that: The method comprises: A log text acquisition module, used to acquire the operation log text of the power plant operation status uploaded by at least one intelligent terminal device of the target power plant to form the operation log text to be analyzed; An implicit representation extraction module, used to extract an implicit representation of a target text from the operation log text to be analyzed, wherein the operation log text to be analyzed includes content of interest; A core feature determination module, for iteratively optimizing the implicit representation of the target text and the implicit representation of the control core text item obtained by any assignment start based on the core text index model, to obtain the implicit representation of the target core text item of the content of interest, wherein the implicit representation of the target core text item represents the implicit representation of the core text item detected and obtained in the content of interest contained in the operation log text to be analyzed; Wherein, the core text index model is obtained by performing p rounds of iterative optimization on each running log text template according to the initialized core text index model, and in the ath core text index model that completes the ath round of iterative optimization, the implicit representation bigram of the bth template obtained by the bth round of iterative optimization is iteratively optimized to obtain the ath template implicit representation bigram, and the weights and biases in the ath core text index model are updated according to the implicit representation error between the bth template implicit representation bigram and the ath template implicit representation bigram, and the process stops when the preset stopping requirements are met, wherein 1≤a≤p, b=a-1, the ath template implicit representation bigram includes the ath template text implicit representation and the ath reference template core text item implicit representation, the ath template text implicit representation is obtained by performing a round of iterative optimization on the initial template text implicit representation extracted from the running log text template, and the ath reference template core text item implicit representation is obtained by performing a round of iterative optimization on the initial reference template core text item implicit representation obtained by starting with arbitrary assignment; The log text storage module is used to determine the text paragraph where the core text item in the content of interest exists in the run log text to be analyzed based on the implicit representation of the target core text item, mark the core text item, obtain the marked run log text, and store the marked run log text.

9. A cloud computing server, characterized in that: include: one or more processors; Memory; one or more computer programs; The one or more computer programs are stored in the memory and configured to be executed by the one or more processors, and when the one or more computer programs are executed by the processors, the method according to any one of claims 1 to 7 is implemented.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, and when the computer program runs on a processor, the processor can execute the method according to any one of claims 1 to 7.

Images