Real-time intelligent prediction method for faults in offshore wind turbines

Abstract

This invention provides a real-time intelligent prediction method for faults in offshore wind turbines, comprising: continuously photographing an operating offshore wind turbine under test using a thermal imaging device according to set shooting parameters to generate a real-time thermal imaging image sequence of the offshore wind turbine under test; obtaining the start timestamp of the continuous shooting and creating a sequence generation time period based on the start timestamp; continuously monitoring the vibration of the offshore wind turbine under test using vibration sensors installed on the bearings of the offshore wind turbine under test based on the sequence generation time period to generate a vibration degree time series of the offshore wind turbine under test; fusing the real-time thermal imaging image sequence and the turbine vibration degree time series to obtain a real-time fused feature sequence; and predicting the probability of faults in the offshore wind turbine under test in real time based on the real-time fused feature sequence.

Description

Technical Field

[0001] This invention relates to the field of intelligent processing technology, specifically to a real-time intelligent prediction method for faults in offshore wind turbines. Background Technology

[0002] Offshore wind power, as a clean and renewable energy source, has developed rapidly in recent years. Offshore wind turbines (hereinafter referred to as "wind turbines") are the core components of offshore wind power systems, and their stability and reliability directly affect the overall operating efficiency and economic benefits of the system. However, due to the complexity of the offshore environment, wind turbines are prone to various failures during operation. These failures not only affect power generation efficiency but may also lead to major safety accidents. Therefore, effective fault prediction and maintenance of wind turbines are of great significance for ensuring the stable operation of offshore wind power systems.

[0003] Existing wind turbine fault prediction methods mainly include statistical methods, model-based methods, and data-driven methods. Statistical methods typically rely on historical fault data, making predictions by analyzing the frequency and patterns of fault occurrence. Model-based methods are based on a deep understanding of the physical processes of wind turbines, predicting faults by establishing mathematical models. Data-driven methods utilize machine learning algorithms to learn fault characteristics from large amounts of operational data to achieve fault prediction.

[0004] Although existing fault prediction methods can predict wind turbine faults to some extent, they have some limitations. For example, statistical methods require a large amount of historical data and have limited ability to predict newly emerging fault modes; model-based methods require a deep understanding of the physical processes of wind turbines and the model building and maintenance are relatively complex; data-driven methods can handle complex nonlinear relationships, but have high requirements for data quality and quantity and poor model interpretability. Summary of the Invention

[0005] To address the aforementioned technical problems, this application provides a real-time intelligent prediction method for faults in offshore wind turbines, which can at least solve or alleviate the problems existing in the prior art.

[0006] To achieve the above objectives, according to one aspect of this application, a real-time intelligent fault prediction method for offshore wind turbine generators is provided, comprising:

[0007] Based on the set shooting parameters and the thermal imaging equipment, the offshore wind turbine under test is continuously photographed to generate a real-time thermal imaging image sequence of the offshore wind turbine under test.

[0008] Obtain the start timestamp of the continuous shooting, and create a sequence generation time period based on the start timestamp;

[0009] Based on the time period for generating the sequence, the vibration of the offshore wind turbine under test is continuously monitored by a vibration sensor installed on the bearing of the offshore wind turbine under test, so as to generate a time series of the vibration degree of the offshore wind turbine under test.

[0010] The real-time thermal imaging image sequence is fused with the vibration intensity time sequence to obtain a real-time fused feature sequence;

[0011] Based on the real-time fused feature sequence, the probability of failure of the offshore wind turbine under test is predicted in real time;

[0012] The method further includes:

[0013] Based on thermal imaging equipment, continuous images are taken of the same type of offshore wind turbine under normal operating conditions to generate a reference thermal imaging image sequence of the offshore wind turbine to be tested.

[0014] The vibration sensors installed on the bearings of the same type of offshore wind turbine are used to continuously monitor the vibration of the same type of offshore wind turbine, so as to generate a reference vibration time series of the offshore wind turbine to be tested.

[0015] The step of predicting the probability of a fault in the offshore wind turbine under test based on the real-time fused feature sequence includes:

[0016] The reference thermal imaging image sequence and the reference vibration intensity time series are acquired and fused to obtain a reference fusion feature sequence;

[0017] Based on the benchmark fusion feature sequence, and according to the real-time fusion feature sequence, the probability of the offshore wind turbine unit to be detected failing is predicted in real time.

[0018] This invention provides a real-time intelligent fault prediction method for offshore wind turbines, comprising: continuously capturing images of the operating offshore wind turbine under test using a thermal imaging device according to set shooting parameters to generate a real-time thermal imaging image sequence of the offshore wind turbine under test; obtaining the start timestamp of the continuous shooting and creating a sequence generation time period based on the start timestamp; continuously monitoring the vibration of the offshore wind turbine under test using vibration sensors installed on the bearings of the offshore wind turbine under test based on the sequence generation time period to generate a vibration intensity time series of the offshore wind turbine under test; fusing the real-time thermal imaging image sequence with the vibration intensity time series to obtain a real-time fused feature sequence; and predicting the probability of fault occurrence of the offshore wind turbine under test in real time based on the real-time fused feature sequence. By continuously capturing thermal imaging images and monitoring vibration intensity, the operating status of the wind turbine can be monitored in real time, which helps to detect abnormalities in the operation of the unit in a timely manner, thereby enabling preventive maintenance and repair, avoiding the occurrence of faults or mitigating the impact of faults on the operation of the unit. Furthermore, by fusing real-time thermal imaging image sequences and unit vibration time series, more comprehensive information on the unit's operating status can be obtained. This helps to capture fault signals that might be missed by single data points, thereby improving the accuracy and reliability of real-time intelligent fault prediction. In addition, real-time intelligent fault prediction based on fused feature sequences allows for the development of more precise and optimized maintenance strategies. This not only reduces unnecessary maintenance costs but also ensures the unit operates in optimal condition, improving overall operational efficiency. Moreover, real-time monitoring of the unit's operating status and real-time intelligent fault prediction enable the timely detection and handling of potential safety hazards, thus ensuring the safe operation of the unit. Attached Figure Description

[0019] The accompanying drawings, which form part of this application, are used to provide a further understanding of the application and to make other features, objects, and advantages of the application more apparent. The illustrative embodiments and descriptions of the accompanying drawings are used to explain the application and do not constitute an undue limitation of the application. In the drawings:

[0020] Figure 1 This is a schematic diagram of a real-time intelligent fault prediction method for offshore wind turbines according to an embodiment of this application. Detailed Implementation

[0021] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present application.

[0022] Figure 1 This is a flowchart illustrating a real-time intelligent fault prediction method for offshore wind turbines according to an embodiment of this application. Figure 1 As shown, it includes:

[0023] Based on the set shooting parameters and the thermal imaging equipment, the offshore wind turbine under test is continuously photographed to generate a real-time thermal imaging image sequence of the offshore wind turbine under test.

[0024] Obtain the start timestamp of the continuous shooting, and create a sequence generation time period based on the start timestamp;

[0025] Based on the time period for generating the sequence, the vibration of the offshore wind turbine under test is continuously monitored by a vibration sensor installed on the bearing of the offshore wind turbine under test, so as to generate a time series of the vibration degree of the offshore wind turbine under test.

[0026] The real-time thermal imaging image sequence is fused with the vibration intensity time sequence to obtain a real-time fused feature sequence;

[0027] Based on the real-time fused feature sequence, the probability of failure of the offshore wind turbine under test is predicted in real time.

[0028] In this embodiment, by continuously capturing thermal images and monitoring vibration levels, the operating status of the wind turbine can be monitored in real time. This allows for the timely detection of anomalies during turbine operation, enabling preventative maintenance and repair, and preventing or mitigating the impact of faults on turbine operation. Furthermore, by fusing real-time thermal imaging image sequences and turbine vibration time series, more comprehensive information on the turbine's operating status can be obtained, helping to capture fault signals that might be missed by single data points, thereby improving the accuracy and reliability of real-time intelligent fault prediction. Additionally, real-time intelligent fault prediction based on real-time fused feature sequences allows for the development of more precise and optimized maintenance strategies, reducing unnecessary maintenance costs and ensuring the turbine operates in optimal condition, thus improving overall operating efficiency. Moreover, real-time monitoring of the turbine's operating status and real-time intelligent fault prediction enable the timely detection and handling of potential safety hazards, thereby ensuring the safe operation of the turbine.

[0029] This application provides a code snippet for product implementation:

[0030] import numpy as np

[0031] import pandas as pd

[0032] from datetime import datetime, timedelta

[0033] from sklearn.ensemble import RandomForestClassifier

[0034] # Simulation Data Generation

[0035] def generate_simulated_data(num_images, num_vibrations, sequence_duration):

[0036] # Generate simulated thermal imaging image sequence data

[0037] thermal_images = np.random.rand(num_images, 100, 100)

[0038] # Generate simulated vibration time series data

[0039] start_time = datetime.now()

[0040] end_time = start_time + timedelta(seconds=sequence_duration)

[0041] time_stamps = pd.date_range(start=start_time, end=end_time,periods=num_vibrations)

[0042] vibrations = np.random.rand(num_vibrations) # Assuming the vibration level is a random number between 0 and 1

[0043] return thermal_images, time_stamps, vibrations

[0044] # Data Fusion

[0045] def fuse_data(thermal_images, vibrations):

[0046] #Use the average value of the image sequence and the average value of the vibration sequence as fusion features

[0047] fused_feature = np.mean(thermal_images), np.mean(vibrations)

[0048] return fused_feature

[0049] # Real-time intelligent fault prediction

[0050] def predict_fault_probability(fused_features, model):

[0051] # Using machine learning models for prediction

[0052] fault_probability = model.predict_proba(fused_features)[:, 1]

[0053] return fault_probability

[0054] # Main Process

[0055] def main():

[0056] # Setting parameters

[0057] num_images = 100 # Take 100 thermal images consecutively

[0058] num_vibrations = 1000 # Generate 1000 vibration data points

[0059] sequence_duration = 60 # Vibration monitoring lasts for 60 seconds

[0060] # Generate simulation data

[0061] thermal_images,time_stamps,vibrations=generate_simulated_data(num_images, num_vibrations, sequence_duration)

[0062] # Data Fusion

[0063] fused_feature = fuse_data(thermal_images, vibrations)

[0064] # Create and train a real-time intelligent fault prediction model

[0065] model = RandomForestClassifier()

[0066] # model.fit(X_train, y_train)

[0067] # Predicting the probability of failure

[0068] fault_probability = predict_fault_probability(np.array([fused_feature]), model)

[0069] print(f"Predicted fault probability: {fault_probability[0]}")

[0070] In this embodiment, the `fuse_data` function fuses the thermal imaging image sequence and the vibration time series data into a single feature vector. The average of the two sequences is used as the fused feature. Furthermore, the `predict_fault_probability` function uses a machine learning model (random forest as an example) to predict the failure probability of the fused feature. In practical applications, the model needs to be trained with real data beforehand.

[0071] Optionally, the step of continuously capturing images of the offshore wind turbine under test based on the set shooting parameters and using a thermal imaging device to generate a thermal imaging image sequence of the offshore wind turbine under test includes: adjusting the rotation angle and rotation speed of the scanner in the thermal imaging device according to the set shooting parameters to continuously capture images of the offshore wind turbine under test from multiple angles to generate a thermal imaging image sequence of the offshore wind turbine under test.

[0072] In this embodiment, by adjusting the scanner's rotation angle and speed, the thermal imaging device can capture thermal images of offshore wind turbines from different angles and sides. This multi-angle imaging helps to comprehensively monitor the thermal distribution of the turbine, thereby more accurately identifying potential fault points or abnormal hot areas. Furthermore, continuous multi-angle imaging can capture the thermal characteristics of various parts of the turbine, including hard-to-observe hidden areas, helping to reduce fault omissions due to shooting angle limitations and improving the accuracy and reliability of fault detection. In addition, the image sequence generated by multi-angle imaging contains more dimensional thermal information, which can provide richer features in subsequent data fusion and real-time intelligent fault prediction, helping machine learning models learn the thermal behavior patterns of the turbine from multiple angles, thereby improving the accuracy of real-time intelligent fault prediction. Moreover, offshore wind turbines are typically located in complex environments, affected by wind, waves, salt spray, and other factors. Multi-angle imaging can better adapt to these complex environments, reducing the interference and limitations that may occur with single-angle imaging by capturing images from different angles. Finally, by reasonably setting the scanner's rotation angle and speed, the imaging parameters can be optimized, improving imaging efficiency and reducing invalid or repetitive imaging. This helps to acquire more valuable thermal imaging images under limited resource conditions, providing richer data support for real-time intelligent fault prediction.

[0073] This application provides a code snippet for product implementation:

[0074] import time

[0075] from thermal_camera_library import ThermalCamera

[0076] # Set shooting parameters

[0077] rotation_angles = [0, 30, 60, 90, 120, 150, 180] # List of rotation angles

[0078] rotation_speed = 10 # Rotation speed, unit: degrees / second

[0079] capture_interval = 2 # The interval between shots after each rotation, in seconds

[0080] # Initialize thermal imaging equipment

[0081] camera = ThermalCamera(device_address='COM1') # The device is connected via serial port, address is COM1

[0082] camera.initialize()

[0083] # Set the scanner rotation parameters

[0084] camera.set_rotation_speed(rotation_speed)

[0085] # Continuous multi-angle shooting function

[0086] def continuous_multi_angle_capture(camera, rotation_angles, capture_interval):

[0087] images = [] # Store the captured image sequence

[0088] for angle in rotation_angles:

[0089] camera.set_rotation_angle(angle) # Set the rotation angle of the scanner

[0090] time.sleep(capture_interval) # Wait for the capture interval to ensure stable shooting.

[0091] image = camera.capture_image() # Capture thermal image

[0092] images.append(image) # Add the captured image to the sequence.

[0093] return images

[0094] # Calling a function to perform continuous multi-angle shooting

[0095] thermal_images_sequence = continuous_multi_angle_capture(camera,rotation_angles, capture_interval)

[0096] # Turn off thermal imaging equipment

[0097] camera.close()

[0098] # Output the number of captured images to verify the shooting process.

[0099] print (f"Captured {len(thermal_images_sequence)} thermal images for the wind turbine conversion unit.")

[0100] In this embodiment, the code first introduces a hypothetical thermal imaging device library (ThermalCamera), initializes the thermal imaging device, and sets its rotation speed. A function `continuous_multi_angle_capture` is defined, which accepts a thermal imaging device object, a list of rotation angles, and an image capture interval as parameters. Inside this function, the list of rotation angles is iterated, the scanner's rotation angle is set for each angle, and the specified image capture interval is waited for to ensure device stability. The `capture_image` method is used to capture thermal images, and the captured images are added to an image sequence list. The function returns the sequence of captured thermal images. In the main flow, the `continuous_multi_angle_capture` function is called to take images, and the thermal imaging device is then shut down. Finally, the number of captured images is output to verify the capturing process and to allow for subsequent thermal image analysis and processing.

[0101] Optionally, the method further includes: continuously photographing the same type of offshore wind turbine under normal operating conditions using a thermal imaging device to generate a reference thermal imaging image sequence of the offshore wind turbine to be tested; and continuously monitoring the vibration of the same type of offshore wind turbine using a vibration sensor installed on the bearing of the same type of offshore wind turbine to generate a reference vibration degree time series of the offshore wind turbine to be tested.

[0102] In this embodiment, a reference thermal imaging image sequence of the same type of offshore wind turbine under normal operating conditions is generated, providing a comparative benchmark for subsequent fault detection. By comparing the thermal imaging images with those of the turbine under test, abnormal hot zones or temperature changes can be more easily identified, thereby quickly locating potential faults. Furthermore, by combining data from vibration sensors, the operating status of the turbine can be comprehensively analyzed from multiple dimensions. Thermal imaging data reflects the temperature distribution of the turbine, while vibration data provides dynamic information about the turbine during operation. Combining the two allows for a more accurate determination of whether a fault exists in the turbine and the specific location of the fault. Additionally, by continuously monitoring the vibration intensity time series of the same type of turbine, a correspondence between vibration patterns and the turbine's health status can be established. This correspondence can serve as the basis for predictive models to predict potential future faults in the turbine under test, thereby enabling preventative maintenance. Moreover, by comparing the benchmark data and the data under test, it is possible to more accurately determine which turbines require priority for inspection or maintenance, optimizing resource allocation and improving the operation and maintenance efficiency of the wind farm. Finally, by comprehensively applying thermal imaging and vibration monitoring technologies, a more comprehensive and reliable fault detection system can be built, improving the overall operational reliability of wind farms and reducing downtime and economic losses caused by faults.

[0103] This application provides a code snippet for product implementation:

[0104] import time

[0105] from thermal_camera_library import ThermalCamera # Thermal imaging equipment library

[0106] from vibration_sensor_library import VibrationSensor # Vibration sensor library

[0107] # Initialize thermal imaging equipment and vibration sensor

[0108] thermal_camera = ThermalCamera(device_address='COM1') vibration_sensor = VibrationSensor(port='COM2')

[0109] # Function: Generates a sequence of baseline thermal imaging images

[0110] def generate_baseline_thermal_images(camera, duration, interval):

[0111] images = []

[0112] start_time = time.time()

[0113] while (time.time() - start_time) <duration:

[0114] image = camera.capture_image()

[0115] images.append(image)

[0116] time.sleep(interval) # Wait for the specified interval before taking the next photo.

[0117] return images

[0118] # Function: Generates a time series of vibration levels

[0119] def generate_vibration_data(sensor, duration, interval):

[0120] vibration_data = []

[0121] start_time = time.time()

[0122] while (time.time() - start_time) <duration:

[0123] vibration_level = sensor.read_vibration_level()

[0124] vibration_data.append(vibration_level)

[0125] time.sleep(interval) # Wait for the specified interval before reading again.

[0126] return vibration_data

[0127] # Set shooting and monitoring parameters

[0128] duration = 300 # Monitoring duration, in seconds

[0129] interval = 5 # Interval between shooting and reading, in seconds

[0130] # Generate a benchmark thermal imaging image sequence

[0131] baseline_thermal_images=generate_baseline_thermal_images(thermal_camera, duration, interval)

[0132] # Generate vibration intensity time series

[0133] baseline_vibration_data=generate_vibration_data(vibration_sensor,duration, interval)

[0134] # Turn off devices and sensors

[0135] thermal_camera.close()

[0136] vibration_sensor.close()

[0137] In this embodiment, two libraries are used: ThermalCameraLibrary for controlling the thermal imaging equipment and VibrationSensorLibrary for reading data from the vibration sensor. These devices are initialized, and their communication interface with the computer is set up. Next, two functions, generate_baseline_thermal_images and generate_vibration_data, are defined to generate a sequence of thermal imaging images and a time series of vibration levels, respectively. Both functions use a loop to continuously capture images or read vibration data until a set duration is reached. The monitoring duration and the interval between each capture or read are set. Then, these two functions are called to generate baseline data for the same model of offshore wind turbine under normal operating conditions. After data generation is complete, the thermal imaging equipment and vibration sensor are shut down to release resources. Finally, the generated data can be saved to a file or used for subsequent analysis and processing.

[0138] Optionally, the step of predicting the probability of failure of the offshore wind turbine under test in real time based on the real-time fused feature sequence includes: acquiring the reference thermal imaging image sequence and the reference vibration degree time sequence and fusing them to obtain a reference fused feature sequence; and predicting the probability of failure of the offshore wind turbine under test in real time based on the reference fused feature sequence and the real-time fused feature sequence.

[0139] In this embodiment, by fusing thermal imaging image sequences with vibration intensity time series, this scheme can comprehensively utilize information provided by different sensors. Thermal imaging images reflect the temperature distribution on the turbine surface, while vibration data provides dynamic information on the turbine's operating status. Combining the two allows for a more comprehensive and accurate description of the turbine's operating condition, thereby improving the accuracy of real-time intelligent fault prediction. Furthermore, by acquiring the fused feature sequence in real time, this scheme can achieve real-time status monitoring and real-time intelligent fault prediction of offshore wind turbines, helping to promptly detect potential faults, prevent turbine downtime, and reduce maintenance costs. In addition, by fusing thermal imaging and vibration data, this scheme can comprehensively consider multiple fault indication features within a single framework, avoiding information redundancy or omissions that may occur when analyzing each data source individually, enabling rapid fault location and improving fault diagnosis efficiency. Moreover, due to the combination of data from multiple sensors, this scheme has stronger robustness to single sensor failures or data anomalies. Even if one sensor malfunctions, data from other sensors can still be used for real-time intelligent fault prediction, reducing the system's dependence on a single data source. Finally, by automatically acquiring real-time fusion feature sequences and performing real-time intelligent fault prediction, the realization of intelligent operation and maintenance of wind power units is ensured, reducing the need for manual intervention, improving operation and maintenance efficiency, reducing operation and maintenance costs, and enhancing the operational reliability and economy of the entire wind farm.

[0140] This application provides a code snippet for product implementation:

[0141] import numpy as np

[0142] from sklearn.preprocessing import StandardScaler

[0143] from sklearn.ensemble import RandomForestClassifier

[0144] baseline_thermal_images = np.random.rand(100, 64, 64)

[0145] baseline_vibration_data = np.random.rand(100, 10)

[0146] def get_real_time_fused_features():

[0147] return np.random.rand(1, 100)

[0148] # Feature fusion function

[0149] def fuse_features(thermal_image, vibration_data):

[0150] flattened_thermal = thermal_image.flatten()

[0151] fused_features = np.concatenate([flattened_thermal, vibration_data])

[0152] return fused_features

[0153] # Benchmark Feature Fusion

[0154] baseline_fused_features = [fuse_features(img, vib) for img, vib inzip(baseline_thermal_images, baseline_vibration_data)]

[0155] baseline_fused_features = np.array(baseline_fused_features)

[0156] # Data Standardization

[0157] scaler = StandardScaler()

[0158] baseline_fused_features_scaled = scaler.fit_transform(baseline_fused_features)

[0159] # Using a random forest classifier as a real-time intelligent fault prediction model

[0160] model = RandomForestClassifier()

[0161] labels = np.random.randint(0, 2, size=len(baseline_fused_features_scaled)) # 0 indicates normal, 1 indicates fault

[0162] # Training Model

[0163] model.fit(baseline_fused_features_scaled, labels)

[0164] # Predict the probability of a malfunction in the unit under test

[0165] def predict_failure_probability():

[0166] real_time_fused_features = get_real_time_fused_features()

[0167] real_time_fused_features_scaled = scaler.transform(real_time_fused_features)

[0168] prediction = model.predict_proba(real_time_fused_features_scaled)[0][1] # Get the probability of the fault

[0169] return prediction

[0170] # Calling a function to predict probabilities

[0171] failure_probability = predict_failure_probability()

[0172] print(f"Predicted probability of failure: {failure_probability:.2%}")

[0173] In this embodiment, the code first simulates a baseline thermal imaging image sequence and a vibration intensity time series, and assumes a method for acquiring the real-time fused feature sequence. Next, a feature fusion function is defined, which flattens the image data and concatenates it with the vibration data to form a long feature vector. Then, feature fusion is performed on the baseline data, and the fused features are standardized to eliminate scale differences between different features. A random forest classifier is used as the real-time intelligent fault prediction model, assuming corresponding fault labels to train the model. In practical applications, these labels are usually generated through expert annotation or historical data. A function `predict_failure_probability` is defined, which uses the trained model to predict the probability of a fault in the unit under inspection. Finally, the function is called and the prediction result is output.

[0174] Optionally, the step of predicting the probability of a fault in the offshore wind turbine under test in real time based on the benchmark fused feature sequence and the real-time fused feature sequence includes: mapping the benchmark fused feature sequence and the real-time fused feature sequence to the same feature space to obtain the benchmark fused feature vector set and the real-time fused feature vector set respectively; and predicting the probability of a fault in the offshore wind turbine under test in real time based on the benchmark fused feature vector set and the real-time fused feature vector set.

[0175] In this embodiment, mapping the baseline fused feature sequence and the real-time fused feature sequence to the same feature space eliminates potential scale differences and dimensional inconsistencies, ensuring that features from different sources participate fairly in subsequent analysis and comparison, thus improving prediction accuracy. Furthermore, mapping features to the same space facilitates real-time intelligent fault prediction using existing machine learning algorithms and models. This avoids cumbersome feature transformation and matching processes, improving computational efficiency and making predictions faster and more real-time. Additionally, within the same feature space, the baseline fused feature vector set and the real-time fused feature vector set can be directly compared and analyzed, enabling timely detection of anomalies or deviations from the baseline pattern in real-time data, thereby accurately predicting fault occurrence. Moreover, mapping features from different time points to the same space allows for the construction of more robust and generalized prediction models. Such models better adapt to data changes under different conditions, improving prediction reliability and stability. Finally, within the same feature space, the relationships and patterns between features are more easily interpreted and visualized, facilitating understanding the internal mechanisms of unit operation and identifying potential fault modes.

[0176] This application provides a code snippet for product implementation:

[0177] import numpy as np

[0178] from sklearn.preprocessing import StandardScaler

[0179] from sklearn.neighbors import LocalOutlierFactor

[0180] from sklearn.metrics import pairwise_distances_min_min

[0181] def get_real_time_fused_features():

[0182] return np.random.rand(1, 100)

[0183] baseline_fused_features = np.random.rand(100, 100)

[0184] # Data standardization to ensure they are on the same scale

[0185] scaler = StandardScaler()

[0186] baseline_fused_features_scaled=scaler.fit_transform(baseline_fused_features)

[0187] # Real-time fused features also need to be transformed using the same scaler to ensure they are in the same feature space.

[0188] real_time_fused_features = get_real_time_fused_features()

[0189] real_time_fused_features_scaled = scaler.transform(real_time_fused_features)

[0190] # Treat the standardized features as a set of feature vectors

[0191] baseline_feature_vectors = baseline_fused_features_scaled

[0192] real_time_feature_vector = real_time_fused_features_scaled[0]

[0193] # Using the Local Anomaly Factor Algorithm to Detect the Anomaly of Real-Time Feature Vectors Relative to the Baseline Feature Vectors

[0194] lof = LocalOutlierFactor(n_neighbors=20, contamination=0.1)

[0195] y_pred = lof.fit_predict(baseline_feature_vectors)

[0196] # Calculate the minimum distance from the real-time feature vector to all vectors in the baseline feature vector set.

[0197] distances = pairwise_distances_min_min(baseline_feature_vectors,real_time_feature_vector)

[0198] failure_probability = 1 / (1 + distances)

[0199] # Output the predicted probability

[0200] print(f"Predicted probability of failure: {failure_probability:.2%}")

[0201] In this embodiment, the baseline fused feature sequence is first standardized to ensure it is on the same scale. Next, real-time fused features are acquired and processed using the same normalizer to ensure they reside in the same feature space as the baseline features. Then, the Local Outlier Factor (LOF) algorithm is used to detect the anomaly degree of the real-time feature vector within the baseline feature vector set. The LOF algorithm measures the local density deviation of a sample point relative to other sample points in its neighborhood, thus determining whether it is an outlier. The minimum distance from the real-time feature vector to all vectors in the baseline feature vector set is calculated; this distance serves as a measure of the similarity between the real-time feature vector and the baseline feature set. Based on the distance between the real-time feature vector and the baseline feature set, the probability of a fault in the wind turbine unit under test is calculated.

[0202] Optionally, the step of predicting the probability of a fault in the offshore wind turbine under test in real time based on the benchmark fused feature vector set and the real-time fused feature vector set includes: calculating the covariance matrix of the benchmark fused feature vector set to obtain the kernel density function of the benchmark fused feature vector set; mapping the real-time fused feature vector set onto the kernel density function of the benchmark fused feature vector set to calculate the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set; and predicting the probability of a fault in the offshore wind turbine under test in real time based on the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set.

[0203] In this embodiment, by calculating the covariance matrix of the benchmark fused feature vector set and constructing its kernel density description, the distribution characteristics of the benchmark data can be more accurately reflected. Furthermore, mapping the real-time fused feature vector set to the kernel density function of the benchmark fused feature vector set allows for the calculation of the position of the real-time data within the benchmark data distribution. By comparing the kernel density description of the real-time data with the distribution of the benchmark data, anomalies or deviations in the real-time data can be sensitively detected, thereby enabling timely discovery of potential faults. In addition, kernel density estimation does not rely on specific distribution assumptions of the data, thus enabling it to handle various complex and nonlinear data distributions and more flexibly address the diversity and uncertainty of wind turbine operating data. Moreover, the kernel density estimation results can be easily visualized, intuitively showing the distribution differences between real-time data and benchmark data, which helps enhance the interpretability of real-time intelligent fault prediction results, making it easier for maintenance personnel to understand the reasons behind the prediction results. Finally, kernel density estimation has a certain robustness to noise and outliers, resisting interference factors in the data to a certain extent, making the scheme more stable and reliable in practical applications.

[0204] This application provides a code snippet for product implementation:

[0205] import numpy as np

[0206] from scipy.stats import gaussian_kde

[0207] baseline_feature_vectors=np.random.rand(100, 100)real_time_feature_vector = np.random.rand(1, 100)

[0208] # Calculate the covariance matrix and mean of the benchmark fused eigenvector set

[0209] cov_matrix = np.cov(baseline_feature_vectors, rowvar=False)

[0210] mean_vector = np.mean(baseline_feature_vectors, axis=0)

[0211] # Create a kernel density estimation object

[0212] kde = gaussian_kde(baseline_feature_vectors.T)

[0213] # Calculate the value of the real-time fused feature vector on the baseline kernel density function

[0214] rt_density = kde.evaluate(real_time_feature_vector.T)

[0215] # Predict the failure probability based on the value of the real-time feature vector in the benchmark kernel density function.

[0216] failure_probability = 1 - rt_density

[0217] # Output the predicted probability

[0218] print(f"Predicted probability of failure: {failure_probability:.2%}")

[0219] In this embodiment, the code first calculates the covariance matrix and mean of the baseline fused feature vector set, which are necessary statistics for constructing the kernel density estimation model. Then, the baseline feature vector set is fitted using a Gaussian_kde object to obtain the kernel density function of the baseline data. Since the feature vector set follows a Gaussian distribution, a Gaussian kernel is used for density estimation. Next, the real-time fused feature vectors are mapped onto the baseline kernel density function, and the kernel density value of the real-time feature vectors in the baseline data distribution is calculated. Based on the kernel density value of the real-time feature vectors, the probability of a fault in the wind turbine unit under test is predicted. The lower the density value, the higher the probability of a fault. Finally, the predicted probability value is output for maintenance personnel or automated systems to provide subsequent fault warnings or decision support.

[0220] Optionally, mapping the real-time fused feature vector set to the kernel density function of the benchmark fused feature vector set to calculate the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set includes: substituting the real-time fused feature vector set as an independent variable into the kernel density function of the benchmark fused feature vector set to calculate the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set; predicting the probability of failure of the offshore wind turbine under test in real time based on the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set includes: statistically analyzing the skewness distribution and kurtosis distribution of the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set; comparing the skewness distribution and the kurtosis distribution with set skewness distribution thresholds and kurtosis distribution thresholds respectively to calculate the skewness distribution distortion factor and the kurtosis distribution distortion factor; and predicting the probability of failure of the offshore wind turbine under test based on the skewness distribution distortion factor and the kurtosis distribution distortion factor.

[0221] In this embodiment, by directly substituting the real-time fused feature vector set as an independent variable into the kernel density function of the benchmark fused feature vector set, the accuracy of the mapping can be ensured, thereby obtaining the precise position of the real-time data within the benchmark data distribution. Furthermore, skewness and kurtosis distributions are used to describe the distribution of real-time data within the benchmark data, taking into account the morphological characteristics of the data distribution. Skewness reflects the symmetry of the distribution, while kurtosis reflects the steepness or flatness of the distribution. These two indicators can more comprehensively characterize the statistical properties of the data, thus more accurately predicting the probability of failure. In addition, by comparing the calculated skewness and kurtosis distributions with set thresholds, it is possible to intuitively determine whether the distribution of real-time data deviates from the normal range. This threshold comparison method is simple, easy to understand, and easy to implement. Moreover, by calculating the skewness and kurtosis distortion factors, the degree of deviation between the real-time data distribution and the benchmark data distribution can be quantified. These distortion factors can sensitively capture abnormal changes in real-time data, thereby promptly identifying potential failure risks. Finally, using skewness and kurtosis as statistical measures to describe the distribution characteristics of the data makes the prediction results highly interpretable. Operations and maintenance personnel can use changes in these statistics to understand and analyze the causes and trends of failures.

[0222] This application provides a code snippet for product implementation:

[0223] import numpy as np

[0224] from scipy.stats import norm, skew, kurtosis

[0225] baseline_feature_vectors = np.random.rand(100, 100)

[0226] real_time_feature_vector = np.random.rand(1, 100)

[0227] # Calculate the kernel density estimate of the benchmark fused feature vector set

[0228] from scipy.stats import gaussian_kde

[0229] kde = gaussian_kde(baseline_feature_vectors.T)

[0230] # Map the real-time fused feature vector set to the kernel density function

[0231] rt_density = kde.evaluate(real_time_feature_vector.T)

[0232] # Calculate the skewness and kurtosis of the kernel density description of the real-time fused feature vector set

[0233] skewness_rt = skew(real_time_feature_vector.flatten())

[0234] kurtosis_rt = kurtosis(real_time_feature_vector.flatten())

[0235] # Set thresholds for skewness and kurtosis distributions

[0236] skew_threshold = 0.5 # Assumed skewness threshold

[0237] kurtosis_threshold = 3.0 # Assumed kurtosis threshold

[0238] # Calculate the distortion factor of skewness distribution and the distortion factor of kurtosis distribution

[0239] skew_distortion_factor = abs(skewness_rt) / skew_threshold

[0240] kurtosis_distortion_factor=abs(kurtosis_rt) / kurtosis_threshold

[0241] # Predicting failure probability based on distortion factor

[0242] failure_probability = (skew_distortion_factor + kurtosis_distortion_factor) / 2

[0243] # Output the predicted probability

[0244] print(f"Predicted probability of failure: {failure_probability:.2%}")

[0245] In this embodiment, the code first uses Gaussian kernel density estimation to fit the benchmark fused feature vector set, obtaining a kernel density function that describes the distribution of the benchmark data. Next, the real-time fused feature vector set is input as an independent variable into the kernel density function to calculate the kernel density value of the real-time data in the benchmark data distribution. This step is crucial for comparing the real-time data with the benchmark data. Then, the skewness and kurtosis distributions of the real-time data are calculated. Skewness reflects the symmetry of the data distribution, while kurtosis describes the steepness or flatness of the distribution. These two statistics help understand the distribution characteristics of the real-time data. Subsequently, the calculated skewness and kurtosis are compared with set thresholds to calculate the skewness and kurtosis distortion factors. These distortion factors quantify the degree of deviation between the real-time data distribution and the benchmark data distribution. Finally, the probability of a fault in the wind turbine unit under test is predicted based on the distortion factors. The predicted probability value is output for maintenance personnel or automation systems to provide subsequent fault warnings or decision support.

[0246] Optionally, predicting the probability of failure of the offshore wind turbine under test based on the skewness distribution distortion factor and the kurtosis distribution distortion factor includes: performing gradient-based multiple linear regression on the skewness distribution distortion factor and the kurtosis distribution distortion factor to obtain gradient-based regression results; and predicting the probability of failure of the offshore wind turbine under test based on the gradient-based regression results.

[0247] In this embodiment, gradient-based multiple linear regression allows the model to automatically adjust the weights of each feature (i.e., distortion factors) during training to better fit failure modes in historical data. This typically improves the accuracy of the prediction model, making it more accurately reflect the probability of actual failures. Furthermore, multiple linear regression can consider the potential correlation between skewed and kurtosis-based distortion factors. This means the model considers not only the individual impact of each factor on the failure probability but also their combined effects, resulting in a more comprehensive prediction. Additionally, the gradient-based multiple linear regression model can output coefficients for each feature, reflecting the contribution of each factor to the failure probability. This makes the prediction results more interpretable, allowing maintenance personnel to more easily understand which factors have led to an increase in the failure probability, thus enabling targeted maintenance and management. Moreover, since the model is trained on historical data, it can automatically adjust as data is updated to adapt to new operating environments and failure modes, making the model highly adaptable and able to cope with various changes that may occur during the operation of wind turbine units. Finally, the prediction results obtained through multiple linear regression are continuous probability values, rather than simple classification labels. This makes the prediction results richer and more detailed, providing a more accurate assessment of failure risks and helping maintenance personnel to develop more refined maintenance plans.

[0248] This application provides a code snippet for product implementation:

[0249] import numpy as np

[0250] from sklearn.linear_model import LinearRegression

[0251] from sklearn.preprocessing import StandardScaler

[0252] skew_distortion_factors=np.array([...]) kurtosis_distortion_factors=np.array([...])

[0253] # Combine two distortion factors as the feature matrix

[0254] X=np.column_stack((skew_distortion_factors, kurtosis_distortion_factors))

[0255] y = np.array([...])

[0256] # Data standardization, which typically improves the performance of linear regression models.

[0257] scaler = StandardScaler()

[0258] X_scaled = scaler.fit_transform(X)

[0259] # Create and train a multiple linear regression model

[0260] reg = LinearRegression()

[0261] reg.fit(X_scaled, y)

[0262] new_skew_distortion = [...] # Replace with the new skewness distribution distortion factor

[0263] new_kurtosis_distortion = [...] # Replace with the new kurtosis distortion factor

[0264] # Combine the new distortion factors into a feature vector and then standardize it.

[0265] new_X = np.array([new_skew_distortion, new_kurtosis_distortion]).reshape(1,-1)

[0266] new_X_scaled = scaler.transform(new_X)

[0267] # Use the trained model for prediction

[0268] predicted_probability = reg.predict(new_X_scaled)

[0269] # Output prediction results

[0270] print(f"Predicted probability of failure for the new data:{predicted_probability[0]:.2%}")

[0271] In this embodiment, firstly, skewness and kurtosis distortion factors are prepared as features, and it is assumed that corresponding fault probability labels are obtained from historical data. These data form the basis for model training and prediction. The features are standardized to eliminate potential differences in dimensions and distributions between different features, ensuring that each feature has the same weight during model training. Then, the `LinearRegression` class from the `sklearn` library is used to create a multiple linear regression model, and the model is trained using the prepared features and target variables. Next, skewness and kurtosis distortion factors of new data to be detected are prepared; these will serve as inputs to predict fault probabilities. The features of the new data undergo the same standardization process as the training data to ensure consistency of model input. The trained multiple linear regression model is used to predict the new data, yielding the predicted fault probabilities. Finally, the prediction results are output, which can be used for subsequent fault warnings or decision support.

[0272] Optionally, predicting the probability of failure of the offshore wind turbine under test based on the gradient regression results includes: projecting the gradient regression results into a pre-built fault confidence interval library to obtain a fault probability level estimate; generating a probability quality description based on the fault probability level estimate; and predicting the probability of failure of the offshore wind turbine under test based on the probability quality description.

[0273] In this embodiment, by mapping the gradient regression results to the fault confidence interval library, fault mode information in historical data can be fully utilized to more accurately determine the fault probability level represented by the current data point. This helps reduce the errors that may be caused by a single regression model and improves prediction accuracy. Furthermore, by converting the prediction results into probabilistic quality descriptions, the prediction results become more intuitive and easier to understand. Probabilistic quality descriptions not only provide numerical estimates of fault probabilities but also further describe the distribution of fault probabilities, providing maintenance personnel with richer information and helping them better understand the unit's operating status and fault risks. In addition, probabilistic quality descriptions provide maintenance personnel with quantitative indicators of fault risk, helping to formulate targeted maintenance plans and risk response measures. Simultaneously, based on the probabilistic quality descriptions, fault risks can be compared and assessed for different units or different time periods, providing strong support for management decision-making. Finally, the pre-built fault confidence interval library can be updated as new data accumulates, thereby adapting to changes in the wind turbine operating environment and fault modes, making the prediction model more adaptable and able to cope with various complex situations.

[0274] This application provides a code snippet for product implementation:

[0275] import numpy as np

[0276] gradient_regression_result = 0.5 # This value comes from the model's prediction results and represents the predicted probability.

[0277] fault_confidence_intervals = {

[0278] 'low': (0, 0.3),

[0279] 'medium': (0.3, 0.7),

[0280] 'high': (0.7, 1.0)

[0281] }

[0282] # Projecting onto the fault confidence interval library yields the estimated fault probability level.

[0283] def get_fault_probability_level(result):

[0284] for level, interval in fault_confidence_intervals.items():

[0285] if interval[0]<= result<= interval[1]:

[0286] return level

[0287] return None # Return None if the result is not within any range

[0288] # Generate probability quality descriptions based on probability level predictions

[0289] def generate_probability_quality_description(level):

[0290] descriptions = {

[0291] 'low': 'Low probability of failure, operating condition is good'

[0292] 'medium': 'The probability of failure is moderate; enhanced monitoring is recommended.'

[0293] 'high': 'High probability of failure, requires immediate repair'

[0294] }

[0295] return descriptions.get(level, 'Unable to determine the probability level of failure')

[0296] # Predicting failure probability based on gradient regression results

[0297] fault_level = get_fault_probability_level(gradient_regression_result)

[0298] description = generate_probability_quality_description(fault_level)

[0299] # Output prediction results and probability quality description

[0300] print(f"Predicted fault probability level: {fault_level}")

[0301] print(f"Probability mass description: {description}")

[0302] In the code of this embodiment, firstly, the prediction result obtained from the gradient-based multiple linear regression model represents the probability of a fault occurring in the wind turbine unit under test. Next, a fault confidence interval library is predefined, dividing the probability range into different intervals, each interval corresponding to a fault probability level (such as low, medium, and high).

[0303] Then, a function `get_fault_probability_level` was created. This function takes the prediction result as input and returns the corresponding fault probability level. This is achieved by comparing the prediction result with each interval in the interval library. Further, based on the obtained fault probability level, another function `generate_probability_quality_description` is defined to generate a descriptive string, providing maintenance personnel with intuitive information about the unit's fault risk. Finally, these two functions are called, outputting the prediction result and the probabilistic quality description. This helps maintenance personnel understand the current operating status of the wind turbine units and formulate maintenance plans or take other measures accordingly.

[0304] Optionally, projecting the gradient regression result onto a pre-built fault confidence interval library to obtain a fault probability level estimate includes: constructing a fault confidence interval library, where each interval should correspond to a fault probability range, and all intervals cover possible fault probability levels; using the gradient regression result as a predicted fault probability and comparing it with the fault confidence interval library to obtain a fault probability level estimate.

[0305] In this embodiment, by constructing a fault confidence interval library, continuous fault probability values ​​are divided into several discrete intervals, each corresponding to a specific fault probability level (e.g., low, medium, high). This makes the expression of fault probability clearer and more intuitive, facilitating maintenance personnel to quickly understand the fault risk status of the unit. Furthermore, by mapping the prediction results to predefined fault confidence intervals, the fault probability level of the unit can be quickly determined, thereby simplifying the fault risk management and decision-making process. Maintenance personnel do not need to perform complex probability calculations or analyses; they can take corresponding maintenance measures or risk response strategies based on the predicted values. In addition, the fault confidence interval library can be adjusted and expanded according to actual needs. As new data accumulates and fault modes are discovered, intervals can be updated or added to adapt to the fault probability distribution of different units or different operating environments. This flexibility enables the solution to cope with various complex situations and maintain high prediction accuracy. Moreover, as an independent module, the fault confidence interval library can be easily integrated into existing wind turbine operation and maintenance management systems. Through collaborative work with other functional modules (such as monitoring, alarms, and maintenance plans), comprehensive management and control of fault risks can be achieved. By mapping the prediction results to a predefined interval, the fluctuation of the prediction results caused by model errors or data noise can be reduced, the stability and reliability of the prediction can be improved, the prediction results can be closer to the actual situation, and more accurate fault risk information can be provided to operation and maintenance personnel.

[0306] This application provides a code snippet for product implementation:

[0307] import numpy as np

[0308] gradient_regression_result = 0.65 # Fault probability predicted by the regression model

[0309] # Pre-built fault confidence interval library

[0310] # Each tuple represents the lower and upper bounds of an interval, corresponding to a failure probability level.

[0311] fault_confidence_intervals = {

[0312] 'low': (0.0, 0.3),

[0313] 'medium': (0.3, 0.7),

[0314] 'high': (0.7, 1.0)

[0315] }

[0316] # Project the gradient regression results onto the fault confidence interval library to obtain the fault probability level prediction.

[0317] def project_to_fault_interval(result, intervals):

[0318] for level, interval in intervals.items():

[0319] if interval[0]<= result<= interval[1]:

[0320] return level

[0321] # If no matching interval is found, return unknown.

[0322] return 'unknown'

[0323] # Perform projection operation

[0324] fault_level_prediction=project_to_fault_interval(gradient_regression_result, fault_confidence_intervals)

[0325] # Output the estimated failure probability level

[0326] print(f"The predicted fault level is: {fault_level_prediction}")

[0327] In this embodiment, the code first obtains a prediction result from the gradient regression model, representing the probability of a unit failure. Then, a dictionary `fault_confidence_intervals` is defined, containing multiple intervals, each corresponding to a specific failure probability level (e.g., low, medium, high). Each interval is represented by two floating-point numbers, corresponding to the lower and upper limits of the interval. Next, a function `project_to_fault_interval` is created, which accepts the prediction result and a failure confidence interval library as input. It iterates through each interval in the library, checking if the prediction result falls within that interval. Further, in the projection function, the prediction result is compared with the range of each interval. If the prediction result falls within a certain interval, the failure probability level corresponding to that interval is returned.

[0328] If the prediction does not fall within any interval, a specific value (such as 'unknown') is returned, indicating that the failure probability level cannot be determined. Finally, the projection function is called to project the prediction result onto the fault confidence interval library, thereby obtaining the estimated failure probability level. This estimated value is output for maintenance personnel to refer to.

[0329] Optionally, generating a probabilistic quality description based on the fault probability level estimate includes: constructing a corresponding probabilistic quality function based on the obtained fault probability level estimate to fit the probability relationship between the fault probability level estimate and the fault; and performing statistics on the probabilistic quality function to obtain probabilistic quality information and using it as a probabilistic quality description.

[0330] In this embodiment, the probability quality function not only provides a single estimated level of failure probability but also reflects the shape, central tendency, and dispersion of the probability distribution. This allows maintenance personnel to gain a more comprehensive understanding of the distribution of unit failure risks, enabling them to make more accurate decisions. Furthermore, the probability quality function can calculate specific probability values ​​or ranges at different failure probability levels, helping maintenance personnel to quantitatively assess the magnitude of risks, compare risk differences between different units or under different operating conditions, and provide a basis for developing targeted risk response measures. In addition, decision-making based on probability quality information is more scientific. By analyzing the probability quality function, key points and sensitive factors of failure risks can be identified, allowing for targeted optimization of operating parameters, enhanced monitoring, or other measures to reduce failure risks. Moreover, different maintenance personnel or organizations may have different risk preferences and tolerances. The probability quality description provides detailed probability distribution information, enabling maintenance personnel to choose appropriate risk response measures based on their own risk preferences. Finally, the probability quality description provides specific and quantifiable information, facilitating communication and exchange among maintenance personnel and with other stakeholders. By sharing probabilistic quality information, we can enhance our understanding and awareness of unit failure risks and promote collaborative work and cooperation.

[0331] This application provides a code snippet for product implementation:

[0332] import numpy as np

[0333] from scipy.stats import norm # Import the normal distribution class

[0334] probability_level_prediction = 'medium'

[0335] # Predefined fault confidence interval library and probability mass function parameter mapping

[0336] fault_confidence_intervals = {

[0337] 'low': (0.0, 0.3, norm.mean(0.15), norm.std(0.05)), # The mean and standard deviation are used to construct a normal distribution.

[0338] 'medium': (0.3, 0.7, norm.mean(0.5), norm.std(0.1)),

[0339] 'high': (0.7, 1.0, norm.mean(0.85), norm.std(0.05))

[0340] }

[0341] # Obtain the corresponding probability mass function parameters based on the probability level prediction.

[0342] def get_probability_mass_function_params(prediction, intervals):

[0343] for level, (low, high, mean, std) in intervals.items():

[0344] if prediction == level:

[0345] return mean, std

[0346] return None, None

[0347] # Construct and return the probability mass function

[0348] def build_probability_mass_function(mean, std):

[0349] return norm(mean, std)

[0350] # Perform statistical analysis on the probability mass function to obtain probability mass information.

[0351] def get_probability_mass_info(pmf, num_points=100):

[0352] x = np.linspace(pmf.ppf(0.01), pmf.ppf(0.99), num_points) # Generate evenly spaced x values

[0353] y = pmf.pdf(x) # Calculate the corresponding probability density function value

[0354] return x, y

[0355] # Execute the entire process

[0356] def generate_probability_mass_description(prediction, intervals):

[0357] mean, std = get_probability_mass_function_params(prediction,intervals)

[0358] if mean is not None and std is not None:

[0359] pmf = build_probability_mass_function(mean, std)

[0360] x, y = get_probability_mass_info(pmf)

[0361] return x, y

[0362] else:

[0363] return None, None # Returns None if there is no predicted probability level for a match.

[0364] # Call the function to generate probabilistic quality description

[0365] x_values,y_values=generate_probability_mass_description(probability_level_prediction, fault_confidence_intervals)

[0366] # Output the results or perform further processing (such as plotting).

[0367] if x_values ​​is not None and y_values ​​is not None:

[0368] print("Probability quality description (x value):", x_values)

[0369] print("Probability quality description (y-values):", y_values)

[0370] # You can add code here to plot the probability mass function.

[0371] else:

[0372] print("Unable to generate probability quality description because no matching probability level estimate was found.")

[0373] In this embodiment, a library of predicted probability levels and fault confidence intervals is first defined, where each fault probability level is associated with parameters (mean and standard deviation) of a normal distribution. The `get_probability_mass_function_params` function retrieves the corresponding parameters from the interval library based on the predicted values. Then, the `build_probability_mass_function` function uses these parameters to construct a probability mass function (here, a normal distribution). Next, the `get_probability_mass_info` function calculates the probability density value of the probability mass function within a specific range of x values, generating the x and y values ​​for probability mass information. Finally, the `generate_probability_mass_description` function integrates these steps and returns the probability mass description information.

[0374] Optionally, predicting the probability of failure of the offshore wind turbine under test based on the probability quality description includes: calculating different expected failure probabilities based on the probability quality description; and performing a weighted average of the expected failure probabilities to predict the probability of failure of the offshore wind turbine under test in real time.

[0375] In this embodiment, probabilistic quality descriptions can yield multiple possibilities for failure risk and their corresponding probability distributions. Calculating different expected failure probabilities and weighting them by average allows for a comprehensive consideration of these possibilities, rather than relying solely on a single predicted value, thus providing a more complete reflection of the unit's failure risk. Furthermore, the weighted averaging method can weight the expected failure probabilities according to the importance or confidence level of different probability levels, resulting in more accurate predictions. Higher weights can be assigned to failure scenarios that are more likely to occur or have a higher risk, making the predictions more consistent with reality. Additionally, this scheme allows for adjustments to the calculation of expected failure probabilities and the weighted averaging method based on different probabilistic quality descriptions. As data changes or new information becomes available, the probabilistic quality descriptions can be updated and predictions re-performed to adapt to changes in failure risk under different circumstances. Moreover, calculating the weighted average failure probability provides quantitative decision support for maintenance personnel. They can then develop targeted risk response measures based on the prediction results, optimize maintenance plans, and improve the unit's reliability and operational efficiency. Finally, by using a weighted average of the expected failure probabilities, we can better understand and assess the distribution and trends of unit failure risks, which helps maintenance personnel to develop more effective risk management strategies, identify and resolve potential problems in a timely manner, and reduce the likelihood of failures.

[0376] This application provides a code snippet for product implementation:

[0377] import numpy as np

[0378] # The format is [(failure probability 1, probability mass 1), (failure probability 2, probability mass 2), ...]

[0379] probability_mass_description = [(0.05, 0.2), (0.15, 0.4), (0.3, 0.4)]

[0380] # Calculate the expected failure probability based on the probabilistic quality description.

[0381] def calculate_expected_failure_probabilities(prob_mass_desc):

[0382] expected_probs = []

[0383] for prob, mass in prob_mass_desc:

[0384] expected_probs.append(prob * mass) # Expected failure probability = failure probability * probability mass

[0385] return expected_probs

[0386] # Weighted average of expected failure probabilities

[0387] def weighted_average_failure_probability(expected_probs):

[0388] total_mass = sum(mass for _, mass in probability_mass_description)

[0389] weighted_avg_prob = sum(expected_prob / total_mass for expected_prob in expected_probs)

[0390] return weighted_avg_prob

[0391] # Execute the entire prediction process

[0392] expected_failure_probs=calculate_expected_failure_probabilities(probability_mass_description)

[0393] predicted_failure_probability=weighted_average_failure_probability(expected_failure_probs)

[0394] # Output prediction results

[0395] print("List of expected failure probabilities:", expected_failure_probs)

[0396] print("Predicted failure probability:", predicted_failure_probability)

[0397] In this embodiment, the code first defines a list of probabilistic quality descriptions, which includes different failure probability levels and their corresponding probabilistic qualities. Next, the `calculate_expected_failure_probabilities` function calculates the expected failure probability for each failure probability level by multiplying the failure probability by the probabilistic quality. Then, the `weighted_average_failure_probability` function calculates a weighted average of these expected failure probabilities. This is achieved by first summing all the probabilistic qualities to obtain the total quality, then dividing each expected failure probability by the total quality, and finally summing all the results. Finally, the code calls these two functions to calculate the predicted failure probability and outputs the result.

[0398] Optionally, calculating different expected failure probabilities based on the probability quality description includes: extracting each failure probability level estimate and its corresponding probability from the probability quality description to form a failure description array, which includes the failure probability level estimate and the corresponding occurrence probability; for each failure probability level estimate... and its corresponding probability of occurrence The expected failure probability is calculated as follows: : , where i is greater than 1 and less than or equal to n, n is the number of estimated failure probability levels, and n is an integer greater than 1.

[0399] In this embodiment, by forming a fault description array, the probability level of each possible fault and its probability of occurrence can be visually observed, facilitating a clearer understanding of the risk distribution. Furthermore, using the expected probability calculation formula, the expected fault probability can be accurately obtained, which is a quantitative representation of the entire fault probability distribution and has significant reference value for prediction and decision-making. In addition, this scheme allows consideration of multiple different fault probability level estimates, rather than just a single probability value, making the prediction model more flexible and adaptable to various changing circumstances. Moreover, considering multiple fault probability levels allows for better consideration of risk dispersion. In some cases, while certain high-probability fault events may lead to significant losses, other low-probability fault events may also have a significant impact on the overall risk. Furthermore, the calculated expected fault probability provides decision-makers with quantitative information about potential risks, aiding in the development of targeted risk management strategies and maintenance plans. Finally, this scheme provides a basic calculation framework, allowing for the addition of more fault probability level estimates or the use of more complex calculation methods to optimize the prediction results as needed.

[0400] This application provides a code snippet for product implementation:

[0401] probability_mass_description = [(0.05, 0.2), (0.1, 0.3), (0.2, 0.5)]

[0402] # Calculate the expected failure probability based on the probabilistic quality description.

[0403] def calculate_expected_failure_probability(prob_mass_desc):

[0404] # Initialize the expected failure probability to 0

[0405] expected_failure_prob = 0

[0406] # Traverse the probabilistic quality description and calculate the expected failure probability

[0407] for fault_prob, prob in prob_mass_desc:

[0408] expected_failure_prob += fault_prob * prob

[0409] return expected_failure_prob

[0410] # Calculate the expected failure probability

[0411] expected_failure_prob=calculate_expected_failure_probability(probability_mass_description)

[0412] # Output expected failure probability

[0413] print("Expected failure probability:", expected_failure_prob)

[0414] In this embodiment, the code first defines a list of probabilistic quality descriptions, containing the estimated value of each failure probability level and its corresponding probability. Then, a function `calculate_expected_failure_probability` is defined to calculate the expected failure probability. Inside the function, the list of probabilistic quality descriptions is traversed, and the estimated value of each failure probability level and its corresponding probability are multiplied and accumulated into the expected failure probability. Finally, the function returns the calculated expected failure probability. Calling this function outputs the expected failure probability.

[0415] Optionally, the expected failure probability can be weighted and averaged based on the following formula to predict the probability of failure of the offshore wind turbine under test in real time:

[0416] ,in, This indicates the probability that the offshore wind turbine under test will malfunction. This represents the expected failure probability of the j-th fault. denoted by weight, where j is greater than 1 and less than or equal to m, m is the number of expected failure probabilities, and the magnitude of the weight reflects the degree of influence of different expected failure probabilities on the prediction result, m is an integer greater than 1.

[0417] In this embodiment, the weighted average method allows different weights to be assigned to different expected failure probabilities. This reflects the relative importance of different expected failure probabilities in predicting the overall failure probability. For example, some expected failure probabilities derived from more reliable data or more accurate models may be given higher weights. Furthermore, by adjusting the weights, the impact of different expected failure probabilities on the final prediction result can be flexibly controlled. Additionally, the weighted average method provides a clear way to explain how the prediction results were derived. Each expected failure probability and its corresponding weight contribute to the final prediction result, which helps to understand and interpret the source of the prediction results. Moreover, when some expected failure probabilities may be inaccurate due to data anomalies or model bias, by reasonably setting the weights, the weighted average method can reduce the impact of these inaccurate values ​​on the overall prediction result, thereby improving the robustness of the model. Finally, the weighted average method is not only applicable to situations with expected failure probabilities derived from multiple different sources or different models, but also to data collected at different time periods or under different operating conditions; it can be flexibly applied according to the actual situation.

[0418] This application provides a code snippet for product implementation:

[0419] expected_failure_probabilities = [0.03, 0.05, 0.04] # The j-th expected failure probability

[0420] weights = [0.3, 0.5, 0.2] # The corresponding weights, the sum should be 1

[0421] # Calculate the probability of a fault occurring in the offshore wind turbine unit under test.

[0422] def weighted_average_failure_probability(probs, weights):

[0423] The statement `assert len(probs) == len(weights)` means that "the expected failure probability and the number of weights must be equal."

[0424] assert abs(sum(weights) - 1)<1e-6,

[0425] weighted_sum = sum(p * w for p, w in zip(probs, weights))

[0426] return weighted_sum

[0427] # Call the function and output the result

[0428] predicted_failure_probability = weighted_average_failure_probability(expected_failure_probabilities,weights)

[0429] print("Predicted probability of failure of offshore wind turbine:", predicted_failure_probability)

[0430] In this embodiment, a function `weighted_average_failure_probability` is first defined to calculate the weighted average failure probability. The function takes two lists as parameters: a list of expected failure probabilities and a list of corresponding weights. The function ensures the validity of the input data through assertions, namely, that the number of expected failure probabilities and weights are equal, and that the sum of the weights is close to 1. The weighted sum, i.e., the sum of the products of each expected failure probability and its corresponding weight, is calculated using list comprehensions and the `sum` function. The function returns the calculated weighted average as the predicted probability of failure for the offshore wind turbine.

[0431] The above description is merely a preferred embodiment of this application and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of the invention involved in this application is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described inventive concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features with similar functions disclosed in this application.

Claims

1. A real-time intelligent fault prediction method for offshore wind turbine units, characterized in that, include: Based on the set shooting parameters and the thermal imaging equipment, the offshore wind turbine under test is continuously photographed to generate a real-time thermal imaging image sequence of the offshore wind turbine under test. Obtain the start timestamp of the continuous shooting, and create a sequence generation time period based on the start timestamp; Based on the time period for generating the sequence, the vibration of the offshore wind turbine under test is continuously monitored by a vibration sensor installed on the bearing of the offshore wind turbine under test, so as to generate a time series of the vibration degree of the offshore wind turbine under test. The real-time thermal imaging image sequence is fused with the vibration intensity time sequence to obtain a real-time fused feature sequence; Based on the real-time fused feature sequence, the probability of failure of the offshore wind turbine under test is predicted in real time; The method further includes: Based on thermal imaging equipment, continuous images are taken of the same type of offshore wind turbine under normal operating conditions to generate a reference thermal imaging image sequence of the offshore wind turbine to be tested. The vibration sensors installed on the bearings of the same type of offshore wind turbine are used to continuously monitor the vibration of the same type of offshore wind turbine, so as to generate a reference vibration time series of the offshore wind turbine to be tested. The step of predicting the probability of a fault in the offshore wind turbine under test based on the real-time fused feature sequence includes: The reference thermal imaging image sequence and the reference vibration intensity time series are acquired and fused to obtain a reference fusion feature sequence; Based on the benchmark fusion feature sequence, and according to the real-time fusion feature sequence, the probability of the offshore wind turbine unit to be detected failing is predicted in real time.

2. The method according to claim 1, characterized in that, The step of predicting the probability of a fault in the offshore wind turbine under test in real time based on the benchmark fused feature sequence and the real-time fused feature sequence includes: The baseline fusion feature sequence and the real-time fusion feature sequence are mapped to the same feature space to obtain the baseline fusion feature vector set and the real-time fusion feature vector set, respectively. Based on the baseline fusion feature vector set and the real-time fusion feature vector set, the probability of failure of the offshore wind turbine under test is predicted in real time.

3. The method according to claim 2, characterized in that, The step of predicting the probability of a fault in the offshore wind turbine under test in real time based on the benchmark fused feature vector set and the real-time fused feature vector set includes: Calculate the covariance matrix of the benchmark fused feature vector set to obtain the kernel density function of the benchmark fused feature vector set; The real-time fused feature vector set is mapped onto the kernel density function of the benchmark fused feature vector set to calculate the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set; Based on the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set, the probability of failure of the offshore wind turbine to be detected is predicted in real time.

4. The method according to claim 3, characterized in that, The step of mapping the real-time fused feature vector set to the kernel density function of the benchmark fused feature vector set to calculate the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set includes: The real-time fused feature vector set is substituted as an independent variable into the kernel density function of the benchmark fused feature vector set to calculate the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set. The step of predicting the probability of a fault in the offshore wind turbine under test in real time based on the kernel density description of the real-time fused feature vector set in the benchmark fused feature vector set includes: The skewness and kurtosis distributions of the real-time fused feature vector set described by the kernel density in the baseline fused feature vector set are statistically analyzed. The skewness distribution and the kurtosis distribution are compared with the set skewness distribution threshold and kurtosis distribution threshold, respectively, and the skewness distribution distortion factor and kurtosis distribution distortion factor are calculated. Based on the skewness distribution distortion factor and the kurtosis distribution distortion factor, the probability of failure of the offshore wind turbine under test is predicted.

5. The method according to claim 4, characterized in that, The step of predicting the probability of a fault in the offshore wind turbine under test based on the skewness distribution distortion factor and the kurtosis distribution distortion factor includes: Gradientized multiple linear regression is performed on the skewness distribution distortion factor and the kurtosis distribution distortion factor to obtain the gradientized regression results; Based on the gradient regression results, the probability of failure of the offshore wind turbine under test is predicted.

6. The method according to claim 5, characterized in that, The step of predicting the probability of a fault in the offshore wind turbine under test based on the gradient regression results includes: The gradient regression results are projected onto a pre-built fault confidence interval library to obtain a fault probability level estimate. Based on the estimated failure probability level, a probabilistic quality description is generated; Based on the probabilistic quality description, the probability of the offshore wind turbine unit under test malfunctioning is predicted.

7. The method according to claim 6, characterized in that, The generation of a probabilistic quality description based on the estimated failure probability level includes: Based on the obtained fault probability level estimate, a corresponding probability mass function is constructed to fit the fault probability level estimate and the probability relationship of the fault. The probability quality function is statistically analyzed to obtain probability quality information, which is then used as a description of probability quality.

8. The method according to claim 7, characterized in that, The step of predicting the probability of a fault occurring in the offshore wind turbine under test based on the probabilistic quality description includes: Based on the probabilistic quality description, different expected failure probabilities are calculated; The expected failure probabilities are weighted and averaged to predict the probability of failure of the offshore wind turbine under test in real time.

9. The method according to claim 8, characterized in that, The step of calculating different expected failure probabilities based on the probabilistic quality description includes: Each fault probability level estimate and its corresponding probability are extracted from the probability quality description to form a fault description array, which includes the fault probability level estimate and the corresponding occurrence probability. For each failure probability level, the estimated value and its corresponding probability of occurrence The expected failure probability is calculated as follows: : , where i is greater than 1 and less than or equal to n, n is the number of estimated failure probability levels, and n is an integer greater than 1.

10. The method according to claim 9, characterized in that, The expected failure probabilities are weighted and averaged using the following formula to predict the probability of failure of the offshore wind turbine under test in real time: ,in, This indicates the probability that the offshore wind turbine under test will malfunction. This represents the expected failure probability of the j-th fault. denoted by weight, where j is greater than 1 and less than or equal to m, m is the number of expected failure probabilities, and the magnitude of the weight reflects the degree of influence of different expected failure probabilities on the prediction result, m is an integer greater than 1.

Images