Small sample class increment non-analytic indicator diagram fault diagnosis system based on serialization and contrast learning and diagnosis method of small sample class increment non-analytic indicator diagram fault diagnosis system

Abstract

The invention provides a small sample class increment non-analytic indicator diagram fault diagnosis method based on serialization and comparative learning. The method comprises the following steps of non-analytic indicator diagram serialization; comparative learning pre-training; carrying out incremental learning on small sample classes; performing fault diagnosis; the invention further provides a small sample class increment non-analytic indicator diagram fault diagnosis system based on serialization and comparative learning, wherein the method is applied to the small sample class increment non-analytic indicator diagram fault diagnosis system. According to the small sample class increment non-analytic indicator diagram fault diagnosis system based on serialization and comparative learning and the diagnosis method thereof, the information density of the non-analytic indicator diagram is improved through a serialization method, and efficient and stable dynamic fault diagnosis is achieved in combination with comparative learning pre-training, a lightweight adapter, sample replay and an NME classifier.

Description

Technical Field

[0001] This invention belongs to the field of industrial fault diagnosis technology, specifically relating to a small-sample incremental non-analytical dynamometer diagram fault diagnosis model based on serialization and contrastive learning. It is particularly suitable for efficient utilization of small samples of non-analytical dynamometer diagrams and incremental learning of dynamic fault categories in fault diagnosis of oil pumping well conditions. Background Technology

[0002] Dynamometer diagrams of pumping units are crucial tools for describing their operational status, and analyzing their morphological characteristics can effectively diagnose various typical faults. However, in practical engineering, a large amount of historical dynamometer diagram data is stored only in image format, lacking original displacement-load data; these are called non-analytical dynamometer diagrams. These images contain a large number of invalid pixels and redundant information, which not only increases the storage and computational burden but also interferes with the model's effective extraction of key features.

[0003] Existing dynamometer fault diagnosis methods are mostly based on raw displacement-load data or complete image data. When processing non-analytical dynamometer diagrams, there are three limitations: First, the raw sequence data cannot be used; second, directly inputting the image into the deep learning network leads to a waste of computational resources and is prone to overfitting; third, manual feature design is highly subjective and has low information retention.

[0004] Furthermore, practical fault diagnosis faces two major challenges: on the one hand, obtaining samples for certain fault types is difficult and the labeling cost is high, resulting in extremely limited training data; on the other hand, the types of faults dynamically increase with changing operating conditions, requiring models to continuously learn new categories without forgetting previously learned knowledge. Traditional deep learning models, after being trained on fixed datasets, struggle to adapt to scenarios with scarce data and dynamically growing categories, and are prone to "catastrophic forgetting," meaning that the recognition performance of old categories drops sharply after learning new categories.

[0005] Existing incremental learning methods for few-shot classes, such as TOPIC (TOpology-Preserving knowledge Incrementer), iCaRL (incremental classifier and representation learning), and DER (Dynamically Expandable Representation), have alleviated the forgetting problem to some extent. However, in non-analytical dynamometer scenarios, they still suffer from problems such as insufficient feature extraction, poor classifier adaptability, and parameter redundancy, resulting in low diagnostic accuracy and insufficient stability.

[0006] Purpose of the invention

[0007] The purpose of this invention is to provide a few-sample incremental non-analytical dynamometer diagram fault diagnosis model based on serialization and contrastive learning, which solves the problems of feature redundancy, catastrophic forgetting, and low diagnostic accuracy in existing methods in non-analytical dynamometer diagram processing and few-sample incremental learning. Summary of the Invention

[0008] To achieve the above objectives, this invention provides a small-sample incremental non-analytical dynamometer diagram fault diagnosis system and method based on serialization and contrastive learning.

[0009] This invention discloses a few-sample incremental non-analytical dynamometer diagram fault diagnosis system based on sequence-based and contrastive learning, comprising:

[0010] The serialization module is used to convert non-analytical dynamometer diagrams into one-dimensional sequences;

[0011] The contrastive learning pre-training module is used to pre-train and freeze parameters on the base class training set to obtain a general feature representation;

[0012] The adapter module adopts an inverted pyramid residual architecture to fine-tune parameters in incremental tasks;

[0013] The replay module is used to store and manage the example set, and selects representative samples based on herding;

[0014] The NME classifier is used for classification based on the distance from the feature vector to the class mean.

[0015] This system implements a few-sample incremental non-analytical dynamometer diagram fault diagnosis method based on sequence-based and contrastive learning. The method includes the following steps:

[0016] (1) Non-analytical dynamometer map serialization: The non-analytical dynamometer map is preprocessed to remove background noise and redundant pixels, and the upper and lower contour points are extracted and sorted by the horizontal coordinate to form a one-dimensional sequence, thereby achieving data compression and effective feature preservation.

[0017] (2) Contrastive learning pre-training: The contrastive learning module is pre-trained using the base class training set. Multi-scale contextual representations of sequence data are captured through hierarchical contrastive learning. After pre-training, the module parameters are frozen to obtain general feature representations.

[0018] (3) Small sample incremental learning: In the incremental stage, a small sample set of new fault categories is introduced. Combined with a lightweight adapter and sample replay mechanism, the adapter parameters are fine-tuned. At the same time, the NME classifier is used for fault classification to alleviate catastrophic forgetting and improve diagnostic accuracy.

[0019] (4) Fault diagnosis: For the input non-analytical indicator diagram, after serialization, the feature vector is obtained through the feature extraction link, and finally the fault category is output by the NME classifier.

[0020] Preferably, the non-analytical dynamometer image serialization specifically includes: inputting the preprocessed image and extracting the foreground pixel set; for each horizontal coordinate, taking the minimum and maximum vertical coordinates as the upper and lower boundary points; sorting the upper boundary points in ascending order and the lower boundary points in descending order; concatenating the upper and lower boundary point sequences and normalizing the coordinates; zero-padding to a uniform maximum length and outputting a one-dimensional sequence; wherein, the serialization compresses the image data from approximately 10^5 pixels to the order of 10^3, reducing the data volume by 99.4%.

[0021] Preferably, in the contrastive learning pre-training, the contrastive learning module includes an input projection layer, a dilated convolutional block, and an output convolutional block; during pre-training, a context is generated by random pruning, positive and negative sample pairs are set using context consistency, and the loss function includes index contrastive loss and instance contrastive loss, with the overall loss being the sum of the hierarchical contrastive losses, used to learn a general representation of sequence data.

[0022] Preferably, the lightweight adapter employs a convolutional module with an inverse pyramid residual architecture, including an initial convolutional layer and multiple inverse pyramid residual blocks;

[0023] The adapter is trainable in both base and incremental tasks. It maps the general features extracted by the frozen contrastive learning module to task-specific features, with the number of channels decreasing sequentially. Finally, it outputs the features to be classified through global average pooling.

[0024] Preferably, the sample replay mechanism is based on the herding-first example selection method, which selects representative examples from the old class of fault data and stores them in the example set;

[0025] Example formula selection:

[0026]

[0027] p k This represents the currently selected sample, k represents the sample number, and X is the set of training samples for this class. This represents the feature vector of the sample, and μ is the mean of the feature vectors of the training samples of this class; during incremental training, the loss of the new sample and the loss of the example set are optimized simultaneously.

[0028] Preferably, the NME classifier uses normalized feature vectors, and the classification principle is as follows:

[0029]

[0030] μ y The example mean vector for each category is obtained by averaging the feature vectors of the example set belonging to that category; the NME classifier avoids category conflicts in the parameterized classification layer and supports lossless expansion.

[0031] Preferably, during the incremental phase t, there is a training set. Where n t This represents the total number of samples in the training set at stage t. As a training sample, the corresponding label is And when t≠t′ In the learning of incremental phase t, only the training dataset of the current phase can be used. Update the model, and simultaneously test on all known classes. The above assesses their learning ability; if f(x; θ) and Let the classification model and classification loss represent the classification model and classification loss, respectively. Then the overall class increment learning objective can be expressed as:

[0032]

[0033] Preferably, the method is applied to the diagnosis of non-analytical dynamometer diagram faults in pumping wells, and the fault categories include multiple types such as normal operating conditions, liquid hammer, gas interference, gas lock, slow closing of traveling valve, pump barrel splitting, traveling valve leakage, tubing leakage, pump jamming, insufficient fluid supply, coupling rod breakage, and plunger detachment from the pump barrel.

[0034] Compared with related technologies, the present invention provides a small-sample incremental non-analytical dynamometer diagram fault diagnosis system and method based on sequence-based and contrastive learning, which has the following beneficial effects:

[0035] By using a serialization method, non-analytical dynamometer diagrams are transformed into one-dimensional sequences, reducing the data volume by 99.4%, significantly reducing storage and computational overhead, while retaining effective fault characteristics.

[0036] By employing contrastive learning pre-training and freezing parameters, stable and universal feature representations are obtained, providing a high starting point for incremental learning with few samples. Combining a lightweight adapter and a sample replay mechanism effectively mitigates catastrophic forgetting and improves model adaptability and stability. Using an NME classifier instead of a parameterized classification layer avoids class conflicts and supports lossless expansion. Experimental results on the sequential non-analytical dynamometer diagram dataset for oil wells show that the proposed model, with improvements to the CLIFS-Net backbone and classifier compared to the contrastive method, achieves an average improvement in diagnostic accuracy of 2.39% and 4.23%, respectively, validating the advancement of each component. In particular, CLIFS-Net, integrating the advantages of both, achieves an average diagnostic accuracy of 92.72%, significantly higher than the overall mean of 87.94% for the contrastive method and its improved backbone and classifier. CLIFS-Net also achieves the best diagnostic accuracy of 99.82% on the CWRU bearing fault dataset, with a standard deviation of only 0.41, validating the high diagnostic accuracy and stability of the proposed incremental non-analytical dynamometer diagram fault diagnosis model based on sequential and contrastive learning. Attached Figure Description

[0037] Figure 1 A schematic diagram of the preprocessing flow for non-analytical indicator diagrams;

[0038] Figure 2 This is a visualization of the non-analytical indicator diagram serialization result;

[0039] Figure 3 This is a comparison chart of the diagnostic performance of images and serialized data under various models;

[0040] Figure 4 This is a schematic diagram of a small sample incremental task scenario;

[0041] Figure 5 It is a diagram illustrating the method for contrastive learning of positive and negative sample pairs;

[0042] Figure 6 Here are the structure diagrams of representation learning neural networks: (a) contrastive learning module structure; (b) adapter module structure;

[0043] Figure 7 This is a CLIFS-Net diagnostic workflow framework diagram;

[0044] Figure 8 These are examples of non-analytical indicator diagrams for twelve different operating conditions;

[0045] Figure 9 A comparison of the number of parameters between the CLIFS-Net backbone and mainstream feature extraction backbones.

[0046] Figure 10 This is a histogram of the model's average accuracy on a serialized non-analytical dynamometer dataset;

[0047] Figure 11 It is a line graph of model stage accuracy on a serialized non-analytical dynamometer dataset;

[0048] Figure 12 This is a comparison chart of high-performance models on a serialized non-analytical dynamometer dataset;

[0049] Figure 13 It is the confusion matrix of CLIFS-Net for incremental diagnosis on the serialized non-analytical dynamometer dataset;

[0050] Figure 14 This is a visualization of t-SNE features for incremental diagnosis using CLIFS-Net on a serialized non-analytical dynamometer dataset;

[0051] Figure 15 This is a bar chart of the average accuracy of the model on the CWRU bearing fault dataset;

[0052] Figure 16 This is a line graph showing the model stage accuracy on the CWRU bearing dataset;

[0053] Figure 17 This is a comparison chart of high-performance models of CLIFS-Net on the CWRU bearing fault dataset;

[0054] Figure 18 This is a visualization of t-SNE features for incremental diagnosis using CLIFS-Net on the CWRU bearing dataset. Detailed Implementation

[0055] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0056] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0057] The present invention will now be described in detail with reference to the accompanying drawings and specific embodiments.

[0058] This invention discloses a small-sample incremental non-analytical dynamometer fault diagnosis method based on sequence-based and contrastive learning, characterized by the following steps:

[0059] Non-analytical dynamometer image serialization: The non-analytical dynamometer image is preprocessed to remove background noise and redundant pixels, and the upper and lower contour points are extracted and sorted by the horizontal coordinate to form a one-dimensional sequence, thereby achieving data compression and effective feature preservation.

[0060] Non-analytical indicator diagram serialization methods include:

[0061] 1.1 Non-analytical indicator diagram and its preprocessing

[0062] The dynamometer card (DDC) of a pumping unit well is an important tool for describing the production status of a pumping unit well. It originates from the surface dynamic monitoring system of the pumping unit well. Sensors installed on the walking beam, connecting rod, and other parts of the pumping unit well measure the load and displacement of the sucker rod during production. The data collected by the sensors is transmitted to the surface monitoring system via a data acquisition device, and after processing, a dynamometer card is generated. The dynamometer card presents the load change curve of the sucker rod during a complete working cycle (up and down stroke), reflecting the mechanical and hydraulic state of the pumping unit well throughout its entire working cycle. Therefore, fault diagnosis using the dynamometer card of a pumping unit well can improve production efficiency, reduce equipment damage, and enhance safety, making it of great significance in oilfield production management.

[0063] Non-analytical dynamometer diagrams are prevalent in oil extraction and oilfield digitization. Firstly, these images are commonly found in data archiving methods in less digitized oilfields, where raw dynamometer results are often preserved in paper or scanned form, lacking numerical sequence storage. Secondly, some dynamometer instruments have significant limitations in equipment compatibility and data interfaces, making it difficult to export raw data; the only accessible form is usually an image. Furthermore, in some project processes and technical reports, dynamometer diagrams are often presented graphically without accompanying numerical support. For example, some studies have used neural networks for operational condition diagnosis using image-based dynamometer diagrams, but the original displacement-load data were not disclosed. Moreover, although modern oilfield monitoring systems can collect and archive raw sequence data in real time, a large amount of historical data is still stored only as images, especially in the initial stages of sample database construction and production and maintenance records. In the complex data system of digital oilfield construction, image-based dynamometer diagrams are easier to display, transmit, and archive than raw sequences, further contributing to the widespread use of non-analytical dynamometer diagrams.

[0064] When diagnosticians cannot directly obtain the original displacement-load data and can only acquire its image, i.e., the non-analytical dynamometer card, direct processing results in a large amount of data redundancy and invalid features. To address these issues, this study converts the two-dimensional redundant data into a one-dimensional sequence, retaining only the effective information related to the line relationships, thus achieving data purification. Serialization is a crucial bridge connecting the non-analytical dynamometer card and the sequential fault diagnosis model. Through algorithms, pixel information is sorted according to a continuous process, transforming the static image into a dynamic cyclic sequence, providing a reasonable input structure for the subsequent sequence model.

[0065] Non-analytical indicator maps contain a large amount of background noise and redundant pixels. First, background subtraction or grayscale thresholding is used to remove the background. Then, morphological operations (dilation, erosion) or Gaussian blur are applied to smooth the image, filling in breaks and holes, forming closed curves, and binarizing them to finally obtain clean indicator map lines, such as... Figure 1 As shown.

[0066] 1.2 Serialization Algorithm

[0067] The serialization method extracts upper and lower contour points from the preprocessed image, sorts them by their horizontal coordinates, and normalizes them to form a one-dimensional sequence. The specific steps are as follows:

[0068] Input preprocessed image;

[0069] Extract the foreground pixel set;

[0070] For each x-coordinate, take the minimum and maximum y-coordinates as the upper and lower boundary points;

[0071] Sort the upper boundary points in ascending order of their x-coordinates, and sort the lower boundary points in descending order of their x-coordinates.

[0072] Concatenate the upper and lower boundary point sequences and normalize the coordinates;

[0073] Zero-padding to a uniform maximum length, output sequence.

[0074] This process compresses image data from approximately 10^5 pixels to a sequence on the order of 10^3, reducing the data volume by 99.4%, while preserving key geometric features, such as... Figure 2 As shown.

[0075] 1.3 Serialization effect verification

[0076] Based on the aforementioned non-analytical dynamometer image serialization principle, a comparison of fault diagnosis was performed on the original image data and the corresponding serialized data on a relatively balanced base class dataset of serialized non-analytical dynamometer image fault dataset (see Section 3.1). The experiment constructed two groups: the first group input the original image into various classic two-dimensional convolutional neural network models (VGG16, ResNet18, MobileNetV3-S) for diagnosis; the second group input the serialized reconstructed image into one-dimensional convolutional neural networks and their hybrid models (VGG16-1D, CNN-BiGRU, CNN-BiGRU-Attention) for diagnostic analysis. In CNN-BiGRU, the input signal is first processed through a three-layer one-dimensional convolutional structure for local feature extraction. Each layer includes convolution, ELU activation, Dropout (p=0.3), max pooling, and batch normalization operations, with the number of channels increasing to 16, 32, and 64 respectively. The feature sequence is then input into two layers of BiGRU for context modeling, with 128 and 64 hidden units respectively. CNN-BiGRU-Attention incorporates an attention mechanism to weight and aggregate bidirectional outputs, ultimately outputting the classification result through a fully connected layer.

[0077] The comparison results of fault diagnosis between the original image and the data after corresponding serialization methods are as follows: Figure 3As shown, in terms of data volume, the image input is serialized and reconstructed, achieving a reduction rate of up to 99.4%, significantly reducing the complexity and storage overhead of subsequent calculations. Regarding accuracy, serialization is not only an efficient preprocessing technique, but by selecting suitable models, such as a deep neural network architecture that integrates temporal feature extraction and context awareness (CNN-BiGRU-Attention), it can achieve accuracy approximately equal to or even exceeding that of directly processing the original image. Therefore, the serialization method proposed in this paper achieves efficient data compression and seamless integration with downstream analysis tools by accurately removing redundant pixels. Compared to original image processing, it significantly reduces the data size while maintaining roughly the same diagnostic accuracy, and has overwhelming advantages in storage efficiency and computational speed. This method is an ideal bridge for effectively connecting image-based dynamometer maps and sequential fault diagnosis models.

[0078] (2) Contrastive learning pre-training: The contrastive learning module is pre-trained using the base class training set. Multi-scale contextual representations of sequence data are captured through hierarchical contrastive learning. After pre-training, the module parameters are frozen to obtain general feature representations.

[0079] (3) Small sample incremental learning: In the incremental stage, a small sample set of new fault categories is introduced. Combined with a lightweight adapter and sample replay mechanism, the adapter parameters are fine-tuned. At the same time, the NME classifier is used for fault classification to alleviate catastrophic forgetting and improve diagnostic accuracy.

[0080] Fault diagnosis based on serialized non-analytical indicator diagrams using few-sample incremental learning includes the following steps:

[0081] 2.1 Incremental Learning by Category and Incremental Learning by Fewer Samples

[0082] In class incremental learning (CIL) scenarios, data changes dynamically. Learning new tasks can overwrite the parameters of older tasks, leading to a loss of the ability to identify older classes—a phenomenon known as catastrophic forgetting. An ideal class incremental learning model should, like a human, learn a series of continuously arriving new classes sequentially, thereby continuously enhancing its discriminative ability. After training is completed sequentially, it needs to be evaluated on all trained classes, meaning that it learns new class knowledge without forgetting old class knowledge. However, this process is always accompanied by a stability-plasticity dilemma, reflecting the contradiction between stability and plasticity. Stability means that the neural network should retain its learned knowledge and resist changes caused by new data; conversely, plasticity means that the network should be able to adapt to new inputs or tasks. A highly stable model may not be able to effectively learn new tasks or data, while a highly plastic model may quickly lose information about previously learned tasks or data. Therefore, an excellent class incremental learning model needs to strike a balance between these two aspects during the learning process.

[0083] Research methods on incremental class learning can be broadly categorized into data-level methods, parameter-level methods, and algorithm-level methods. Data-level methods include two subtypes: data replay and data restriction. These primarily utilize example sets to augment the training set and constrain the model update process using example samples. Parameter-level methods include two types: parameter regularization and dynamic architecture. These mainly constrain the model based on parameter importance and dynamically adjust the network structure / number of parameters. Algorithm-level methods can be divided into two types: knowledge distillation and lag adjustment. These primarily design effective learning paradigms to maintain model knowledge and discover and adjust the preferences of incremental class learning models during training. While these three methods differ in their approaches, they all share the common characteristic of retaining as much old class knowledge as possible when learning new tasks to avoid catastrophic forgetting.

[0084] In terms of form, at the incremental stage t, there is a training set Where n t This represents the total number of samples in the training set at stage t. As a training sample, the corresponding label is And when t≠t′ like Figure 4 As shown, in the learning of class incremental stage t, only the training dataset of the current stage can be used. Update the model, and simultaneously test on all known classes. The above assesses their learning ability; if f(x; θ) and Let the classification model and classification loss represent the classification model and classification loss, respectively. Then the overall class increment learning objective can be expressed as:

[0085]

[0086] In small-sample incremental learning scenarios With sufficient training samples, in the subsequent incremental phase, each class has only a small number of samples, i.e., when t>0. Set to N-way K-shot mode (containing N classes, with only K data points per class). Few-shot incremental learning faces both the stability-plasticity dilemma and unreliable empirical risk minimization. Empirical risk minimization (ERM) aims to optimize the average loss of the training data. This strategy works well in large-scale data environments where there are enough samples to ensure statistical consistency during training. In few-shot scenarios, the limited number of training samples may not fully represent the true distribution of the entire data, causing the ERM function to fail to accurately approximate the optimal expected risk minimization function, resulting in poor generalization performance of the trained model. In addition to the above challenges, the imbalance between the base class samples and the new class samples also makes it difficult for the model to learn new classes.

[0087] 2.2 Fault Diagnosis of CLIFS-Net Incremental Learning for Few Sample Classes

[0088] 2.2.1 Representation Learning Neural Networks

[0089] CLIFS-Net employs a pre-trained sequence representation module based on hierarchical contrastive learning and context enhancement, pre-trained and frozen on a base class. This module can learn contextual representations of any subsequence in sequence data at different semantic levels, learning stable cross-task general feature representations for incremental scenarios, while providing a powerful, high-starting-point feature extractor for small-sample scenarios. A hierarchical contrastive approach is used on the instance and index (sequence index, corresponding to timestamps in a time series) dimensions to capture multi-scale contextual information, and contextual consistency is used to define positive and negative sample pairs.

[0090] During the pre-training phase, a context is generated by applying random pruning to the input fault sequence. The specific operation of random pruning is as follows: For example, given the input fault sequence x... i ∈R K×F Randomly sample two overlapping sequence indices [a1, b1], [a2, b2] such that 0 <a1≤b1≤a2≤b2≤K。 Figure 5To facilitate contrastive learning, a positive / negative sample pairing method is employed. As shown in the figure, context consistency treats representations of the same index from two views of the input fault sequence as positive samples, while representations from different indices of the same fault sequence are treated as negative samples. Let i be the sample number of the input fault sequence, and k be the position index within the sequence. i,k and r′ i,k They represent from x i The representation of the same index k is enhanced by two additional representations. The contrastive loss of the i-th sequence at index k. As shown in equation (2):

[0091]

[0092] Where Ω is the set of indices of the overlapping portion of the two subsequences. It is an indicator function.

[0093] Example comparison loss As shown in equation (3), the representations of other fault sequences at index k in the same batch are used as negative samples, where B represents the batch size:

[0094]

[0095] Total loss As shown in equation (4):

[0096]

[0097] Where α is the scaling factor, N is the number of instances in the training set, and K is the index of a single sequence. In the hierarchical comparison operation, max pooling is performed on the corresponding index to obtain a deeper representation. The comparison loss is calculated for each layer and summed to achieve the goal of fully capturing the contextual information of the fault sequence data at multiple resolutions.

[0098] Figure 6 (a) shows the structure of the contrastive learning module, which includes an Input projection layer, a DilatedConvBlock, and an OutputConvBlock. The Input projection layer is a fully connected layer that projects the input x... i,t Mapping to a high-dimensional latent vector z i,t The hidden dimension is 64. DilatedConvBlock contains two identical dilated convolutional layers, maintaining the hidden dimension (DilatedConv1d) at 64 channels. For the l-th block, the dilation parameter is 2. lOutputConvBlock transforms the dimension to an output dimension of 128. Its structure is such that residual connections in DilatedConvBlock are replaced with 1×1 convolutional layer connections, used to adjust the number of channels across layers. These dilated convolutional neural networks are used to extract the contextual representation at each index.

[0099] The entire contrastive learning module is pre-trained on the base class and then frozen to obtain a general representation across incremental tasks. During subsequent incremental learning, the model already possesses the ability to understand the basic structure and dynamics of sequences, and further fine-tuning only requires task-specific adaptation based on this foundation. When the amount of data for new tasks is limited (small-sample incremental learning), pre-trained features with rich contextual information are crucial. Based on these powerful general features, the model can effectively learn patterns for new tasks using fewer new samples and better associate them with existing knowledge (stored in parameters learned before the feature extractor), reducing the risk of forgetting.

[0100] Following the contrastive learning network, an inverted pyramid residual architecture convolutional module is used as an adapter. This adapter learns how to map the general features extracted by the frozen module into feature representations more suitable for distinguishing the current task, such as... Figure 6 (b) shows the structure of the adapter. It operates in a parameter-trainable mode for both base and incremental tasks. Its core design is that as the network depth increases, the number of feature channels and the length of the index dimension gradually decrease. This structure takes high-dimensional temporal features extracted by the pre-trained model through contrastive learning. After adjusting the initial convolutional layer while keeping the number of channels constant, it then uses three stages of inverse pyramid residual blocks (ConvBlock) to refine downsampled features with the number of channels being 64, 32, and 16 respectively. Finally, global average pooling is used to compress the index dimension and output the features to be classified.

[0101] 2.2.2 Replay Mechanism and NME Classification

[0102] When the training samples are severely unevenly distributed, i.e., the base class has a large number of samples and the increment class has a very small number of samples, the classification rule of a parameterized classifier such as a linear classifier is: Weight vector ω and feature extraction process Separation can easily lead to catastrophic forgetting and tends to favor classes with large sample sizes. The NME classifier naturally mitigates this bias by comparing the distance of samples to the class mean. The herding design can provide the NME classifier with class instance center information under small sample budgets, and also make the NME classifier more robust when feature representations are updated because the prototype automatically adjusts with the representation.

[0103] The herding-based priority example selection and replay method's core lies in selecting representative examples from old class failure data for incremental training. When Z classes have been observed, and K is the total number of storable examples, each class uses m = K / Z examples with a truncation method to ensure that the available memory budget of K examples is always fully utilized and not exceeded. Examples p1,…,p are iteratively selected and stored. m Until the target number m is reached, in each iteration step, a sample from the current training set is added to the example set, as shown in equation (5):

[0104]

[0105] p k This represents the currently selected sample, k represents the sample number, and X is the set of training samples for this class. Let μ represent the feature vector of the sample, and let μ be the mean of the feature vectors of the training samples of this class. The calculation method is shown in equation (6):

[0106]

[0107] In other words, the sample selected for inclusion in the example set is one whose average feature vector, along with the already stored sample, is closest to the average feature vector of all training samples of that class. This method implies a storage order for the example set: samples closer to μ are added first. This order plays a crucial role in example set management. When a new class sample is added to the example set, to maintain a fixed total number of examples, old class examples need to be discarded: if the number of examples decreases from m′ to m, then example p is discarded. m+1 ,…,p m′ The retained examples approximate the class mean vector well. When learning a new class, the model simultaneously optimizes the new sample loss and the example set loss, as shown in Equation (7):

[0108]

[0109] Let X be the adapter loss function. y To add a training set for new fault types, P y x is the set of instances of the old classes. i For the fault sample, y i For sample x i The corresponding actual fault type, The Kronecker function takes the value 1 when the constraints are met, and 0 otherwise. y (x i ) is x i The prediction results after inputting the data into the model.

[0110] After the feature extractor processes the input samples to obtain feature vectors, the NME classifier comes into play (ensuring consistency of distance metrics and using normalized feature vectors). Its classification principle is shown in equation (8):

[0111]

[0112] μ y The example mean vector for each category is obtained by averaging the feature vectors of the example set belonging to that category.

[0113] 2.2.3 CLIFS-Net Diagnostic Framework and Process

[0114] Combining 1.2, 2.2.1, and 2.2.2, the CLIFS-Net diagnostic process proposed in this invention includes an initial model learning part and an incremental learning part, the framework of which is as follows: Figure 7 As shown, the diagnostic steps are as follows:

[0115] Step 1: Obtaining the Fault Dataset. The non-analytical dynamometer diagram fault dataset is processed using the dynamometer diagram serialization algorithm described in Section 1.2 to obtain a serialized dynamometer diagram fault dataset, which serves as the input dataset for the model. t is the sequence number of the incremental task.

[0116] Step 2: Pre-training and Basic Tasks. Collect data containing C... base Training set of base classes for each fault category Using base class data pass Optimize the comparative learning module The parameter θ is used to freeze the parameters of this module after training. The training dataset for learning the basic task Task0 is... use pass Training adapter A linear temporary classification head is used during computation. The example set is determined by equation (5) to provide replay data for subsequent tasks. During testing, the base class test set data is used. Through the entire feature extraction chain The NME classifier is then used to obtain the fault prediction category.

[0117] Step 3: Training with few-sample incremental learning tasks. The model learns incremental learning tasks t, t>0, sequentially, introducing a new set of fault categories. and its corresponding small sample set n incre It is very small. The training dataset for this task is... in Replay the data for the example set corresponding to this task, and update it synchronously using Equation (5). pass Training adapter A linear temporary classification head is used during computation. During testing, the test set... Through the entire feature extraction chain The NME classifier is then used to obtain the fault prediction category.

[0118] (4) Fault diagnosis: For the input non-analytical indicator diagram, after serialization, the feature vector is obtained through the feature extraction link, and finally the fault category is output by the NME classifier.

[0119] Small-sample incremental fault diagnosis experiments include:

[0120] 3.1 Description and Experimental Setup of Serialized Non-Analytical Dysfunction Diagram Fault Dataset

[0121] Figure 8 The 12 categories of non-analytical indicator diagrams shown include Normal Operation, Tubing Leak, Stuck Pump, Insufficient Fluid Supply, Rod Break at Coupling, Plunger Disengagement from Pump Barrel, Traveling Valve Leakage, Pump Barrel Split, Tardy Traveling Valve Closure, Fluid Pound, Gas Interference, and Gas Locking. After preprocessing and serialization using the method described in Section 1.2, the sample distribution of the serialized non-analytical indicator diagram fault dataset is shown in Table 1.

[0122] Table 1: Serialized Non-Analytical Dysfunction Diagram Fault Dataset in Incremental Scenarios with Small Sample Sizes

[0123]

[0124] Nine popular incremental learning methods are introduced and compared with the proposed method CLIFS-Net: Replay (see Section 2.2.2), BiC (bias Correction), DER (Dynamically Expandable Representation), iCaRL (incremental classifier and representation learning), PODNet (Pooled Outputs Distillation), ACIL (Analytic Class-Incremental Learning with Absolute), COIL (Co-Transport for Class-Incremental Learning), and Foster (Feature Boosting and Compression for Class-Incremental Learning). Among them, Replay alleviates forgetting by saving and replaying some historical samples; BiC uses linear bias parameters to reduce bias in incremental learning; DER uses dynamic feature expansion to learn new categories; iCaRL combines model distillation, replay, and example nearest neighbor classifiers, and is a classic class incremental method; PODNet uses distillation loss in the spatial dimension and multiple class proxy vectors to effectively mitigate catastrophic forgetting; ACIL proposes an "absolute memory" framework and a classification method that solves directly; COIL proposes cooperative transport to realize the transfer of knowledge between old and new categories; and FOSTER efficiently supports class incremental learning by dynamically adding modules and then distilling to compress redundant parameters. In the comparative experiments, the representation network proposed in this invention is compared before and after the modification of each method, the classifier introduced in this invention is compared before and after the modification of each method except ACIL, and a comparison is made with CLIFS-Net to verify its module advancement and overall advancement. The experimental environment is PyTorch 1.11.0, and the GPU used is NVIDIA RTX3090.

[0125] Table 2: Parameter settings for CLIFS-Net and baseline methods

[0126]

[0127] To fully evaluate the small-sample incremental learning diagnostic performance of each model, this invention introduces four evaluation metrics: stage accuracy (as shown in Equation 9), average accuracy (as shown in Equation 10), standard deviation (as shown in Equation 11), and final task decay rate (as shown in Equation 12).

[0128]

[0129] Where A t It is the accuracy of the incremental stage t, R t M is the number of test samples in the incremental phase t in which the model correctly diagnoses. t It is the total number of test samples for model diagnosis in the incremental stage t. Let σ represent the average accuracy across all incremental stages, T be the final stage number, and σ be the standard deviation.

[0130] 3.2 Incremental Diagnostic Assessment of Small Sample Classes in Serialized Dysfunction Diagram Fault Dataset

[0131] 3.2.1 Comparative Experiment Fault Diagnosis and Evaluation

[0132] Table 3 compares the incremental diagnostic performance of small sample classes on the serialized non-analytical dynamometer diagram fault dataset. The "CL" suffix indicates that the CLIFS-Net representation learning part is used as the backbone network; the absence of the "CL" suffix indicates that the algorithm uses a one-dimensional ResNet18-1D as the backbone. "FC" indicates that a standard linear classifier is used during inference, and "NME" indicates that the nearest example mean classifier is used during inference. For ACIL classification, an analytical solution is used. CLIFS-Net can be understood as a combination of CL-replay-NME.

[0133] Table 3 shows the results for all methods in the table when using the NME classifier. The metrics, when optimized using CL (Clear Flow) optimization, show an average improvement of 2.39% compared to the method without CL optimization. Figure 9 The CL backbone network shown has 0.39M parameters, while the ResNet18-1D has 3.85M parameters, verifying that the CL backbone network provides a high-discriminative feature space for the classifier while maintaining a relatively low parameter count. Furthermore, the NME classifier mechanism exhibits stronger robustness in long-term incremental tasks, such as... Figure 10 The table shows all methods except ACIL when using the NME classifier. The performance index (90.05%) outperformed the FC classifier. 4.23 percentage points, while... Figure 11 The CLIFS-Net shown in Figure A t The performance metrics remained consistently above 91% in later task phases 4-5, outperforming its own fully connected (FC) classifier. Finally, CLIFS-Net demonstrated exceptional stability during class incrementing, with a σ of only 1.04, significantly lower than other methods. In contrast, such as Figure 12In the high-precision performance region shown, the high accuracy and low task decay rate of the DER algorithm and its CL optimization demonstrate the effectiveness of the dynamic architecture, but the ever-increasing parameter cost limits its practicality. The FOSTER algorithm and its CL optimization also perform well, but compressing the representations learned by the extended branches back into the backbone also leads to significant computational resource consumption. Therefore, the CLIFS-Net proposed in this invention efficiently achieves a balance between stability and discriminative power in incremental learning with few samples through a collaborative mechanism of contrastive learning backbone representation freezing plus task adaptation, dynamic sample replay, and parameterless classifiers.

[0134] Table 3: Comparison of incremental diagnostic performance for small sample classes in serialized non-analytical dynamometer diagram fault datasets (classification accuracy %)

[0135]

[0136] Figure 13 The confusion matrix for CLIFS-Net's diagnostic results across various tasks on the serialized non-analytical dynamometer fault dataset shows that the accuracy decreased from 94.29% for seven categories to 91.08% for twelve categories, a drop of only 3.21%. The initial seven categories maintained an average accuracy of 93.2% across the final twelve categories (with a maximum decrease of only 3%), while the average accuracy for the newly added categories reached 94.2%, effectively mitigating catastrophic forgetting and effectively learning new classes. The overall architecture achieves an optimal balance between feature stability and task adaptability.

[0137] Using t-SNE feature visualization test set data, features were extracted from the link and before the classifier using CLIFS-Net, such as... Figure 14 As shown, the old clusters have a lower deformation rate, while the newly added yellow clusters form relatively independent clusters, confirming that the features maintain high structural stability during the incremental process. This demonstrates the structural stability and dynamic expansion capability of the proposed CLIFS-Net in feature extraction during the incremental process.

[0138] 3.2.2 Ablation Experiment Fault Diagnosis and Assessment

[0139] To verify the contributions of each component of CLIFS-Net, this experiment demonstrates variants of the contrastive learning module and incremental strategy, and evaluates the performance degradation, as shown in Table 4, where w / o Eliminated w / o Eliminated w / o RandomCropping eliminates random cropping, w / o Input Projection Layer removes the input projection layer, w TimestampMasking uses the Bernoulli distribution mask commonly used in sequence models during training, w / o replay eliminates the replay strategy, i.e., fine-tuning after using the CLIFS-Net backbone.

[0140] Table 4 shows the ablation experimental results on the serialized non-analytical dynamometer diagram fault dataset.

[0141]

[0142] Remove This resulted in a sharp drop in average accuracy of 5.27%, demonstrating its core value for incremental learning. However, the addition of wTimestamp Masking caused the loss of some crucial information, leading to a further drop in accuracy to 88.71%. The lack of a replay strategy caused the adapter to lose its balance between tasks, resulting in a catastrophic collapse.

[0143] 3.3 Description and Experimental Setup of CWRU Bearing Fault Dataset

[0144] The CLIFS-Net proposed in this invention was tested on the Case Western Reserve University bearing failure dataset

[54] . The bearing model was a deep groove ball bearing SKF6205, which was manufactured by electrical discharge machining with a single point of failure. This invention selected drive end data at 12 kHz and a speed of 1797 r / min for 10 classifications. There were 3 types of defect locations in the diagnosed bearing, including rolling element damage, outer ring damage, and inner ring damage. The damage diameter of each defect location included 0.007 inch, 0.014 inch, and 0.021 inch. There were a total of 9 fault states and 1 normal state, for a total of 10 bearing states. Among them, class 0 is the normal bearing state, and classes 1 to 9 are the fault bearing states. The data was limited to 119,808 data points. The training sample data was sequentially truncated using the sliding window method. The sample length was set to 1024, and the overlap rate was 50%. The obtained sample data were allocated to the training set and test set according to the ratio of 8:2 for each class. To create a small sample environment, classes 0 to 4 were set as the basic classes, and the original number and ratio of samples in the training and test sets remained unchanged. Classes 5 to 9 were set as small sample incremental classes. The number of samples in each class in the training set was randomly retained to 10, and the number of samples in the test set remained unchanged. The specific experimental sample data are shown in Table 5.

[0145] Table 5 shows the CWRU bearing fault dataset under incremental scenarios with a small sample size.

[0146]

[0147] During the pre-training phase of contrastive learning, the contrastive learning representation module was trained for 10 epochs on the base class training set with an initial learning rate of 0.001 and a batch size of 16. In this case, α is set to 1, that is To achieve better performance, the Adam optimizer was used during incremental learning training. The learning rates for the base class and incremental class were fixed at 0.1 and decayed by a factor of 10 at epochs 10 / 30 / 40. The batch size was set to 128, the training epochs were 50, and the number of samples stored in the sample library was 60 (considering the maximum number of samples achievable with a small sample size for the incremental class). The parameter settings of the comparison method were the same as those in the experiment on the serialized non-analytical dynamometer diagram fault dataset.

[0148] 3.4 Incremental Diagnostic Evaluation of Small Sample Classes in the CWRU Bearing Fault Dataset

[0149] 3.4.1 Comparative Test Fault Diagnosis and Assessment

[0150] Table 6 presents a performance comparison of various methods on the CWRU bearing fault dataset in a few-sample incremental learning scenario. It can be seen that the CL method with an improved backbone network significantly outperforms its basic version, such as... Figure 15 As shown, CLIFS-Net performs well on FC and NME. All metrics are significantly higher than the basic Replay method, and DER(CL) outperforms the basic DER method in the later incremental stage. For example... Figure 16 As shown, this advantage is particularly pronounced in the later stages of incremental learning, demonstrating that the feature space optimized by CL has stronger geometric stability, laying a robust foundation for incremental classification. Secondly, the NME classifier exhibits superior and more stable performance than the FC classifier in the vast majority of methods. The Replay and DER methods using the NME classifier... The performance metrics are significantly higher than those of the FC classifier, highlighting the inherent robustness of the prototype-based classification mechanism when handling small sample increments and adding new classes. When using the NME classifier, iCaRL(CL) essentially adds adapter distillation to the method of this invention. The superposition of contrastive learning representation of frozen parameters, replay, and distillation leads to an imbalance in the stability-plasticity dilemma, resulting in a lower average accuracy than the method of this invention, demonstrating that distillation affects the model's learning performance. Figure 17 The results show the comparison of high-performance models using incremental learning for small sample classes on the CWRU bearing fault dataset. It can be seen that the CLIFS-Net proposed in this invention achieves the best performance, and the final task decay rate is only 1.09.

[0151] Table 6: Comparison of incremental diagnostic performance for small sample classes in the CWRU bearing fault dataset (classification accuracy %)

[0152]

[0153] Figure 18 This paper showcases the features of the CWRU bearing fault dataset test set data after feature extraction via CLIFS-Net. The results demonstrate a highly cohesive, loosely coupled cluster distribution throughout the incremental task, providing intuitive proof of the module's representational capabilities. Newly added categories autonomously form independent clusters, and the dynamic expansion of the feature space does not erode the regions of older categories. The old category clusters exhibit excellent morphological stability. New categories demonstrate efficient adaptation and structured scalability when entering the feature space.

[0154] 3.4.2 Ablation Experiment Fault Diagnosis and Assessment

[0155] Table 7 shows the ablation experiment results of CLIFS-Net on the CWRU bearing fault dataset, where w Added That is, α is set to 0.5, and it can be seen that using and Extremely high accuracy can still be achieved. The results after eliminating random pruning demonstrate that it significantly improves the model's generalization ability. And the replay strategy remains the key mechanism for adjusting the adapter to adapt to the task.

[0156] Table 7 shows the ablation experiment results on the CWRU bearing fault dataset.

[0157]

[0158]

Claims

1. A small sample class incremental non-analytical indicator diagram fault diagnosis method based on serialization and contrast learning, characterized by, The method comprises the following steps: (1) Non-resolved indicator diagram serialization: the non-resolved indicator diagram is preprocessed to remove background noise and redundant pixels, the upper and lower contour points are extracted and sorted by horizontal coordinates to form a one-dimensional sequence, data compression and effective feature retention are realized; (2) Contrastive learning pre-training: the contrastive learning module is pre-trained using the base class training set, the multi-scale context representation of the sequence data is captured through hierarchical contrastive learning, and the module parameters are frozen after pre-training to obtain a general feature representation; (3) Small sample class incremental learning: in the incremental stage, a small sample set of new fault categories is introduced, a lightweight adapter and a sample replay mechanism are combined to fine-tune the adapter parameters, and an NME classifier is used for fault classification to alleviate catastrophic forgetting and improve diagnostic accuracy; (4) Fault diagnosis: for the input non-resolved indicator diagram, the feature vector is obtained through the feature extraction link after serialization, and finally the fault category is output by the NME classifier.

2. The small sample class incremental non-resolution indicator diagram fault diagnosis method based on serialization and contrast learning according to claim 1, characterized in that, The non-resolved indicator diagram serialization specifically comprises: inputting the preprocessed image, extracting the foreground pixel point set; for each horizontal coordinate, taking the minimum and maximum vertical coordinates as the upper and lower boundary points; sorting the upper boundary points in ascending order of horizontal coordinates and the lower boundary points in descending order; concatenating the upper and lower boundary point sequences and normalizing the coordinates; zero padding to a unified maximum length, and outputting a one-dimensional sequence; wherein the image data is compressed from about 10^5 pixels to 10^3 orders of magnitude through serialization, and the data volume is reduced by 99.4%.

3. The small sample class incremental non-resolution indicator diagram fault diagnosis method based on serialization and contrast learning according to claim 1, characterized in that, In the contrastive learning pre-training, the contrastive learning module comprises an input projection layer, an expansion convolution block and an output convolution block; during pre-training, the context is generated by random cropping, the positive and negative sample pairs are set according to the context consistency, the loss function comprises index contrastive loss and instance contrastive loss, the total loss is the sum of hierarchical contrastive losses, and the general representation of the sequence data is learned.

4. The small sample class incremental non-resolution indicator diagram fault diagnosis method based on serialization and contrast learning according to claim 1, characterized in that, The lightweight adapter adopts a convolution module with a reverse pyramid residual architecture, comprising an initial convolution layer and a plurality of reverse pyramid residual blocks; The adapter is trainable in the base class task and the incremental task, and is used to map the general features extracted by the frozen contrastive learning module to task-specific features, and the channel number is reduced in turn, and finally the classification features are output through global average pooling.

5. The small sample class-incremental non-parametric indicator diagram fault diagnosis method based on sequential and contrastive learning according to claim 1, characterized in that, The sample replay mechanism is based on the herding priority example selection method, and representative examples are selected from the old class fault data and stored in the example set; The example selection formula is: p k represents the current selected sample, k represents the number of the current sample, X is the set of training samples of this class, represents the feature vector of the sample, μ is the mean of the feature vectors of the training samples of this class; during incremental training, the new sample loss and the example set loss are simultaneously optimized.

6. The small sample class-incremental non-parametric indicator diagram fault diagnosis method based on sequential and contrastive learning according to claim 1, characterized in that, The NME classifier uses a normalized feature vector, and the classification principle is: μ y The mean vector for each class is computed by averaging the sample feature vectors of the examples belonging to that class; the NME classifier avoids the class conflict of parameterized classification layers and supports lossless expansion.

7. The small sample class-incremental non-parametric indicator diagram fault diagnosis method based on sequential and contrastive learning according to claim 1, characterized in that, During the incremental phase t, there is a training set Where n t This represents the total number of samples in the training set at stage t. As a training sample, the corresponding label is And when t≠t′ In the learning of incremental phase t, only the training dataset of the current phase can be used. Update the model, and simultaneously test on all known classes. The above assesses their learning ability; if f(x; θ) and Let the classification model and classification loss represent the classification model and classification loss, respectively. Then the overall class increment learning objective can be expressed as:

8. The small sample class-incremental non-parametric indicator diagram fault diagnosis method based on sequential and contrastive learning according to claim 1, characterized in that, The method is applied to the non-resolved indicator diagram fault diagnosis of pumping unit wells, and the fault categories include normal working conditions, liquid beating, gas interference, gas locking, slow closing of the traveling valve, pump cylinder splitting, traveling valve leakage, oil pipe leakage, pump sticking, insufficient liquid supply, coupling rod breaking, and plunger disengaging from the pump cylinder.

9. A small sample class incremental non-resolution indicator diagram fault diagnosis system based on serialization and contrast learning, characterized by, It comprises: a serialization module for converting a non-resolved indicator diagram into a one-dimensional sequence; a contrastive learning pre-training module for pre-training on a base class training set and freezing parameters to obtain a general feature representation; an adapter module adopting a reverse pyramid residual architecture and fine-tuning parameters in an incremental task; a replay module for storing and managing an example set based on herding to select representative samples; an NME classifier for classifying based on the distance of the feature vector to the class mean; wherein the system performs the method of any of claims 1 to 8.

Images