Wavelet-Based Optimization and Numerical Computing for Fault Detection Method—Signal Fault Localization and Classification Algorithm

Abstract

This study focuses on the development of the WONC-FD (Wavelet-Based Optimization and Numerical Computing for Fault Detection) algorithm for the accurate detection and categorization of faults in signals using wavelet analysis augmented with numerical methods. Fault detection is a key problem in areas related to seismic activity analysis, vibration assessment of industrial equipment, structural integrity control, and electrical grid reliability. In the proposed methodology, wavelet transform serves to accurately localize anomalies in the data, and optimization techniques are introduced to refine the classification based on minimizing the error function. This not only improves the accuracy of fault identification but also provides a better understanding of its nature.

1. Introduction

In this paper, we consider an algorithm for the localization and classification of faults in a signal based on wavelet analysis and numerical methods: WONC-FD (Wavelet-Based Optimization and Numerical Computing for Fault Detection). Fault detection is an important problem in seismic signal processing [1,2,3,4], vibration analysis in industrial equipment [5,6,7,8,9], and structural and electrical network monitoring [10,11,12]. This approach uses wavelet transform to localize faults in the signal for subsequent classification using optimization techniques through minimization of the target error function.

This study focuses on the development of the WONC-FD (Wavelet-Based Optimization and Numerical Computing for Fault Detection) algorithm for the accurate detection and categorization of faults in signals using wavelet analysis augmented with numerical methods. Fault detection is a key problem in areas related to seismic activity analysis, vibration assessment of industrial equipment, structural integrity control, and electrical grid reliability. In the proposed methodology, wavelet transform serves to accurately localize anomalies in the data, and optimization techniques are introduced to refine the classification based on minimizing the error function. This not only improves the accuracy of fault identification but also provides a better understanding of their nature. The development of an algorithm based on wavelet analysis and additional mathematical methods will be an important step in the development of signal processing theory and fault diagnosis methods. This approach will increase the accuracy and sensitivity of fault detection, which are critical for ensuring the reliability and safety of electrical systems. The solution of the designated scientific problem has practical and theoretical potential. Effective fault diagnosis allows one to promptly identify and eliminate problems, minimizing the risk of accidents and equipment damage.

The developed algorithm can be adapted for use in various industries where the stable operation of electrical devices is important, such as industry, energy, transportation, and household appliances. This will minimize risks and ensure the more reliable operation of electrical systems, which is an urgent task in modern industry. Modern requirements for the quality of the maintenance and operation of electrical systems entail more accurate and reliable diagnostic methods, and the developed algorithm fully meets these requirements, contributing to their satisfaction. The current state of research on fault diagnosis in electrical circuits demonstrates significant progress in the development of signal processing and machine learning techniques. However, existing methods often face limitations in accuracy and sensitivity, especially when detecting complex and immediate faults. Traditional methods such as Fourier transform do not provide detailed time–frequency analysis of signals, making it difficult to detect minor changes in signals.

In this regard, the search for new and more effective diagnostic methods becomes one of the key tasks of modern science and engineering. One of the most promising directions in the field of signal processing is the use of wavelet transform [13,14,15,16,17]. Wavelet analysis allows for detailed time–frequency analysis of signals, which makes it particularly attractive for diagnosing failures in electrical circuits. Many studies on the application of wavelet transform in various fields, including medical diagnosis, audio signal processing, and data analysis, confirm its effectiveness and flexibility. In particular, wavelet transform can detect small and complex changes in signals, which is critical for fault diagnosis in electrical circuits. Examples of the use of wavelet transform in fault diagnosis are in the works [18,19,20,21], where the authors apply wavelet analysis to detect faults in electrical networks. Wavelet transform can identify anomalies in voltage and current signals, which improves the diagnostic accuracy. The studies [22,23,24,25] examine the application of wavelet transform combined with machine learning techniques to classify types of faults in electrical circuits. The authors show that the combined approach significantly improves the accuracy and sensitivity of the diagnosis.

The main research directions in world science in the field of failure diagnosis include the following:

• Developing new signal processing algorithms: Researchers are actively working on developing algorithms that combine wavelet transform with other signal processing techniques, such as filtering and machine learning. These combined approaches can improve the accuracy and sensitivity of diagnostics. For example, in [26], the authors propose a new algorithm that combines wavelet transform with an LSTM-based neural network architecture to predict faults in electrical circuits.
• Machine Learning Applications: Machine learning techniques such as neural networks [27,28,29,30] and random forests are used to classify failure types based on analyzing the time–frequency characteristics of signals. These methods are able to automatically train on large amounts of data and identify different types of failures with high accuracy. In [31], the authors use neural networks to diagnose faults in electrical circuits, showing a significant improvement in accuracy over traditional methods.
• Integration with modern technologies: Modern technologies such as the Internet of Things (IoT) and cloud computing allow large amounts of data to be collected and analyzed in real time. The integration of these technologies with fault diagnosis techniques helps to improve the efficiency and reliability of fault diagnosis systems. In [32], the authors examine the integration of algorithms with IoT systems to monitor and diagnose failures in solar PV panels. The method suggested can be used after adaptation in agent-based modeling for complex socio-economic processes coupled with high-performance computing (HPC) [33,34,35,36,37,38,39,40].

Modern approaches to data classification tasks increasingly rely on machine learning methods [41,42,43,44], particularly neural network architectures. However, the use of neural networks is associated with a number of limitations, the main of which being the need to form extensive training samples. These datasets are usually collected within a specific subject area, which complicates the process of adapting the model to new applications and requires significant computational resources to retrain it.

Other work in the application of wavelet transform for signal fault detection has a narrower and more specialized focus, particularly for electrical instrumentation applications [45,46,47]. The methods then aim to work for more specific electrical signals, which improves overall reliability and accuracy but is less applicable to general time series.

The proposed method uses an alternative approach based on wavelet transform and numerical optimization techniques [48,49,50,51]. The wavelet transform performs the task of localizing meaningful features in the input data, which allows for the efficient extraction of informative features. Unlike neural network methods, which require a complex training procedure, classification in our approach is based on mathematical models using libraries of basic reference signals.

A key aspect of the proposed method is the application of the standard deviation metric (MSE) as a similarity criterion. This approach allows for comparing the input data with pre-formed libraries of failure (anomaly) patterns and performing classification without the need to pre-train the model on specialized samples. Thus, the flexibility of the method and its portability to different subject areas without significant adaptation costs are ensured.

One of the important advantages of the proposed method is its modularity. This approach can be considered as service-oriented, which makes it possible to replace individual components of the system without disturbing its overall structure. For example, the classification or localization stage can be replaced by neural network models if it turns out to be appropriate for a particular task. This hybrid approach allows the algorithm to be adapted to different scenarios, combining the advantages of traditional mathematical methods and machine learning.

Some algorithm parameters, such as thresholds and other coefficients, depend on the subject area and the specifics of the problem to be solved. Their selection is based on the characteristics of the data and may require additional calibration for optimal model performance.

In general, the proposed method combines the advantages of wavelet transform for local data analysis, numerical optimization methods for efficient classification, and the flexibility of a modular approach, allowing for the integration of neural network components as needed. This makes it a competitive alternative to purely neural network models, especially in cases where the availability of large training samples is limited and adaptation to new data must be performed with minimal computational cost.

2. Materials and Methods

2.1. Wavelet Transform

The fundamental method for the algorithm to work is wavelet transform, which decomposes the input signal into detailing coefficients that can be used for subsequent failure analysis and localization.

The wavelet decomposition algorithm, often referred to as the Mallat algorithm [52] or fast wavelet transform, is an efficient method for decomposing a signal into multiple levels of detail. This algorithm is the basis for many signal processing applications, including noise reduction, data compression, and feature analysis. The pseudocode provided as ‘WaveletDecomposition’ describes the scheme of Mallat’s algorithm for one-dimensional signals (Algorithm 1).

Algorithm 1 WaveletDecomposition (Mallat’s Algorithm)

Require:  $signal$—input one-dimensional signal Require:  $wavelet$—wavelet type (e.g., ‘db20’) Require:  $level$—decomposition depth Ensure:  Coefficient array $coeffs=[c{A}_{\mathrm{level}},c{D}_{\mathrm{level}},\dots ,c{D}_1]$   1: Initialize the list of coefficients $coeffs$ as empty   2: $current\_signal\leftarrow signal$   3: for $k\leftarrow 1$ to $level$ do   4:       Perform convolution of $current\_signal$ with the scaling filter (low-pass) from the selected wavelet $\to c{A}_k$   5:       Perform convolution of $current\_signal$ with the high-pass filter from the selected wavelet $\to c{D}_k$   6:       Perform a downsampling operation (select every second sample) for $c{A}_k$ and $c{D}_k$   7:       $current\_signal\leftarrow c{A}_k$   ▹ The signal at the next step is the approximating coefficients   8:       Save $c{D}_k$ to the internal buffer   9: end for 10: Save $current\_signal$ (i.e., $c{A}_{\mathrm{level}}$) to $coeffs$ 11: Add all detailing coefficients $c{D}_k$ to $coeffs$ in order from last to first return $coeffs$

2.1.1. Basic Principles and Steps of the Algorithm

The wavelet decomposition algorithm is based on the use of a set of wavelet filters, including scaling (low-pass) and detail (high-pass) filters, which are associated with the selected wavelet. The decomposition process is iterative and is applied a given number of times, determined by the decomposition level (‘level’).

Input data: The algorithm takes as input a one-dimensional signal (‘signal’), a wavelet type (‘wavelet’) that specifies the set of filters to be used, and a decomposition depth (‘level’) indicating the number of decomposition levels.

Initialization: At the beginning of the algorithm, an empty list of ‘coeffs’ is initialized to store the coefficients of the wavelet decomposition. The current signal being processed ‘current signal’ is set as equal to the input signal.

Iterative decomposition process (FOR loop): The algorithm performs iterations, the number of which being determined by the level of decomposition (‘level’). At each iteration k (from 1 to ‘level’), the following steps are performed:

• Scaling filter convolution: The current signal ‘current signal’ is subjected to a convolution operation with the scaling filter (low-pass filter) associated with the selected wavelet. The result of this operation is the approximating coefficients of the current level, denoted as $c{A}_k$. These coefficients represent the low-frequency component of the signal, reflecting the overall structure or trend of the signal at a given resolution level.
• Wrap with detail filter: Simultaneously, the same current signal ‘current signal’ is convolved with a detail filter (high-pass filter) also originating from the selected wavelet. The result is the detailing coefficients of the current level, denoted as $c{D}_k$. These coefficients represent the high-frequency component of the signal, containing details and abrupt changes such as noise and signal features.
• Downsampling (decimations): Both the approximating coefficients $c{A}_k$ and the detailing coefficients $c{D}_k$ undergo a “downsampling” operation, which consists of selecting every second sample. This is performed to reduce the size of the data and increase the level of resolution in the next decomposition step. Downsampling is a key part of the Mallat algorithm, ensuring its efficiency.
• Update current signal: For the next iteration of the algorithm, the current signal ‘current signal’ is replaced by the approximating coefficients $c{A}_k$ of the current level. This means that, at the next level, only the approximated, smoother version of the previous level signal is decomposed.
• Saving detailing coefficients: The detailing coefficients $c{D}_k$ obtained at the current level are temporarily stored in an internal buffer for later sequencing.

Saving approximating coefficients of the last level: At the end of the iteration cycle, when a given decomposition depth (‘level’) has been reached, the last obtained approximating coefficients $c{A}_{level}$ (which are the ‘current signal’ values at the last iteration) are stored in the ‘coeffs’ list. These coefficients represent the crudest approximation of the original signal.

Add detail coefficients to the output array: Then, all the detailing coefficients $c{D}_k$ stored in the internal buffer during the iterations are added to the ‘coeffs’ list. It is important to note that they are added in the order of the last level to the first, i.e., in the order $c{D}_{level},c{D}_{level-1},\dots ,c{D}_1$.

Output: The algorithm returns an array of coefficients ‘coeffs’, which is a list starting with the approximating coefficients of the last level $c{A}_{level}$, followed by the detailing coefficients of all levels, from $c{D}_{level}$ to $c{D}_1$. Thus, the structure of the output coefficients is of the following form: $[c{A}_{level},c{D}_{level},c{D}_{level-1},\dots ,c{D}_1]$.

2.1.2. Meaning and Application of the Algorithm

The Mallat wavelet decomposition algorithm is an efficient and widely used method for analyzing signals in many fields. Decomposing a signal into approximating and detailing coefficients at different levels allows the signal to be analyzed at different frequency ranges and resolution levels. This is useful for identifying various signal characteristics, such as trends, details, noise, and features. The resulting coefficients can be used for a variety of tasks, including noise reduction (by thresholding the detailing coefficients), data compression (by discarding small coefficients), and feature extraction for classification and pattern recognition.

2.2. Data Preprocessing Methods

Next, it is necessary to consider methods of data preprocessing, i.e., the received signal, for further analysis: localization and classification.

2.2.1. find_peaksAlgorithm (Peak Search)

The find_peaks algorithm (Algorithm 2) is designed to detect local maxima (peaks) in a one-dimensional numeric array. The main goal of the algorithm is to select point indices that correspond to peaks that meet the given criteria, particularly the “prominence” of the peak.

Algorithm 2 find_peaks

1: Input: $signal$—one-dimensional array of numbers   2: Input: $prominence=(min\_threshold, max\_threshold)$—minimum and maximum excretion thresholds   3: Output: List of $peaks$ indexes (maxima corresponding to a given prominence)   4: Initialize empty list $peaks$   5: Find all local maxima in $signal$ (points where $signal[i-1]<signal\left[i\right]>signal[i+1]$)   6: for each local maximum i do   7:       Determine its prominence—the height of the peak relative to local troughs   8:       if prominence $\ge \text{min\_threshold}$ and $\le \text{max\_threshold}$ then   9:             Add i to the $peaks$ list 10:     end if 11: end for 12: return  $peaks$

Main Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array of numbers signal and an optional parameter prominence, which is a tuple (min_threshold, max_threshold). The prominence parameter specifies the minimum and maximum thresholds for “highlighting” the peaks to be considered significant.

Local maxima: The first step of the algorithm identifies all local maxima in the input signal. A local maximum is defined as a point with index i whose value is greater than the values at the neighboring points $signal[i-1]$ and $signal[i+1]$ ($signal[i-1]<signal\left[i\right]>signal[i+1]$).

Calculation of “prominence”: For each local peak found, its “prominence” is calculated. The “prominence” of a peak is a measure of its height relative to the surrounding local troughs. The exact definition of “prominence” can vary, but, in general, it reflects the vertical distance from the top of the peak to the lowest contour point defined to the left and right of the peak until the higher peak or end of the signal is reached. (In the simplified scheme, the details of the prominence calculation are not disclosed, but it is assumed that such a calculation is made.)

Threshold filtering prominence: After computing the “prominence” for each local peak, the algorithm applies threshold filtering. A peak is considered significant and is included in the list of results peaks only if its “prominence” is within the specified range, i.e., greater than or equal to min_threshold and less than or equal to max_threshold. If the prominence parameter is not set or thresholds are not specified, filtering may not be applied or may use default values.

Output: The algorithm returns a list of peaks that contains the indices of local maxima that satisfy the prominence criterion (if given).

Remarks

This simplified find_peaks algorithm focuses on the basic steps of prominence-based peak detection. However, the presented scheme reflects the key idea of selecting significant peaks based on their prominence.

2.2.2. detect_faults Algorithm

The detect_faults algorithm (Algorithm 3) is designed to detect potential “faults” in a one-dimensional signal. It uses the find_peaks algorithm (see Algorithm 2) to identify peaks in the absolute value of the signal, which are interpreted as indicators of damage.

Algorithm 3 detect_faults

1: Input: $signal$—one-dimensional array 2: Input: $min\_threshold,max\_threshold$—limits for the prominence parameter 3: Output: Tuple $(peaks,\_)$, where peaks—an array of peak indices 4: $peaks\leftarrow \text{find\_peaks}(|signal|, prominence=(min\_threshold, max\_threshold))$   ▹ See Algorithm 2 5: return  $peaks$

Basic Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array signal and parameters min_threshold and max_threshold, which define the bounds for the prominence parameter when searching for peaks.

Finding peaks with find_peaks: The algorithm calls the find_peaks function (Algorithm 2) to search for peaks in the absolute value of the input signal $| signal |$. Parameters prominence=(min_threshold, max_threshold) are passed to find_peaks to specify the criteria for selecting peaks based on their prominence.

Output: The algorithm detect_faults returns a tuple whose first element is the array peaks. The array peaks contains indices of peaks detected by the find_peaks algorithm, which, in this context, are interpreted as indices of potential faults.

Remarks

The detect_faults algorithm relies on the assumption that faults in the signal appear as peaks or abnormal outliers. By using the absolute value of the signal, both positive and negative outliers can be detected. The effectiveness of fault detection depends on the proper selection of the prominence parameters (min_threshold, max_threshold), which must be adjusted according to the signal characteristics and expected types of faults.

2.2.3. intervals_errors Algorithm

The intervals_errors algorithm (Algorithm 4) is designed to identify intervals where errors or corruptions are suspected to be in the signal. It uses wavelet decomposition, peak detection, and pair generation to determine these intervals.

Algorithm 4 intervals_errors

1: Input: $signal$—one-dimensional array   2: Input: $wavelet$—wavelet type (e.g., ‘db20’)   3: Input: $level=3$—level of decomposition   4: Input:  $epsilon=2$   5: Input:  $min\_threshold=0.1, max\_threshold=25$   6: Input:  $h=1e-6$   7: Output: List of intervals (pairs) where errors are suspected   8: $coeffs\leftarrow \mathrm{WaveletDecomposition}(signal, wavelet, level)$   ▹ See Algorithm 1   9: $cf\_lvl\leftarrow coeffs\left[level\right]$   ▹ Coefficients at a given level (detailing or approximating-depends on the library) 10: $peaks\leftarrow \text{detect\_faults}(cf\_lvl, min\_threshold, max\_threshold)$ 11: Build a list of $eps\_peaks$ by $peak-epsilon$ for each $peak\in peaks\left[0\right]$ 12: $intervals\leftarrow \mathrm{combinations}(eps\_peaks, 2)$ 13: return  $intervals$

Main Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array signal, wavelet type wavelet, decomposition level level (default 3), parameter $ϵ$ (epsilon, default 2), prominence threshold parameters min_threshold and max_threshold, and filter threshold h (default 1 × 10 ⁻⁶).

Wavelet decomposition: In the first step, the algorithm applies wavelet decomposition to the input signal signal using the WaveletDecomposition algorithm (Algorithm 1), the selected wavelet wavelet, and the decomposition level level. The result is a list of coefficients coeffs.

Selection of level coefficients  level: The algorithm selects coefficients at a given decomposition level from a list of coeffs. In pseudocode, this is the string cf_lvl ← coeffs[level].

Detect peaks in coefficients: The algorithm applies the detect_faults function (Algorithm 3) to the selected wavelet coefficients cf_lvl with the given prominence thresholds min_threshold and max_threshold. The result is a list of peak indices of peaks in coefficients.

Building “extended” peaks: For each peak index peak of peaks[0], an “extended peak” is created from peaks[0] eps_peaks by subtracting the value $ϵ$ from the peak index (peak-epsilon). The purpose of this step is to possibly expand the area around the peak to determine the error interval.

Generation of intervals (pairs): The algorithm uses the combinations function to generate all pairs of combinations from a list of “extended” peaks eps_peaks of length 2. Each pair represents an interval potentially containing an error.

Output: The algorithm returns a list of intervals containing index pairs representing the intervals where the errors in the original signal are suspected to be located.

Remarks

The intervals_errors algorithm combines wavelet analysis with peak detection and combinatorics to determine error intervals. Using wavelet decomposition allows one to analyze the signal at different frequency levels and possibly better isolate features associated with faults. The $ϵ$ parameter and pair generation can be associated with trying to identify intervals around peaks where errors are most likely to occur. Adjusting the wavelet parameters, decomposition level, prominence and filter thresholds, and the $ϵ$ value is critical to the effectiveness of the algorithm in specific applications.

2.2.4. clean_signal

The clean_signal algorithm (Algorithm 5) is designed to “clean” a signal, represented as a structure or array with x and y fields. The algorithm removes the sinusoidal component from the signal y to investigate the latest signal faults.

Algorithm 5 clean_signal

1: Input: $signal$—structure/array with fields x and y 2: Output: New one-dimensional array $y\_clean$ 3: $(vals, counts)\leftarrow \mathrm{unique}(signal[“y”], \text{return\_counts}=True)$ 4: $Ampl\leftarrow vals[\arg {\max }_{i\in counts}\left(counts\right)]$   ▹ Find the most frequent value 5: $y\leftarrow signal[“y”]-\left|Ampl\right|·sin(100·\pi ·signal[“x”])$ 6: return  y

Main Steps of the Algorithm

Input data: The algorithm takes as input a structure or array signal, which is assumed to contain the fields x and y. The x field may represent the time axis or other independent variables, and the y field may represent the signal values.

Find the most frequent value. The algorithm uses the unique function to find unique values in the array signal[“y”] and count their frequency. The result is the arrays vals (unique values) and counts (the number of occurrences of each unique value).

Determination of the amplitude of Ampl:. The algorithm finds the value of Ampl, which is the most frequent value in signal[“y”]. This is achieved by finding the index of the maximum value in the counts array using the argmax function and then extracting the corresponding value from the vals array.

Sinusoidal component subtraction: The algorithm creates a new array y by subtracting the sine function from the original signal signal[“y”]. The sine function is of the form $\left|Ampl\right|·sin(100·\pi ·signal[“x”\left]\right)$. The amplitude of the sinusoid is given as the absolute value of Ampl, the frequency is fixed as $100\pi$ (which corresponds to a frequency of 50 Hz if x is in seconds, or 100 cycles per unit of x), and the phase is zero.

Output: The algorithm returns a new one-dimensional array y_clean, which is the result of subtracting the sine component from the original signal signal[“y”].

Remarks

The clean_signal algorithm is designed to remove a specific type of noise: a sine wave interference with a fixed frequency (or frequency proportional to x). The method of determining the amplitude of the noise (by searching for the most common value) is heuristic and may not always be efficient or accurate. The choice of frequency ($100\pi$) and the shape of the sine function assumes that the type of interference is known in advance. More general noise reduction may require more sophisticated techniques, such as wavelet noise reduction or filtering in the frequency domain.

2.2.5. pad_array Algorithm

The pad_array algorithm (Algorithm 6) is designed to augment the input array arr with zeros up to a given length length. If the input array already has a length greater than or equal to length, the algorithm returns the original array unchanged. If the length of the array is less than the required length, the missing elements are added symmetrically on both sides of the array as zeros.

Algorithm 6 pad_array

1: Input: $arr$—source array, $length$—required length of the result   2: Output: New array of length $length$   3: $current\_len\leftarrow \mathrm{length}\left(arr\right)$   4: if  $current\_len\ge length$  then   5:       return $arr$                    ▹ The array is already long enough   6: else   7:       $pad\_len\leftarrow length-current\_len$   8:       $left\_len\leftarrow \lfloor {\displaystyle \frac{pad\_len}{2}}\rfloor$   9:       $right\_len\leftarrow pad\_len-left\_len$ 10:       Augment $arr$ to the left by $left\_len$ zeros and to the right by $right\_len$ zeros 11:       return New augmented array 12: end if

Main Steps of the Algorithm

Input data: The algorithm takes as input an array arr and the desired length length (integer).

Check current length: The algorithm first determines the current length of the input array current_len. Then, it compares current_len with the given length length.

In case the array is long enough: If current_len is greater than or equal to length, it means that the array already has the required or an excessive length. In this case, the algorithm does not perform any addition actions and simply returns the original array arr.

In case the array needs to be appended: If current_len is less than length, the array must be appended to the required length:

• Calculating the length of the complement. The total length of the complement pad_len is calculated as the difference between the required length length and the current length current_len: $pad\_len=length-current\_len$.
• Left and right complement distribution. The length of the complement pad_len is distributed approximately equally between the left and right sides of the array to ensure a symmetrical complement.
  • The length of the left complement left_len is calculated as the integer part of dividing pad_len by two: $left\_len=\lfloor {\displaystyle \frac{pad\_len}{2}}\rfloor$.
  • The length of the right-hand complement right_len is calculated as the remainder: $right\_len=pad\_len-left\_len$. This distribution ensures that the total length of the complement is equal to pad_len, even if pad_len is an odd number.
• Zeros complementation. The array arr is appended with left_len zeros on the left and right_len zeros on the right. The complement operation is usually performed by creating a new array and copying the original elements of the arr array into it, adding zeros at the beginning and end.

Output data: The algorithm returns a new array whose length is equal to length. If the original array was shorter, it will be appended with zeros symmetrically on both sides. If the original array was long enough, the original array is returned.

Remarks

The pad_array algorithm is useful in situations where arrays need to be brought to a uniform length for further processing, such as in batch processing, where all input data must have the same dimensionality. Symmetric addition with zeros helps to minimize distortions that can be introduced by addition, especially in the context of signal processing, where the position of elements relative to the beginning and end of the array may be important.

2.2.6. resize_vector Algorithm

The resize_vector algorithm (Algorithm 7) is designed to resize a one-dimensional array (vector) vector to a new specified length new_size. The algorithm provides two main cases of resizing—length increase and length decrease—and uses different approaches for each case.

Algorithm 7 resize_vector

1: Input: $vector$—original one-dimensional array, $new\_size$—new length   2: Output: New array of length $new\_size$   3: $old\_size\leftarrow \mathrm{length}\left(vector\right)$   4: if  $new\_size=old\_size$  then   5:       return $vector$                        ▹ Size does not change   6: else if $new\_size>old\_size$ then       ▹ Interpolation at increasing length   7:       Let $indices$ be uniform values from 0 to $old\_size-1$ with the number of points $new\_size$   8:       Create an output array by interpolating $vector$ at $indices$ points   9:       return Resulting array 10: else                           ▹ Averaging over decreasing length 11:       Let $indices$ be uniform values from 0 to $old\_size-1$ with the number of points $new\_size$ 12:       Initialize $resized\_vector$ with zeros of length $new\_size$ 13:       for $i\leftarrow 1$ to $new\_size$ do 14:           $start\_index\leftarrow \lfloor indices\left[i\right]\rfloor$ 15:           $end\_index\leftarrow start\_index+1$        ▹ or $old\_size$, if $i=new\_size$ 16:           $resized\_vector\left[i\right]\leftarrow$ mean value of the $vector$ subarray on the interval $[start\_index,end\_index)$ 17:       end for 18:       return $resized\_vector$ 19: end if

Main Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array vector and a new desired length new_size (integer).

Size comparison: The algorithm compares the current length of the array old_size with the new length new_size.

Case where the size does not change: If new_size is equal to old_size, then the array size does not need to be changed. In this case, the algorithm simply returns the original array vector unchanged.

Length increase case (new_size > old_size): When the length of the array needs to be increased, the algorithm uses interpolation to create new values between existing points:

• Create interpolation indexes: An array of indices is created containing new_size evenly spaced values ranging from 0 to old_size − 1. These indices represent the positions in the original array for which values must be interpolated to produce an array of the new length.
• Interpolation: The original array vector is interpolated at the points specified by the array indices. The interpolation method is not explicitly specified in the pseudocode, but it is implied that some one-dimensional interpolation method (e.g., linear, spline, or cubic) is used that approximates the signal values between the source points.
• Output data (after interpolation): The algorithm returns a new array resulting from the interpolation, whose length is equal to new_size.

Length reduction case (new_size < old_size): When the length of the array needs to be reduced, the algorithm uses value averaging to preserve the overall information while reducing the granularity:

• Creating indexes for averaging: Similar to the increment case, an array of indices is created containing new_size evenly spaced values ranging from 0 to old_size − 1. These indices define the boundaries of the intervals in the original array, which will be averaged to obtain the values in the new array of reduced size.
• Initializing the output array: A new array resized_vector of length new_size filled with zeros is created.
• Averaging over intervals (FOR loop): For each index i from 1 to new_size (in pseudocode, the numbering starts at 1, which may be atypical for Python-like languages, usually indexes start at 0):
  • The start and end indices of the interval in the source array are specified: start_index and end_index, using the values from the indices array. start_index is taken as an integer part of indices[i]. end_index is usually equal to start_index + 1, but may be limited to old_size for the last interval to keep within the bounds of the original array.
  • The average value of the elements of the vector subarray on the interval $[\mathtt{start}\_\mathtt{index},\mathtt{end}\_\mathtt{index})$ is calculated.
  • The calculated average value is assigned to the element resized_vector[i]. (in the pseudocode, the indexing of resized_vector also starts from 1, which should be taken into account in the implementation).
• Output (after averaging): The algorithm returns an array of resized_vector of length new_size obtained by averaging sections of the original array.

Output data: Depending on the relationship between old_size and new_size, the algorithm returns either an interpolated array (if the size increases), an averaged array (if the size decreases), or the original array (if the size does not change).

Remarks

The resize_vector algorithm provides two different methods of resizing an array depending on whether the size is increasing or decreasing. Using interpolation while increasing the size allows new points to be added while maintaining the overall waveform. Averaging while decreasing the size allows one to preserve the overall energy of the signal while reducing the detail. The choice of a specific interpolation method and averaging method can be customized depending on the requirements of the task.

2.3. Algorithm

Now, we can consider the basic algorithms for signal fault localization and classification, which are based on the use of previous methods and algorithms.

Mathematically, we can describe the problem to be solved as follows:

$\arg {\min }_{\begin{array}{c}(s,t,a)\in S\times T\times A\end{array}}\mathrm{MSE}\left(y,\widehat{y}\right)$.

$\arg {\min }_{\begin{array}{c}(s,t,a)\in S\times T\times A\end{array}}\mathrm{MSE}\left(y,\mathrm{ErrorFunction}(s,t,a)\right)$.

Here, the following applies:

1. y: the original signal represented as a time series. This signal is the reference signal and is used to evaluate the accuracy of the approximation.

2. $\widehat{y}$: the approximated signal obtained by applying an error function with certain parameters. The goal is to match this signal as closely as possible to the original signal y.

3. ErrorFunction: a function that takes stretch, shift, and amplitude parameters as input and returns an approximated signal. Formally, $\mathrm{ErrorFunction}(s,t,a)$ denotes the approximated signal obtained given the parameters s, t, and a.

4. S: the set of possible values of the signal stretching parameter along the OX axis. Each element of this set represents a stretching factor that can be applied to the original signal.

5. T: the set of possible values of the signal shift parameter. Each element of this set represents a shift value that can be applied to the original signal.

6. A: a set of possible values of the signal amplitude parameter. Each element of this set represents an amplitude coefficient that can be applied to the original signal.

7. $S\times T\times A$: The Cartesian product of sets S, T, and A that is the set of all possible combinations of stretch, shift, and amplitude parameters.

The purpose of the method is to find such a combination of parameters $(s,t,a)$ that minimizes the MSE error between the original signal y and the approximated signal $\widehat{y}$.

Thus, this formula defines a procedure for finding the optimal stretch, shift, and amplitude parameters that provide the best approximation of the original signal in the sense of minimizing the MSE error.

The main steps of the algorithm are as follows (Figure 1):

1. Input signal: Obtaining a raw signal containing potential anomalies (failures).

2. Signal preprocessing: Normalization, the removal of unwanted noise components, and peak detection.

3. Wavelet analysis: Wavelet transform (decomposition of the signal into wavelet coefficients for analysis at different scales) and coefficient analysis (examination of wavelet coefficients to identify features associated with failures).

4. Error Classification: Using optimization methods (Nelder–Mead method, BFGS) to minimize the MSE between a failure in the signal interval and a possible failure from error sample libraries.

5. Results output: Error classes (defined failure types), error estimation (metrics output), temporal localization (determining when the failure occurs).

2.3.1. WONC-FD mse_classification Algorithm

The mse_classification algorithm is designed to classify the type of “error” or “defect” in a one-dimensional signal y by comparing it to a set of predefined “error signals” Error_signal of various types listed in the array errors. The classification is based on minimizing the mean square error (MSE) between the input signal and the approximation obtained using different error types, sizes, and shifts.

The Main Steps of the Algorithm 8.

Algorithm 8 WoncFD_mse_classification

1: Input: y—one-dimensional array of points,   2: $errors$—list of possible error types (e.g., [“haar”, “haar1”, …]),   3: $leng$—base length of the signal (e.g., 1000),   4: $epsilon$—a small threshold to check for proximity to 0,   5: n—fraction of zero (modulo) points for rejection.   6: Output: List: [name of the best error type, MSE]   7: if  $\left(\mathrm{length}\right(y)\le leng\times 0.05)$  or  $({\sum }_i(1 \mathrm{if} |y_i|<ϵ \mathrm{else} 0)>\mathrm{length}\left(y\right)\times n)$  then   8:     return [“Bad signal”, “NaN”]   9: end if 10: Initialize empty array $result$ 11: $x\leftarrow$ an array of uniform values from 0 to 1 of size $\mathrm{length}\left(y\right)$ 12: $ampl\leftarrow 1$ 13: $size\_values\leftarrow \left\{\mathrm{length}\right(y),\mathrm{length}(y)+10,\mathrm{length}(y)+20,\dots ,2\times \mathrm{length}(y\left)\right\}$ 14: $shifts\leftarrow \{-\mathrm{length}(y),-\mathrm{length}(y)+1,\dots ,\mathrm{length}(y\left)\right\}$ 15: for each $err$ of $errors$ do 16:     $mse\_err\leftarrow$ a large number (e.g., ${10}^5$) 17:     for each s of $size\_values$ do 18:         for each $shift$ of $shifts$ do 19:            Calculate the vector of error values from the dictionary $Error\leftarrow \text{resize\_vector}(\text{Error\_signal}(err,x,ampl,1),s)$ 20:            if $shift\ge 0$ then 21:                $arr\_error\leftarrow [0,\dots ,0,Error][:\mathrm{length}(x\left)\right]$ forward-shifted 22:            else 23:                $arr\_error\leftarrow [Error,0,\dots ,0][-\mathrm{length}(x):]$ backward 24:            end if 25:            $\text{features\_matrix}\leftarrow$ a matrix of size $\left(\mathrm{length}\right(x),2)$, where the first column is 1, the second column is $arr\_error$ 26:            Find the $coefficients$ using the least squares method: $$\underset{\beta }{min}{\parallel \text{features\_matrix}·\beta -y\parallel }^2$$ 27:            $approximated\_signal\leftarrow \text{features\_matrix}·coefficients$ 28:            $mse\leftarrow \mathrm{MSE}(y,approximated\_signal)$ 29:            if $mse<mse\_err$ then 30:                $mse\_err\leftarrow mse$ 31:            end if 32:         end for 33:     end for 34:     Add $mse\_err$ to the $result$ array 35: end for 36: Find the index $\arg {\min }_{i\in result}\left(result\right)$ 37: return [$errors[\arg {\min }_{i\in result}\left(result\right)],result[\arg {\min }_{i\in result}\left(result\right)]]$

Input data: The algorithm takes as input a one-dimensional array of points y, a list of error type names errors, a base signal length leng, a small threshold $ϵ$ to check for proximity to zero, and a fraction of zero (modulo) points n to reject the signal.

Preliminary Signal Checking: The algorithm performs an initial check on the input signal y to weed out “bad” signals that may lead to incorrect results.

• Check signal length: The signal is checked for whether it is too short. If the length of y is less than or equal to $5\%$ of the base length of leng (i.e., length(y) $\le 0.05\times leng$), the signal is considered “bad”.
• Check for near-zero dots: The number of points in y whose absolute value is less than the specified small threshold $ϵ$ ($|y_i|<ϵ$) is counted. If the number of such points exceeds a fraction n of the total signal length (i.e., the number of points $|y_i|<ϵ$ > $n\times \mathrm{length}\left(y\right)$), the signal is also considered “bad”.
• Return for “bad” signals: If a signal is considered “bad” by one of the above criteria, the algorithm does not perform further classification and returns the list [“Bad signal”, “Nan”] as the result, indicating that classification is impossible or unreliable.

Initialization: For good signals, the algorithm continues the classification process:

• An empty result array is initialized to store MSE values for each error type.
• An array x is created representing uniformly distributed values from 0 to 1, the size of the signal length y. This can serve as a normalized “time” axis for error generation.
• The initial amplitude of ampl for generated errors is set to 1.
• A set of size_values is defined. In pseudocode, these are sizes from length(y) in increments of 10 to $2\times \mathtt{length}\left(y\right)$. These dimensions will be used to resize the generated error signals.
• A set of shifts from $-\mathtt{length}\left(y\right)$ to $\mathtt{length}\left(y\right)$ in increments of 1 is defined. These shifts will be used to offset the generated error signals relative to the beginning of the y signal.

Cycle by error type (external FOR loop): The algorithm iterates over each error type err from the list errors. For each error type, the following process is performed:

• Initialization of minimum MSE for error type: The initial value of the minimum MSE mse_err for the current error type is set to a large number (e.g., ${10}^5$). This value will be updated if smaller MSE values are found.
• Cycle by size (middle FOR loop): For each size s from the set size_values:
• Shift cycle (inner FOR loop): For each shift shift from the set of shifts:
  • Generating and resizing the error signal: A “base” error signal is generated using the Error_signal(err, x, ampl, 1) function for the current error type err, “time axis” x, amplitude ampl, and scale 1. Then, using the function resize_vector, the size of the generated error signal is resized to length s.
  • Applying a shift to the error signal: Depending on the sign of the shift shift, the error signal Error is shifted either forward (if shift $\ge 0$) or backward (if shift < 0) relative to the signal y. The shift is realized by adding zeros to the beginning or end of the error signal and truncating the result to the length length(x).
  • Building a feature matrix: A feature matrix features_matrix of size $\left(\mathtt{length}\right(x),2)$ is created. The first column of the matrix is filled with ones and the second column is filled with the shifted error signal arr_error. The first column with units allows us to account for the bias (constant) in the model.
  • Least Squares Method (LSM): A linear regression problem is solved using the least squares method to find the coefficients ($\beta$) minimizing the norm of the difference ${\parallel \text{features\_matrix}·\beta -y\parallel }^2$. This allows us to find the optimal linear combination (bias and scaling) of the error signal to approximate the y signal.
  • Calculating the approximated signal: The approximated signal approximated_signal is calculated as the product of the feature matrix features_matrix by the found coefficients coefficients.
  • Calculation of MSE: The mean square error (MSE) between the original signal y and the approximated signal approximated_signal is calculated.
  • Update Minimum MSE: If the calculated MSE value is less than the current minimum MSE mse_err for this error type, then mse_err is updated with this new, smaller MSE value.

Saving the minimum MSE for the error type: After the size and shift cycles are completed, the minimum MSE value found mse_err for the current error type err is added to the array result.

Determination of the best error type: After looping through all error types, the algorithm finds the index of the minimum value in the result array. This index corresponds to the error type that provided the lowest MSE when approximating the signal y.

Output: The algorithm returns a list containing two elements: the name of the best error type (from the errors list) and the corresponding minimum MSE value. This indicates the error type that best “explains” the y signal structure in terms of MSE.

Remarks

The mse_classification algorithm is a classification method based on matching a signal to a set of reference “error” signals. Using MSE as an approximation quality metric, it quantifies how well each error type matches the input signal. The enumeration of different sizes of and shifts in the error signals is designed to account for possible differences in scale and phase between expected errors and actual deviations in the signal. The least squares method is used to optimally “fit” the scale and offset of the error signal to the input signal. The efficiency of the algorithm depends on the representativeness of the set of errors, the adequacy of the Error_signal function to model real errors, and the proper choice of parameters, such as size_values, shifts, $epsilon$, and n. The algorithm is computationally intensive due to nested loops and multiple solutions to the least squares problem.

2.4. Parallel Algorithms

It makes sense to parallelize the previous algorithms to optimize the computations in terms of time, since these computations can take a large amount of time with a single thread.

2.4.1. objective_function Algorithm (Loss Function)

The objective_function algorithm (Algorithm 9) is a target function used in the parameter optimization process using the Optuna library (with TPESampler). This function is designed to evaluate the quality of the approximation of the input signal y using a model based on a given “error” type error. The quality of the approximation is evaluated using the mean square error (MSE). The function is used in the context of searching for optimal parameters (size and shift) to model a certain type of error in the signal.

Algorithm 9 objective_function (loss function)

1: Input: y—one-dimensional array of signal points with error,   2: $error$—string, name of the error type   3: Output: MSE (Mean Square Error) for the given parameters   4: $size\leftarrow \left(\mathrm{length}\right(y)-10,\mathrm{length}(y)+10)$                ▹ Integer size frames   5: $shift\leftarrow (-\mathrm{length}(y),\mathrm{length}(y\left)\right)$                   ▹ Integer Shift Frames   6: $x\leftarrow$ array of uniform values from 0 to 1 of size $\mathrm{length}\left(y\right)$   7: $ampl\leftarrow 1$   8: if  $shift\ge 0$  then   9:     $Error\leftarrow \text{resize\_vector}(\text{Error\_signal}(error,x,ampl,1),size)$   ▹ Resize the error signal (See Algorithm 7). 10:     $Error\leftarrow \mathrm{resize}(Error,(1,\mathrm{length}\left(y\right)\left)\right)$   ▹ Change the dimension of the Error array to (1, length(y)) 11:     $Error\leftarrow Error\left[0\right]$             ▹ Get the first line of the Error array 12:     $arr\_error\leftarrow \mathrm{concatenate}\left(\right[0,\dots ,0,Error\left]\right)[:\mathrm{length}(x\left)\right]$   ▹ Complete with zeros and trim 13: else 14:     $Error\leftarrow \text{resize\_vector}(\text{Error\_signal}(error,x,ampl,1),size)$   ▹ Resize the error signal (See Algorithm 7). 15:     $Error\leftarrow \mathrm{resize}(Error,(1,\mathrm{length}\left(y\right)\left)\right)$   ▹ Change the dimension of the Error array to (1, length(y)) 16:     $Error\leftarrow Error\left[0\right]$   ▹ Get the first line of the Error array 17:     $arr\_error\leftarrow \mathrm{concatenate}\left(\right[Error,0,\dots ,0\left]\right)[-\mathrm{length}(x):]$   ▹ Complete with zeros and trim 18: end if 19: $\text{features\_matrix}\leftarrow \mathrm{vstack}([1,\dots ,1],arr\_error).T$            ▹ Create feature matrix 20: $coefficients\leftarrow \mathrm{lstsq}(\text{features\_matrix},y)$           ▹ Least Squares Method 21: $approximated\_signal\leftarrow \mathrm{dot}(\text{features\_matrix},coefficients)$       ▹ Calculate approximated signal 22: $mse\leftarrow \mathrm{MSE}(y,approximated\_signal)$  return  $mse$

Main Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array y representing the signal points with an error, and a string error indicating the type of error to be modeled.

Selecting parameters to optimize: The function uses the trial object to suggest parameter values to be optimized:

• Error size (size): An integer value of size in the range from length(y) − 10 to length(y) + 10. This parameter specifies the length of the error signal to be generated and then reduced to the length of the y signal.
• Error Shift (shift): An integer value of shift in the range of $-\mathtt{length}\left(y\right)$ to length(y). This parameter defines the shift in the error signal relative to the y signal.

Time axis generation: An array x is created, representing evenly spaced values from 0 to 1, with a length equal to the length of the signal y. This array is used as an argument to the function Error_signal, which generates an error signal.

Generation and resizing of the error signal: A “base” error signal is generated using the Error_signal(error, x, ampl, 1) function for the specified error type error, “time axis” x, amplitude ampl (fixed at 1), and scale 1. Then, using the function resize_vector (Algorithm 7), the size of the generated error signal is resized to the proposed value size. After resizing, the array Error is converted to dimension $(1,\mathrm{length}(y\left)\right)$, and then the first row is extracted to obtain a one-dimensional array.

Applying a shift to the error signal: Depending on the sign of the proposed shift shift, the error signal Error is shifted relative to the beginning of the signal y. If shift $\ge 0$ (forward shift), shift zeros are added to the error signal on the left, and the result is truncated to length length(x). If shift < 0 (backward shift), $-\mathtt{shift}$ zeros are added to the error signal on the right, and the result is trimmed from the beginning to length(x).

Building the feature matrix and approximating the least squares.

• A feature matrix features_matrix is created, consisting of two columns: the first column is filled with units (to account for bias) and the second column is filled with a shifted error signal arr_error.
• We solve the linear regression problem by the least squares method (LSM) using the function lstsq to find the coefficients coefficients that minimize the difference between the features_matrix · coefficients and the input signal y.
• The approximated signal approximated_signal is computed as the product of the feature matrix features_matrix by the found coefficients coefficients.

Calculation of MSE: The mean square error (MSE) between the original signal y and the approximated signal approximated_signal is calculated using the function MSE.

Output: The algorithm returns a computed MSE value, which is a measure of the “mismatch” between the signal y and its approximation using a given error type and the proposed size and shift parameters. The goal of Optuna (TPESampler) is to minimize this MSE value.

Remarks

The objective_function is a key component for optimizing the parameters of an error classification model using TPESampler. It evaluates the quality of the model for given values of the size and bias of the error signal, allowing TPESampler to iteratively search for parameters that minimize the MSE and hence provide the best fit between the error model and the input signal. The use of the least squares method provides an optimal linear fit of the error signal to the input signal based on the criterion of minimizing the MSE.

2.4.2. optimize_params Algorithm (Parameter Optimization)

The optimize_params algorithm (Algorithm 10) is designed to automatically optimize the parameters (size and bias) of an error classification model using the Optuna library. It uses the objective function objective_function (Algorithm 9) to estimate the quality of the parameters and iteratively searches for a set of parameters minimizing the MSE between the input signal and its approximation.

Algorithm 10 optimize_params (parameter optimization)

1: Input: y—one-dimensional array of signal points with error, 2: $error$—string, the name of the error type, 3: $iters$—number of optimization iterations. 4: Output: Best MSE value 5: $study\leftarrow \text{create\_study}(\mathrm{direction}=’\mathrm{minimize}’,\mathrm{sampler}=\mathrm{TPESampler}())$   ▹ Create a minimization problem based on the TPESampler algorithm. 6: $objective\_lambda(trial)=\text{objective\_function}(trial,y,error)$   ▹ Wrapper for objective_function 7: $\mathrm{study}.\mathrm{optimize}(objective\_lambda,\text{n\_trials}=iters)$   ▹ Start Optimization return $\text{study.best\_value}$            ▹ Return the best value found

Main Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array y of signal points with an error, a string error indicating the type of error, and an integer iters specifying the number of optimization iterations that Optuna should perform.

Creating an optimization problem: A study object is created using the create_study function. The direction=’minimize’ parameter indicates that the optimization objective is to minimize the target function (MSE). The parameter sampler=TPESampler() specifies the parameter sampling algorithm; in this case, the tree-structured Parzen estimator (TPE) is used, which is an efficient algorithm for Bayesian optimization.

Define lambda function for Objective Function: A lambda function objective_lambda is created that “closes” the target function objective_function with specific inputs y and error. This is necessary so that Optuna can call the target function with the argument trial without passing y and error each time. In fact, objective_lambda(trial) is equivalent to objective_function(trial, y, error).

Start optimization: The optimization process is started using the study.optimize method. The lambda function objective_lambda is passed as the first argument, and the parameter n_trials=iters specifies the number of optimization iterations (the number of times the target function is called to examine different sets of parameters). The optimizer iteratively calls objective_lambda, offering different parameter values (size and shift) and trying to find those that minimize the return value (MSE).

Obtaining the best value: After completing a given number of optimization iterations, the algorithm retrieves the best found value of the target function (minimum MSE) achieved during the optimization using the study.best_value attribute.

Output: The algorithm returns the best MSE value found during the optimization process. This value represents the minimum MSE achieved for a given error type error and input signal y, with optimized size and shift parameters.

Remarks

The optimize_params algorithm automates the process of finding optimal parameters for modeling an error of a given type. Using the TPE method, we can efficiently explore the parameter space and find the values that provide the best fit between the error model and the input signal according to the MSE criterion. The number of iters iterations affects the quality of optimization and the execution time; a larger number of iterations tends to increase the probability of finding the global minimum, but also increases the computational cost.

2.4.3. classification_parallel Algorithm (Parallel Classification)

The classification_parallel algorithm (Algorithm 11) is a basic algorithm for classifying error types in a signal using parallel computing and the Optuna library for parameter optimization. It is designed to classify a y signal by comparing it with a set of different error types listed in the errors array. The classification is performed by finding the error type that provides the minimum MSE after optimizing the parameters for each error type. Parallelization is used to speed up the classification process by performing optimization for different error types simultaneously.

Algorithm 11 classification_parallel (parallel classification)

1: Input: y—one-dimensional array of signal points with error,   2: $errors$—list of error type names (default: [“haar”, “haar1”, …]),   3: $leng$—basic signal length (default: 1000),   4: $epsilon$—small threshold to check proximity to 0 (default: 0.01),   5: n—fraction of zero (modulo) points for rejection (default: 0.98),   6: $iters$—number of iterations for optimization (default: 100).   7: Output: List: [name of the best error type, MSE]   8: if  $(\mathrm{length}\left(y\right)\le leng\times 0.05) \mathrm{OR} ({\sum }_i(1 \mathrm{if} |y_i|<ϵ \mathrm{else} 0)>\mathrm{length}\left(y\right)\times n)$  then   9:     return [“Bad signal”, “Nan”] 10: end if 11: $y\leftarrow \text{pad\_array}(y,leng)$   ▹ Add the signal to the base length (See Algorithm 6). 12: $best\_losses\leftarrow \mathrm{Parallel}(\text{n\_jobs}=-1)(\mathrm{delayed}(\text{optimize\_params})(y,error,iters) \mathrm{for} \mathrm{each} error \mathrm{in} errors)$   ▹ Parallel optimization for each error type 13: $best\_loss\_idx\leftarrow \arg \min (best\_losses)$   ▹ Find the minimum MSE index 14: $best\_error\leftarrow errors[best\_loss\_idx]$   ▹ Name of best error type 15: $best\_loss\leftarrow best\_losses[best\_loss\_idx]$   ▹ Best MSE value 16: $result\leftarrow [best\_error,best\_loss]$  return  $result$

Main Steps of the Algorithm

Input data: The algorithm takes as input a one-dimensional array y of signal points with errors, a list of strings errors containing the names of error types to classify (by default [“haar”, “haar1”, ‘exp’, ‘-exp’, ‘Invexp’, ‘Invexp+’, ‘algb’]), the base signal length leng (the default is 1000), a small threshold $ϵ$ to check proximity to zero (the default is 0.01), the fraction of zero (modulo) points n for signal rejection (the default is 0.98), and the number of iterations iters for Optuna optimization (the default is 100).

Preliminary check of the signal for “bad” quality: The algorithm performs an initial quality check on the input signal y to rule out cases where the signal is too short or contains an excessive number of points close to zero. These checks are similar to those in the mse_classification algorithm (Algorithm 8). If the signal is recognized as “bad”, the algorithm does not perform classification and returns the list [“Bad signal”, “Nan”].

Addition of signal to base length: If the signal passes the pre-check, it is augmented with zeros to the base length leng using the function pad_array (Algorithm 6). This is performed to standardize the length of the input signals before classification.

Parallel MSE optimization for each error type: For each error type in the errors list, the algorithm runs parallel optimization of the parameters (size and shift) using the optimize_params function (Algorithm 10). Parallel execution is provided by using the Parallel function from the joblib library with the parameter n_jobs = −1, which specifies the use of all available CPU cores. The delayed function from joblib is used to “delay” the call to optimize_params for each error type, allowing Parallel to distribute the computation among the cores. The result of the parallel execution is a list of best_losses, where each element represents the best MSE value found for the corresponding error type.

Selecting the best error type based on the minimum MSE: After the parallel optimization is complete, the algorithm finds the index of the minimum value in the list of best_losses using the argmin function. This index best_loss_idx indicates the error type that provided the lowest MSE under the optimal parameters. The name of the best error type best_error and the corresponding minimum MSE value best_loss are extracted from the lists errors and best_losses, respectively, using the index found.

Result Generation: A result list is generated containing two elements: the name of the best error type best_error and the corresponding minimum MSE value best_loss.

Output data: The algorithm returns a list of result, which contains the name of the error type classified as the most likely for the input signal y and the minimum MSE value achieved for that error type. In case the input signal was recognized as “bad”, the algorithm returns [“Bad signal”, “Nan”].

Remarks

The classification_parallel algorithm is an efficient method for classifying error types, combining automatic parameter optimization using Optuna and parallel computation to speed up the process. Parallelization is particularly important because optimizing parameters for each error type can be computationally expensive. The selection of the error type with the lowest MSE as the most likely error type is based on the assumption that the error type that can be best “fitted” to the signal y (in the sense of MSE) and is the most likely error type present in the signal. The efficiency of classification depends on the adequacy of the set of error types errors and the quality of parameter optimization.

3. Experiments and Analysis of Results

To evaluate the effectiveness of the proposed method, an experiment was conducted in which a signal containing several different failures was analyzed based on synthetic data. The input data were fed to the input of the algorithm, sequentially passing through the stages of localization and classification.

In the first stage, localization of the faults was performed based on partitioning the signal into intervals potentially containing anomalies. For this purpose, a wavelet transform was used to identify areas with characteristic changes associated with a violation of the normal behavior of the signal.

The second stage involved classification of the identified anomalies, implemented using numerical optimization methods. Classification takes place in a multithreaded mode, where each thread minimizes the MSE for a specific interval based on a library of synthetic failures. The mean square deviation (MSE) calculated between signal fragments and reference patterns of known failure types was used as a similarity criterion.

The following criteria were used to evaluate the detection success:

1. For each failure actually present in the signal, the method must produce a low MSE value with the corresponding reference failure class.

2. The method must not exhibit low MSE values for classes not present in the analyzed signal.

If both conditions were met, the detection was considered successful. Thus, the experiment allowed for not only testing the ability of the method to correctly identify failures but also evaluating its robustness to possible false positives.

A signal containing two types of anomalies, haar and algb, was chosen as the test signal for this experiment (Figure 2). These types of failures are characterized by different features: haar represents sharp jumps or dips in the data while algb reflects a failure similar to the appearance of some polynomial.

After preprocessing, including noise suppression and removal of the sinusoidal component, anomaly detection techniques were applied to the signal. The purpose of this step was to partition the signal into intervals with a high probability of containing failures (Figure 2).

Figure 3 shows the intervals with possible failures based on the grouping of intervals after performing the wavelet transform. Each interval is expected to contain an anomaly because the interval boundaries are based on the peaks that were obtained after WT.

The results of the algorithms are presented in

Table 1. Results.

Interval	Fault Type	Error (MSE)
1	Bad signal	Nan
2	Invexp	0.739
3	Invexp	0.927
4	haar	0.448
5	haar	1.644
6	haar	1.662
7	haar	1.209
8	Bad signal	Nan
9	Bad signal	Nan
10	Bad signal	Nan
11	haar	0.383
12	haar	1.505
13	Invexp	3.785
14	Bad signal	Nan
15	Bad signal	Nan
16	Invexp	0.696
17	algb	2.142
18	Invexp	1.922
19	Bad signal	Nan
20	Invexp	0.481
21	-exp	1.902
22	Invexp	1.696
23	Bad signal	Nan
24	algb	0.209
25	algb	3.187 × 10−13
26	algb	0.251
27	algb	2.174 × 10−13
28	Bad signal	Nan

. The analysis of the table shows that, for all intervals containing failures of haar and algb types, the algorithms demonstrated successful recognition. The quantitative quality assessment expressed through the mean square error (MSE) confirms this conclusion: for all correctly identified haar and algb failures, the MSE value does not exceed 0.5.

However, in addition to the true positives, there was one false positive case associated with the Invexp algorithm. The interval erroneously classified as containing an anomaly actually has no pronounced signs of failure.

This problem can be solved in several ways:

1. Increasing the number of iterations: When optimizing the parameters of the Invexp algorithm (or any other algorithm prone to false positives), a larger number of iterations can lead to a more accurate minimization of the target function and, consequently, a lower probability of false positives.

2. Reducing the tolerance threshold: Currently, the MSE threshold for classifying an interval as anomalous is set at 0.5. Lowering this threshold (e.g., to 0.4) would increase the rigor of the selection criteria and may reduce the number of false positives. However, this approach requires caution, as too strict a threshold may lead to missing real failures. Improving the quality of signal recognition by increasing the number of iterations, as described in (1), will allow for lowering the threshold without losing true positives.

3. Increasing the level of detail of the wavelet transform: A higher level of detail can be used for wavelet analysis. This will detect more subtle features of the signal, which can help to distinguish between normal areas and anomalies more accurately.

4. Using different wavelets: Different wavelets have different sensitivities to different types of anomalies. Experimenting with different wavelet families (e.g., Morlet, Mexican Hat, Dobeshi, etc.) can lead to better recognition performance for particular types of signals and faults.

Thus, despite the presence of false positives, the experimental results generally demonstrate the effectiveness of the proposed approach for detecting haar- and algb-type failures in a noisy signal with a sinusoidal component.

4. Discussion

The presented algorithms form a comprehensive system for classifying error types in one-dimensional signals. The central element of the system is the classification_parallel algorithm, which automates the classification process using parameter optimization and parallel computation to improve efficiency. The approach is based on the idea of comparing the input signal with a set of model “error” signals of different types and selecting the type that provides the best match in terms of mean square error (MSE).

4.1. Strengths of the Approach

One of the key advantages of the developed system is its automation. The use of optimizers to find the optimal parameters (size and shift) of the error signal eliminates the need for manual tuning and allows for efficient exploration of the parameter space. Parallelizing the optimization process with joblib significantly reduces computation time, making the system applicable to problems requiring fast data processing.

The use of wavelet decomposition in the intervals_errors algorithm, although not central to the classification of error types, demonstrates the ability to integrate different signal processing techniques to improve the analysis and detection of errors at different frequency levels. The find_peaks algorithm provides an effective tool for detecting characteristic features in signals that may be associated with errors or anomalies.

The modularity of the developed algorithms, including auxiliary functions such as pad_array and resize_vector, increases the flexibility and reusability of the system. The mse_classification function, although replaced by the more efficient classification_parallel, demonstrates the basic MSE-based classification approach that underlies the entire system. The clean_signal function shows the possibility of preprocessing the signal to remove known types of noise, which can improve the quality of classification.

4.2. Limitations and Areas for Improvement

Despite the advantages, the proposed system has some limitations and areas for further improvement.

The computational complexity of the algorithms, especially the classification_parallel algorithms, can be significant due to the nested optimization loops and the need to compute MSEs for a large number of combinations of error types, sizes, and shifts. Further optimization of the code, perhaps through the use of more efficient optimization algorithms or methods to speed up MSE computation, may be beneficial.

The quality of classification depends directly on the representativeness of the set of model “error” signals Error_signal. If the real data error types are not covered by the proposed set, the classification accuracy may decrease. Extending the Error_signal library by adding new, more realistic error models, as well as adapting the models to specific applications, is an important direction for future research.

Sensitivity to parameters of algorithms, such as thresholds in find_peaks, wavelet decomposition parameters, and the number of Optuna iterations, can affect classification results. Further work is needed to investigate the robustness of the system to parameter changes and to develop recommendations for selecting optimal parameter values for different types of signals and tasks. In particular, the automatic adaptation of the parameters, possibly based on the characteristics of the input signal, may improve the practical applicability of the system.

The use of MSE as the only quality metric may be a limitation. Depending on the classification task, other metrics such as accuracy, completeness, F1-measure, or other measures specific to the anomaly detection task may be more appropriate for evaluating classification quality. Investigating and comparing different metrics and their impact on classification performance is an interesting direction for future research.

5. Conclusions

The presented system of algorithms provides an efficient and automated approach to classifying error types in one-dimensional signals. Key advantages are the use of optimization techniques and parallel computing for speedup. The system shows potential for applications in various signal processing areas where the automatic detection and classification of anomalies or defects are required, such as equipment diagnostics and sensor data monitoring.

Despite the results achieved, further research could focus on improving computational efficiency, expanding the model error library, investigating robustness to parameters, and exploring alternative classification quality metrics. Improvements in these areas could make the system an even more powerful and versatile tool for analyzing and interpreting complex signal data, contributing to advances in automatic diagnosis and anomaly detection tasks in various fields of science and engineering.