METHOD AND SYSTEM FOR BAYESIAN REGRESSION-BASED FAULT DETECTION AND DIAGNOSIS IN WIND-TURBINE SENSORS AND ACTUATORS

Abstract

Disadvantage of existing fault detection approaches is that they fail to diagnose types and magnitudes of faults and to take into consideration uncertainties that arise due to various factors such as, but not limited to, sensor noise and model inaccuracies. System and method disclosed in the embodiments herein provide Bayesian regression-based fault detection and diagnosis in wind turbine sensors and actuators. In the process, the system generates one or more fault signature distributions and associated magnitude and uncertainty, wherein the one or more fault signature distributions is indicative of one or more probable faults in the wind turbine sensor and the actuator.

Description

PRIORITY CLAIM

This U.S. patent application claims priority under 35 U.S.C. § 119 to: India Application No. 202421000058, filed on Jan. 1, 2024. The entire contents of the aforementioned application are incorporated herein by reference.

TECHNICAL FIELD

The disclosure herein generally relates to fault processing, and, more particularly, to a method and system for a Bayesian regression-based fault detection and diagnosis in wind turbine sensors and actuators.

BACKGROUND

Renewable energy sources have more importance in the context of ever increasing energy demand and adverse impact of fossil fuel on environment. Wind energy is such a renewable energy, which is a clean, non-polluting type of energy. The wind energy is harnessed using wind turbines, which has components such as rotor, blades, generator, and so on. Wind turbines, with all the mechanical components, are prone to failure or faulty operations, and hence require regular checks and maintenance. Faults in sensors and actuators are one of the major contributors to overall faults in wind turbine systems.

As with all mechanical systems, faults in wind turbines have characteristic signatures, which can be detected through sensor data acquisition. The effectiveness of a Fault Detection and Diagnosis (FDD) approach depends on how effectively these signatures are detected from the acquired signals. Conventionally, signal processing techniques have been widely employed for FDD. With the emergence of machine learning (ML), various classification-based models and anomaly detection techniques have gained popularity. In general, FDD methods can be classified into model-based or data-driven approaches. Both approaches map sensed operational data to specific faults. Model-based methods for FDD explicitly build an intermediate dynamics model for turbine operations using dynamical equations or using function approximations like neural networks. Given the sensed system state and inputs, faults are identified as some function of the residuals between model-expected values and observed values during current operation. On the other hand, the data-driven approaches typically classify the observed data (as either faulty or normal) using a machine learning or signal processing pipeline. Specifically, these data-driven methods do not use an intermediate dynamics model for turbine operations.

One disadvantage of the existing approaches is that they focus on fault detection alone and fail to diagnose even if a fault is detected, which adversely affects effectiveness with which maintenance can be performed. They provide little to no further information about the type of fault and its magnitude. Pure data-driven methods do not incorporate knowledge of the underlying system dynamics and may struggle with issues related to labeled data. Another disadvantage of the existing approaches is that they fail to take into consideration uncertainties that arise due to various factors such as, but not limited to, sensor noise and model inaccuracies. Providing a measure of uncertainty associated with a detected fault is important in critical systems where false alarms or missed faults can have significant consequences.

SUMMARY

Embodiments of the present disclosure present technological improvements as solutions to one or more of the above-mentioned technical problems recognized by the inventors in conventional systems. For example, in one embodiment, a processor implemented method is provided. The method includes: collecting, via one or more hardware processors, data from a wind turbine as input data; generating, via the one or more hardware processors, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data; determining, using a fault model via the one or more hardware processors, correlation of a measured value of the one or more parameters of the input data with the associated prime values in presence of a plurality of fault signatures; determining a likelihood function, via the one or more hardware processors, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures; generating, using the Bayesian inference model via the one or more hardware processors, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; and generating, via the one or more hardware processors, one or more fault signature distributions and associated magnitude and uncertainty, by processing the posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in a sensor or actuator.

In an embodiment of the method, the input data comprises a plurality of state parameters, wind data, and measured values from the sensor or the actuator.

In another embodiment of the method, the one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine.

In another embodiment of the method, the one or more probable faults are in one or more sensors or actuators of the wind turbine.

In yet another aspect, a system is provided. The system includes one or more hardware processors, a communication interface, and a memory storing a plurality of instructions. The plurality of instructions cause the one or more hardware processors to: collect data from a wind turbine as input data; generate, via the one or more hardware processors, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data; determine, using a fault model via the one or more hardware processors, correlation of a measured value of the one or more parameters of the input data with the associated prime values in presence of a plurality of fault signatures; determine a likelihood function, via the one or more hardware processors, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures; generate, using the Bayesian inference model via the one or more hardware processors, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; and generate, via the one or more hardware processors, one or more fault signature distributions and associated magnitude and uncertainty, by processing the posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in a sensor or actuator.

In an embodiment of the system, the input data comprises a plurality of state parameters, wind data, and measured values from the sensor or the actuator.

In another embodiment of the system, the one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine.

In another embodiment of the system, the one or more probable faults are in one or more sensors or actuators of the wind turbine.

In yet another aspect, a non-transitory computer readable medium is provided. The non-transitory computer readable medium includes a plurality of instructions, which cause one or more hardware processors to: collect data from a wind turbine as input data; generate, via the one or more hardware processors, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data; determine, using a fault model via the one or more hardware processors, correlation of a measured value of the one or more parameters of the input data with the associated prime values in presence of a plurality of fault signatures; determine a likelihood function, via the one or more hardware processors, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures; generate, using the Bayesian inference model via the one or more hardware processors, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; and generate, via the one or more hardware processors, one or more fault signature distributions and associated magnitude and uncertainty, by processing the posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in a sensor or actuator.

In an embodiment of the non-transitory computer readable medium, the input data comprises a plurality of state parameters, wind data, and measured values from the sensor or the actuator.

In another embodiment of the non-transitory computer readable medium, the one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine.

In another embodiment of the non-transitory computer readable medium, the one or more probable faults are in one or more sensors or actuators of the wind turbine. It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention, as claimed.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated in and constitute a part of this disclosure, illustrate exemplary embodiments and, together with the description, serve to explain the disclosed principles:

FIG. 1 illustrates an exemplary system for Bayesian regression based fault detection and diagnosis, according to some embodiments of the present disclosure.

FIG. 2 is a flow diagram depicting steps involved in the process of Bayesian regression based fault detection and diagnosis being performed by the system of FIG. 1, according to some embodiments of the present disclosure.

FIG. 3 is an example architecture of the Bayesian regression architecture of the system of FIG. 1 for an example sensor (rotor speed sensor) and actuator (rotor pitch actuator), in accordance with some embodiments of the present disclosure.

FIGS. 4 through 6 depict graphs with example values associated with the Bayesian regression-based fault detection and diagnosis being performed by the system of FIG. 1, according to some embodiments of the present disclosure.

DETAILED DESCRIPTION OF EMBODIMENTS

Exemplary embodiments are described with reference to the accompanying drawings. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. Wherever convenient, the same reference numbers are used throughout the drawings to refer to the same or like parts. While examples and features of disclosed principles are described herein, modifications, adaptations, and other implementations are possible without departing from the scope of the disclosed embodiments.

One disadvantage of the existing approaches is that they focus on fault detection alone, and fail to diagnose even if a fault is detected, which adversely affects effectiveness with which maintenance can be performed. They provide little to no further information about the type of fault and its magnitude. Pure data-driven methods do not incorporate knowledge of the underlying system dynamics and may struggle with issues related to labeled data. Another disadvantage of the existing approaches is that they fail to take into consideration uncertainties that arise due to various factors such as, but not limited to, sensor noise and model inaccuracies. Providing a measure of uncertainty associated with a detected fault is important in critical systems where false alarms or missed faults can have significant consequences.

In order to solve the aforementioned challenges, embodiments disclosed herein provide a method and system for a Bayesian regression-based fault detection and diagnosis in wind turbine sensors and actuators. The system performs the following steps for the Bayesian regression-based fault detection and diagnosis in wind turbine sensors and actuators:—collect data from a wind turbine as input data; generate, via the one or more hardware processors, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data; determine, using a fault model via the one or more hardware processors, correlation of a measured value of the one or more parameters of the input data with the associated prime values in presence of a plurality of fault signatures; determine a likelihood function, via the one or more hardware processors, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures; generate, using the Bayesian inference model via the one or more hardware processors, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; and generate, via the one or more hardware processors, one or more fault signature distributions and associated magnitude and uncertainty, by processing the posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in a sensor or actuator. The system addresses the cited challenge with the existing approaches by facilitating diagnosis of detected faults which gives their types and magnitudes. The system also takes into consideration various factors/parameters that contribute to uncertainties, thereby addressing another disadvantage of the existing approaches.

Referring now to the drawings, and more particularly to FIG. 1 through FIG. 6, where similar reference characters denote corresponding features consistently throughout the figures, there are shown preferred embodiments and these embodiments are described in the context of the following exemplary system and/or method.

TABLE 1
Notations Used
                      Meaning
Symbol
                      Model of wind turbine dynamics
                      Baseline classification model
B                     Gearbox ratio
Cq                    Rotor torque coefficient
clip(x, a, b)         Clip function   max(min(x, b), a)
E                     Energy
                      Fault formulation model
I                     Integral rotor speed error in pitch
                      control, rad
J                     Moment of inertia, kgm2
Kg                    Generator constant
(KP, KI, θk)          Rotor pitch controller constants
                      Likelihood function
(μ, v2)               Normal distribution with mean
                      μ and variance v2
P                     Power
p                     Probability distribution
                      Rotor radius, m
s                     Wind turbine state vector
                      Truncated normal distribution
(μ, v2, a, b)         with mean parameter μ, variance
                      parameter v2, lower bound a, and
                      upper bound b
t                     Time, s
u                     Incoming wind speed at rotor,
                      m/s
α                     Fault signature
Γ                     Rotor yaw, degree
Y                     Rotor pitch rate limit, degree/s
Δt                    Pitch controller time step, s
η                     Efficiency
θ                     Rotor pitch, degree
λ                     Rotor tip-speed ratio
ρ                     Air density, kgm−3
σ                     Proportional rotor speed error in
                      pitch control, rad/s
T                     Torque, Nm
ω                     Rotational speed, rad/s or RPM
Subscripts
b                     For gearbox
g                     For generator
H                     In hardware
max                   Maximum value of parameter
min                   Minimum value of parameter
r                     For rotor
rated                 Rated value
S                     In software
t                     At time index = t
θ                     For rotor pitch (actuator)
ω                     For rotor rotational speed
                      (sensor)
Superscripts          Gain
(1)                   O set
(2)                   Relative noise
(3)
′
                      True value
{circumflex over ( )} Estimated value
.                     Time derivative
                      Data-driven
                      Mathematical equations-driven

FIG. 1 illustrates an exemplary system for Bayesian regression-based fault detection and diagnosis, according to some embodiments of the present disclosure. The system 100 includes or is otherwise in communication with hardware processors 102, at least one memory such as a memory 104, an I/O interface 112. The hardware processors 102, memory 104, and the Input/Output (I/O) interface 112 may be coupled by a system bus such as a system bus 108 or a similar mechanism. In an embodiment, the hardware processors 102 can be one or more hardware processors.

The I/O interface 112 may include a variety of software and hardware interfaces, for example, a web interface, a graphical user interface, and the like. The I/O interface 112 may include a variety of software and hardware interfaces, for example, interfaces for peripheral device(s), such as a keyboard, a mouse, an external memory, a printer and the like. Further, the I/O interface 112 may enable the system 100 to communicate with other devices, such as web servers, and external databases.

The I/O interface 112 can facilitate multiple communications within a wide variety of networks and protocol types, including wired networks, for example, local area network (LAN), cable, etc., and wireless networks, such as Wireless LAN (WLAN), cellular, or satellite. For the purpose, the I/O interface 112 may include one or more ports for connecting several computing systems with one another or to another server computer. The I/O interface 112 may include one or more ports for connecting several devices to one another or to another server.

The one or more hardware processors 102 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, node machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Among other capabilities, the one or more hardware processors 102 is configured to fetch and execute computer-readable instructions stored in the memory 104.

The memory 104 may include any computer-readable medium known in the art including, for example, volatile memory, such as static random-access memory (SRAM) and dynamic random-access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. In an embodiment, the memory 104 includes a plurality of modules 106.

The plurality of modules 106 include programs or coded instructions that supplement applications or functions performed by the system 100 for executing different steps involved in the process of the Bayesian regression-based fault detection and diagnosis in wind turbine sensors and actuators. The plurality of modules 106, amongst other things, can include routines, programs, objects, components, and data structures, which performs particular tasks or implements particular abstract data types. The plurality of modules 106 may also be used as, signal processor(s), node machine(s), logic circuitries, and/or any other device or component that manipulates signals based on operational instructions. Further, the plurality of modules 106 can be used by hardware, by computer-readable instructions executed by the one or more hardware processors 102, or by a combination thereof. The plurality of modules 106 can include various sub-modules (not shown). The plurality of modules 106 may include computer-readable instructions that supplement applications or functions performed by the system 100 for the Bayesian regression-based fault detection and diagnosis in wind turbine sensors and actuators. In an embodiment, terms ‘wind turbine’ and ‘wind-turbine’ are used interchangeably.

The data repository (or repository) 110 may include a plurality of abstracted piece of code for refinement and data that is processed, received, or generated as a result of the execution of the plurality of modules in the module(s) 106.

Although the data repository 110 is shown internal to the system 100, it will be noted that, in alternate embodiments, the data repository 110 can also be implemented external to the system 100, where the data repository 110 may be stored within a database (repository 110) communicatively coupled to the system 100. The data contained within such external database may be periodically updated. For example, new data may be added into the database (not shown in FIG. 1) and/or existing data may be modified and/or non-useful data may be deleted from the database. In one example, the data may be stored in an external system, such as a Lightweight Directory Access Protocol (LDAP) directory and a Relational Database Management System (RDBMS). Functions of the components of the system 100 are now explained with reference to the steps in flow diagram in FIG. 2, and the architecture diagram in FIG. 3.

At step 202 of method 200 in FIG. 2, the system 100 collects, via the one or more hardware processors 102, data from a wind turbine as input data. The input data may include values of parameters such as, but not limited to, a plurality of state parameters (s_t), wind data (u_t), and measurement outputs from the faulty sensor or actuator under consideration (rotor speed information (ω_rt), and rotor pitch information (θ_t) in the current example). In an embodiment, the system 100 may collect the input data directly from one or more systems associated with the wind turbine or from any other data source.

Further, at step 204 of the method 200, the system 100 generates, via the one or more hardware processors 102, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model. The plurality of prime values are an estimate of actual values of the one or more parameters of the input data which are relevant to the faulty sensor or actuator under consideration. The actual values are also referred to as ‘model-expected values’. Details of the dynamic model are given below.

Dynamics Model:—

For the example of a faulty rotor speed sensor and pitch actuator under consideration, a model-based fault inference approach requires a model =(,) to estimate wind turbine dynamics. The model estimates the true value of the rotor speed ω′_r that is erroneously reported as ω_r by the faulty rotor speed sensor. Likewise, the model estimates the true value of the rotor pitch θ″ commanded by a pitch PI controller, which is wrongly set as θ by the faulty pitch actuator. Thus, given the wind turbine state vector s_t and the input wind speed u_t, model , gives the probability distribution p(ω′_rt|s_t, u_t; ) and model gives the probability distribution p(θ′_t|s_t, u_t; ).

The Dynamics model used by the system 100 is such a model =(, ). The Dynamics model can be developed using wind turbine dynamics equations, giving rise to a mathematical (analytical) dynamics model =(, ). If such dynamics equations are unavailable, a completely data-driven model =(, ) is developed using neural networks as function approximators to the wind turbine dynamics. In this approach, data from the fault-free operation of the rotor speed sensor or the pitch actuator are used to train and , respectively.

Further, at step 206 of the method 200, the system 100 determines, using a fault model via the one or more hardware processors 102, correlation of a measured value of the one or more parameters of the input data with the associated prime values in presence of a plurality of fault signatures. The one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine. Details of the fault model are given below.

Fault Model:—

A sensor is faulty when a measured output of the sensor deviates from a true value of the variable it is measuring, beyond some tolerance. Similarly, an actuator is faulty if the actuated output deviates from its commanded input. Refer to the table below.

TABLE 2
Fault types and associated signatures
Fault type Fault signatures
No fault   α(1) = 1; α(2) = 0; α(3) = 0
(ideal)
Gain       α(1) /= 1
Offset     α(2)) /= 0
Stuck-at   α(1) = 0
fault
High noise High α(3) beyond acceptable
           limits
Drifts     α(1) (for i = 1, 2, 3) vary with
           time

Faulty signal of a general parameter ψ at time t is modeled as

$\begin{array}{cc}{\Psi }_t\sim \mathrm{clip}\left(𝒩\left({\alpha }_t^{\left(1\right)}{\Psi }_t^{\prime }+{\alpha }_t^{\left(2\right)},{\left({\alpha }_t^{\left(3\right)}{\Psi }_t^{\prime }\right)}^2\right),{\Psi }_{{\min }_t},{\Psi }_{{\max }_t}\right)& \left(1\right)\end{array}$

Here, ψ′_t is the true input to the sensor or actuator and ψ_{min t} and ψ_{max t} are the lower and upper bounds on ψ_t respectively. α_t⁽¹⁾, α_t⁽²⁾, α_t⁽³⁾ are the gain, offset, and relative noise fault signatures respectively. Depending on the values of the fault signatures α⁽ⁱ⁾ (for i=1, 2, 3), the general fault formulation in Equation (1) can incorporate various types of faults in sensors and actuators as given in Table 2.

In the method 200, general fault formulation model in (1) is contextualized to faults in the (rotor speed) sensor and the (rotor pitch) actuator. It is assumed that the faults in the sensor and the actuator are independent of each other. For simplification, the fault signatures ([α⁽¹⁾, α⁽²⁾, α⁽³⁾]) are assumed to not vary with time i.e., there is no drift. Accordingly, two independent fault formulation models and relate the faulty sensed/actuated quantities of ω_rt and θ_t to the respective true (i.e., prime) inputs ω′_rt and θ′_t and the fault signatures as follows:

$\begin{array}{cc}{ℱ}_{\omega }:{\omega }_{r_t}\sim \mathrm{clip}\left(𝒩\left({\alpha }_{\omega }^{\left(1\right)}{\omega }_{r_t}^{\prime }+{\alpha }_{\omega }^{\left(2\right)},{\left({\alpha }_{\omega }^{\left(3\right)}{\omega }_{r_t}^{\prime }\right)}^2\right),{\omega }_{\min },{\omega }_{\max }\right)& \left(2\right)\end{array}$ $\begin{array}{cc}{ℱ}_{\theta }:{\theta }_t\sim \mathrm{clip}\left(𝒩\left({\alpha }_{\theta }^{\left(1\right)}{\theta }_t^{\prime }+{\alpha }_{\theta }^{\left(2\right)},{\left({\alpha }_{\theta }^{\left(3\right)}{\theta }_t^{\prime }\right)}^2\right),\max \left({\theta }_{\min },{\theta }_{t-1}-\gamma \Delta t\right),\min \left({\theta }_{\max },{\theta }_{t-1}+\gamma \Delta t\right)\right)& \left(3\right)\end{array}$

• • Here, ω_min, and ω_max are the time-independent lower and upper bounds on the rotor speed, respectively.
  • Thus, models and give the probability distributions p(ω_r|ω′_rt, [α_ω⁽¹⁾, α_ω⁽²⁾, α_ω⁽³⁾]; ) and p(θ_t|θ′_t, [α_θ⁽¹⁾, α_θ⁽²⁾, α_θ⁽³⁾]; ), respectively.

Further, at step 208 of the method 200, the system 100 determines a likelihood function, via the one or more hardware processors 102. The likelihood function indicates probability of the measured value of the one or more faulty parameters under consideration given the associated prime values and fault signatures. Under the dynamics and fault formulation models described above, mixtures of censored Gaussian distributions are used to determine these likelihood functions.

Further, at step 210 of the method 200, the system 100 generates, using the Bayesian inference model used in the Bayesian regression approach used by the one or more hardware processors 102, a posterior information by combining the likelihood function with a prior information. The posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function. Further, at step 212 of the method 200, the system 100 generates, via the one or more hardware processors 102, one or more fault signature distributions and associated magnitude and uncertainty, by processing the posterior information. The one or more fault signature distributions is indicative of one or more probable faults. In an embodiment, the one or more probable faults are in one or more sensors or actuators of the wind turbine.

The Bayesian inference approach used in steps 210 and 212 is elaborated below:

The Bayesian inference model is a statistical method for updating (prior) beliefs about a random parameter based on new evidence or observed data. Bayesian inference begins with a known/assumed prior probability distribution which represents the initial estimate of the parameter prior to receiving any actual data. As new observations/measurements come, the likelihood function indicates how the new data are distributed given different values of the parameter, i.e., the likelihood function quantifies the probability of observing the new data under suitable assumptions on the parameter. The posterior information includes probability distribution of each of these parameters, and is obtained by combining the prior information with the likelihood function. The posterior information represents the updated belief/estimate of a parameter being considered, after incorporating the new data. At this step, the system 100 obtains posterior distributions of the fault signatures α⁽ⁱ⁾ (for i=1, 2, 3).

The system 100 may use Bayes' theorem to obtain the posterior information distribution. Specifically, the system 100 obtains the probability distributions of the fault signatures, posterior to observing the sensed/actuated value of the signals of interest ω_rt or θ_t along with the input wind speed u_t and the turbine state vector s_t under dynamics and fault formulation models. The system 100 approximates these distributions at a given time t as:

$\begin{array}{cc}p\left({\alpha }_{\omega }^{\left(i\right)}❘{\omega }_{r_t},s_t,u_c;{𝒜}_{\omega },{ℱ}_{\omega }\right)\approx {\int }_{{\alpha }_{\omega }^{\left(j\right)\ne \left(i\right)}}\frac{p\left(\left[{\alpha }_{\omega }^{\left(1\right)},{\alpha }_{\omega }^{\left(2\right)},{\alpha }_{\omega }^{\left(3\right)}\right]\right)}{p\left({\omega }_{r_t}|s_t,u_t\right)}ℒ\left({\omega }_{r_t}❘{\omega }_{r_t}^{\prime },{\alpha }_{\omega }^{\left(1\right)},{\alpha }_{\omega }^{\left(2\right)},{\alpha }_{\omega }^{\left(3\right)}\right)d{\alpha }_{\omega }^{\left(j\right)\ne \left(i\right)}& \left(4\right)\end{array}$ $\begin{array}{cc}p\left({\alpha }_{\theta }^{\left(i\right)}❘{\omega }_{r_t},s_t,u_t;{𝒜}_{\theta },{ℱ}_{\theta }\right)\approx {\int }_{{\alpha }_{\omega }^{\left(j\right)\ne \left(i\right)}}\frac{p\left(\left[{\alpha }_{\omega }^{\left(1\right)},{\alpha }_{\omega }^{\left(2\right)},{\alpha }_{\omega }^{\left(3\right)}\right]\right)}{p\left({\theta }_t❘s_t,u_t\right)}ℒ\left({\theta }_t|{\theta }_t^{\prime },{\alpha }_{\theta }^{\left(1\right)},{\alpha }_{\theta }^{\left(2\right)},{\alpha }_{\theta }^{\left(3\right)}\right)d{\alpha }_{\theta }^{\left(j\right)\ne \left(i\right)}& \left(5\right)\end{array}$ $\mathrm{for}i=1,2,3$

Prior distributions: Bayesian methods require assigning appropriate prior distributions to the six fault signatures being inferred, which are represented by p([α_ω⁽¹⁾, α_ω⁽²⁾, α_ω⁽³⁾]) and p([α_θ⁽¹⁾, α_θ⁽²⁾, α_θ⁽³⁾]) in Equations (4) and (5). These priors could be knowledge-driven or historical data-driven.

In Equations (4) and (5), (ω_rt|ω′_rt, α_ω⁽¹⁾, α_ω⁽²⁾, α_ω⁽³⁾ and (θ_t|θ′_t, α_θ⁽¹⁾, α_θ⁽²⁾, α_θ⁽³⁾), are the respective likelihood functions of the sensed rotor speed and the actuated rotor pitch. Mixtures (as estimates of ω′_rt and θ′_t could have uncertainty) of censored (as ω_rt and θ_t are clipped within a range) Gaussian distributions are used to model the likelihood functions. The likelihood functions are computed from the turbine dynamics model and the fault formulation model .

Apart from the prior distributions and the likelihood functions, computation of the posterior distributions also requires determination of the terms p(ω_rt|s_t, u_t) and p(θ_t|s_t, u_t) in Equations (4) and (5). These terms are difficult to compute analytically and hence, the system 100 may use numerical methods to approximate the posterior distributions of the fault signatures. The Bayesian inference uses a Markov Chain Monte Carlo (MCMC) sampling mechanism to approximate the posterior distributions of the fault signatures. In an embodiment, MCMC is used as an example, and the system 100 may use any other suitable approach for the purpose of approximating the posterior distributions.

Using MCMC, the system 100 obtains samples from the posterior distributions of the fault signatures. In MCMC, samples are generated as a chain with each subsequent sample depending on its previous sample. The system 100, using the sampling algorithm, drives the stationary distribution of the chain to converge to the desired posterior distribution so that after convergence, the chain samples are samples from the desired posterior distribution.

Experimental Data:

1. Implementation:

This section presents the dataset generation and the implementation details of the Bayesian approach used by the system 100. A data-driven binary classifier baseline model is used for comparison, and certain evaluation metrics are discussed.

a. Datasets Used:

For the experiments, simulated data was used to develop and evaluate the different inference methods. Two types of simulated datasets were generated: (1) an ideal dataset, and (2) a realistic dataset.

• • i. Ideal dataset:—This dataset was generated by simulating a reference offshore NREL 5 MW turbine model, with different combinations of synthetically injected fault signatures in rotor speed sensor and pitch actuator. Apart from possible faults in these two (ω_r, θ) systems that were sought to be inferred, the data was assumed to come from a perfectly healthy turbine without any real-world issues like sensor noise, missing data, etc. (hence the name ‘ideal’). This was the primary dataset used to develop the inference methods. First, 3 months worth of wind data (speed, direction) were obtained from a real-world wind farm met mast. These wind data was available at a 10 minute resolution. Because turbine control usually takes place in the order of seconds, Kaimal spectrum technique was used to obtain a 1 Hz sampling of wind data from the 10 minute samples. Starting with the wind speed as input, turbine dynamics equations and fault formulation models _ω, _θ were used to simulate turbine operational data at 1 s intervals with possible faults in the rotor speed sensor or the pitch actuator. The bounds used for the rotor speed (ω_min, ω_max) were (0, ∞) rad/s; and for the pitch (θ_min, θ_max) were (0°,25°). The upper limit on the rate of change of the actuated pitch was taken as γ=5°/s and the pitch controller timestep Δt is 1 s. 100 different faults were injected, one at a time, each with a unique combination of fault signatures. Each unique fault combination was obtained by randomly sampling the fault signatures (the gain α⁽¹⁾, offset α⁽²⁾, and relative noise α⁽³⁾) from their respective ranges, summarized in Table 3. The faults were injected at t=1 s. This results in the creation of 100 different faulty datasets. Additionally, 200 special datasets were also generated, 100 each for the two special cases where only one of the two systems is faulty, i.e., only speed sensor is faulty (with varying fault signatures) but pitch actuator is not faulty, and vice-versa. These datasets were used to train the neural network-based dynamics models .

TABLE 3
Fault signature ranges for data generation
	Fault
	signature	Rotor speed sensor	Rotor pitch actuator
	Gain	αω(1) ∈ {0, 1, 2}	αθ(1) ∈ {0, 1, 2}
	Offset	αω(2) ∈ {−1.5, 0, 1.5}	αθ(2) ∈ {−2, 0, 2}°
		rad/s
	Relative noise	αω(3) ∈ {0, 0.05, 0.1}	αθ(3) ∈ {0, 0.05, 0.1}

• • ii. Realistic dataset:—Because the ideal dataset described above is too good to realize in practice, a ‘realistic’ dataset was also simulated to mimic some data problems seen in real-world operation. While there may be many issues in real-world operation, two are considered as an example here—noisy measurements and missing data. 100 different faulty datasets were generated with faults in the rotor speed sensor or the rotor pitch actuator in a manner similar to that used to generate the ideal dataset. However, unlike the ideal dataset, a 3% zero-mean Gaussian noise was added to all sensor measurements to mimic noisy data. Data points were also dropped at random at different time instants with a small probability to mimic missing data. Moreover, 200 special realistic datasets were also generated, 100 each for the case when the speed sensor is faulty but the pitch actuator is not faulty, and vice versa, to train neural network-based dynamics models on realistic data. As both the ideal and realistic datasets were simulated, they can serve as the ground-truth for evaluating the different inference methods as the true values of the injected fault signatures were known.b. Inference Methods

Two inference methods I and I were developed, which differ in the type of dynamics model used ( and , respectively). Both the methods use the same fault formulation model =(, ).

i. Method I

This inference method uses the analytical dynamics model =(, ) based on the wind turbine dynamics equations. Use of mathematical equations in ^M leads to deterministic estimates of the true rotor speed ω′_rt and the true commanded pitch θ′_t given the observed state stand windspeed u_t.

ii. Method I

The dynamics model used in this inference method was the data-driven model =(, ). Models , and were developed using neural networks to estimate ω′_rt and θ′_t. Sequential neural networks with dropout after each hidden layer were used to train these models on the ideal or realistic datasets. Table 4 shows the input features, target outputs, and details of the neural network scheme.

TABLE 4
Details for training data-driven models
using sequential neural networks (NN) with dropout on the ideal
and realistic datasets. The NN architecture is represented by a tuple
of number of nodes in (input, hidden, output) layers.
	Ideal dataset	Realistic dataset
Target output	ωrt′	θt′	ωrt′	θt′
Input	ut, ωrt-1′	ωrt	Δta, ut	Δta, ωrt
features	,	θt-1′, Ît	ωrt-1′  ,	θt-1′, Ît
	θt-1		θt-1
NN architecture	(4, 25, 1)	(3, 20, 1)	(5, 25, 1)	(4, 20, 1)
No. of training	22,680	21,538
samples
Mini-batch size	453	430
Dropout probability	0.05
Hidden/output	ReLU/Linear
activation
No. of training	1,000
epochs
Loss function	Mean Squared Error
Optimizer	Adam (1e−4)
(learning rate)

The models , and were trained on the 200 special datasets generated, where the rotor speed sensor and the pitch actuator are fault-free, respectively. It should be noted that in the ideal dataset, fault-free operation of the speed sensor or the pitch actuator results in, ω′_rt=ω_rt or θ′_t=θ_t, respectively. However, the same cases in the realistic dataset imply ω′_rt≈ω_rt or θ′_t≈θ_t. The approximations arise due to the presence of measurement noise in the realistic dataset. For the realistic dataset, Δ^at, which is the time difference between two consecutive available samples, was also included as an additional input feature for the neural networks. This is because unlike the ideal dataset where there are no missing data samples, the realistic dataset contains missing data resulting in a Δ^at that varied across samples and is not necessarily 1 s. I⁻_t is an estimate of the integral rotor speed error derived from the basic understanding of a PI controller. The models recursively estimate their respective outputs in a sequential timestep-wise fashion (i.e., for t followed by t+1). Monte Carlo (MC) Dropout was used to get samples of the estimated outputs instead of simple point estimates. Doing so enabled to obtain the output distributions p(ω′_rt|s_t, u_t; ) and p(θ′_t| s_t, u_t; ) which helped in incorporating prediction uncertainty in the dynamics models. This prediction uncertainty could be used to estimate uncertainty in the inferred fault signatures downstream more accurately.

c. Prior Distributions and Likelihood Functions

Initialization of priors before starting any inference was done through domain knowledge of the typical values of fault signatures. Without any information about the faults, the following priors were used at the outset (at t=1 s):

${\alpha }_{\omega }^{\left(1\right)},{\alpha }_{\theta }^{\left(1\right)}\sim \mathrm{𝒯𝒩}\left(1,1,1,\infty \right)$ ${\alpha }_{\omega }^{\left(2\right)},{\alpha }_{\theta }^{\left(2\right)}\sim 𝒩\left(0,1\right)$ ${\alpha }_{\omega }^{\left(3\right)},{\alpha }_{\theta }^{\left(3\right)}\sim \mathrm{𝒯𝒩}\left(0,1,0,\infty \right)$

These three prior distributions give a mode of 1, 0, and 0 for the gain, offset, and relative noise fault signatures respectively, which are the most likely values for healthy operation. The likelihood functions were given by the probability distribution function of a mixture of censored Gaussian distributions. Since ^M gives deterministic estimates of ω′_rt and θ′_t (given u_t and s_t), the number of mixture components for method I is 1. Model gives probabilistic estimates of ω′_rt and θ′_t (using Monte Carlo Dropout). 5 samples each of ω′_rt and θ′_t^θ′t were taken from the output distributions p(ω′_rt|s_t, u_t; ) and p(0′|s_t, u_t; ) predicted by and respectively, resulting in 5 mixture components for method I.

d. Posterior Distributions of Fault Signatures

Using the prior distributions, the likelihood functions, and the observed values of ω_rt and θ_t, two independent inference models were run—one to infer the posterior distribution for the sensor fault signatures and the other to infer the actuator fault signatures α_θ⁽ⁱ⁾, 1, 2, 3. For each of the 100 faulty datasets (ideal or realistic), inference was implemented using the available data samples over a total period of 1-120s, split into two batches (1-60 s and 61-120 s). For the first batch, the prior distribution was the knowledge-driven one at t=1 s. Marginal posterior distributions for the fault signatures were estimated for each batch by Markov Chain Monte Carlo (MCMC) sampling using the Metropolis algorithm. Each run of the MCMC sampler had 3 chains with 20,000 burn-in (to allow the chain to converge to its stationary distribution) and 30,000 chosen samples (after the chain has converged) each. Thus, the sampled trace from all the chains has 90,000 samples for each fault signature that gives the estimated marginal posterior distribution for that signature. A Gaussian Kernel Density Estimator fit to these samples served as the prior distribution for the next batch that followed. This process continues till both the batches are used, eventually giving samples from estimates of p(α_ω⁽ⁱ⁾|ω_rt, s_t, u_t; , ) and p(α_θ⁽ⁱ⁾|θ_t, s_t, u_t; , ). This complete inference approach was implemented using Python library for probabilistic programming PyMC.

e. Classification Baseline,

The classifiers that are data-driven in nature have been predominantly used in literature for fault detection. Hence, a neural network-based binary (fault/no fault) classifier was developed as a baseline model. As wind turbine operational data were time-series, recurrent neural networks are the most suitable designs for building the classifiers as they use context from previous time indices while making predictions for a given time instant. Specifically, Gated Recurrent Unit (GRU)-based neural networks were used for the baseline model .

The same 100 simulated faulty datasets (ideal or realistic) that have been used to develop the Bayesian inference approaches were first split into training, validation and test sets, in the proportion of 40:10:50. Each training sample input to the GRU-neural network was a sequence spanning 120 s, which is the same as the total time period over which inference has been implemented by the Bayesian approaches. Two independent classifiers, one each for the rotor speed sensor (_ω) and the rotor pitch actuator (_θ) were built. For these classifiers, sensed values of 6 parameters, namely u_t, ω_rt, τ_rt, ω_gt, τ_gt, and θ_t are used as the input features. The output target was a class indicator from the set {0, 1}, in which Class 1 corresponds to the sensor/actuator being faulty while Class 0 represents the non-faulty case. The sensor/actuator is deemed faulty when any one of its fault signatures is beyond a user-defined acceptable fault tolerance. For the sake of demonstration, example tolerances were chosen such that:

• • α_ω⁽¹⁾, α_θ⁽¹⁾∈[0.5, 1.5], α_ω⁽²⁾∈[−1.2, 1.2] rad/s, α_θ⁽²⁾∈[−3, 3]°, α_ω⁽³⁾∈[0, 0.1], α_θ⁽³⁾∈[0, 0.7]°
  • correspond to fault-free signatures.

To train the GRU-neural network classifiers, samples of input feature time sequences in the training set were first fed to a GRU. For the realistic dataset, the GRU was preceded by a masking layer that masks the time instants where data samples were missing. The output of the GRU was a fixed-dimensional vector for each sample that embedded the information from the input time sequence for that sample. Next, the output of the GRU was fed to a downstream sequential neural network with one hidden layer followed by the final output layer. Table 5 shows the hyperparameters chosen for the GRU-neural network classifiers for the rotor speed sensor (_ω) and the rotor pitch actuator (_θ). These hyperparameters are tuned on the held-out validation set.

TABLE 5
Details for training the baseline classifier  using GRU-neural
networks on the ideal and realistic datasets. The NN architecture is
represented by a tuple of number of nodes in
(GRU-output, hidden, final output) layers.
	Ideal dataset	Realistic dataset
NN architecture	(20, 11, 1)	(20, 12, 1)	(20, 11, 1)	(15, 8, 1)
No. of training	55	200	115	200
epochs
Target output	Class 0 (non-faulty)/1 (faulty)
Input features	ut, ωrt  , ωgt, , θt
No. of training	43,240
samples
No. of validation	10,810
samples
Mini-batch size	864
Hidden/output	ReLU/sigmoid
activation
Loss function	Binary cross-entropy loss
Optimizer	Adam (1e−4)
(learning rate)

f. Evaluation Metrics

This section discusses three metrics that were used to evaluate the inference approach used by the system 100. First two metrics have statistical rigor while the third one is a business metric.

• • i. Posterior Log Likelihood (PLL): This metric is only relevant to the inference methods I and I as their outputs are samples from the marginal posterior distribution for each fault signature. In order to evaluate how well the posterior distributions account for the true values of the respective signatures (which is known as all data are simulated), first Gaussian Kernel Density Estimators (KDE) are fit to these samples. KDE is a non-parametric statistical method used for estimating the underlying probability density function (PDF) of a continuous random variable using its samples. PLL is the logarithm of the probability density at the true value of the signature under this estimated PDF of the posterior distribution. The higher the PLL is, the better is the posterior distribution inference in terms of accounting for and explaining the true value of the signature.
  • ii. F₁ score: Standard F₁ score was used to evaluate the performance of all the three methods I, I, and in a classification setting. For the two Bayesian approaches, the inferred distributions o fault signatures were first processed into fault (1)/no fault (0) class labels. The higher the F₁ score is the better is the classification performance.
  • iii. Fault Tolerant Control Percentage Error (R_FTC): A binary classification algorithm stops at labeling a given case under study as faulty/non-faulty. However, in practical terms, an FDD algorithm would fulfill its objects more effectively if its results could be applied immediately to course-correct a faulty operation, rather than having to await a full hardware repair/reset. Because the inference methods I and I provide samples of the inferred fault signatures, their outputs could be used to estimate the true values of the signals under study (ω′_r and θ′), which, in turn, could be utilized for course correction. Such a business utility of the proposed inference methods is demonstrated through a fault tolerant pitch control scheme. Such a scheme could improve the turbine energy output even in the presence of a faulty speed sensor or pitch actuator by ‘rectifying’ the faults in software. Briefly, the scheme uses samples of the inferred rotor speed sensor fault signatures to estimate the true rotor speed ω′_r from the faulty speed sensor output. The rotor PI pitch controller used these estimates to further estimate the desired pitch that should be actuated by the faulty pitch actuator. The fault tolerant scheme then used samples of the inferred rotor pitch actuator fault signatures to estimate the correct pitch θ′ that needed to be commanded. This estimate of the pitch was finally fed to the faulty actuator.
  • In order to evaluate the ability of the method 200 to improve the energy output through a fault tolerant control scheme, a metric referred to as Fault Tolerant Control Percentage Error, R_FTC (%) was defined as:

$R_{\mathrm{RFTC}}=❘\frac{E_H-E_S}{E_H}❘\times 100$

The ideal energy output E_H occurs when the faults are completely rectified in hardware (i.e., a full repair of the faulty sensor/actuator). R_FTC defined above is the absolute percentage error between the ideal energy E_H and E_S which was the energy output through fault tolerant control-based rectification in software. The lower the R_FTC is, the better is the inference method in its ability to improve the turbine output relative to the ideal energy output.

Results:—

In this section, some key results from the evaluation of the different inference methods for both the ideal and realistic datasets, using different metrics, are discussed.

a. Posterior Log Likelihood (PLL)

To understand which method I or I gives statistically significantly better inference for each fault signature, 100 values of PLL (one for each of the 100 simulated faulty datasets) given by method I on the ideal dataset need to be statistically compared with those given by method I on the same dataset. Hypothesis testing can be used for such a pairwise comparison between the two inference methods. One-sided Wilcoxon signed-rank test was used for such a hypothesis testing. The null hypothesis is that method I has a PLL lower than (or equal to) that from method I. The alternative hypothesis is that method I has a PLL greater than that from method I. The output from the Wilcoxon test is a p-value. If the p-value is less than a predetermined significance level, then the null hypothesis is rejected and the alternative hypothesis is accepted. Otherwise, the null hypothesis cannot be rejected.

Table 6 shows the p-value resulting from the hypothesis testing explained above for each fault signature. From the p-values, it can be observed that for all six fault signatures on the ideal dataset, at a 5% significance level, method I that uses analytical dynamics equations is statistically significantly better than method I that uses neural networks to approximate dynamics. Thus, the inference follows the expected behavior of I being better than I, thereby increasing confidence in the approach in method 200.

TABLE 6
p-values from the one-sided Wilcoxon signed-rank test for pairwise
comparison of inference methods I   and I   in terms of PLL.
Null hypothesis H0: PL  <= PL ;
Alternative hypothesis HA: PL  > PL .
Fault
signature p-value
αω(1)     3.7e−4
αω(2)     5.9e−4
αω(3)     2.1e−9
αθ(1)     1.8e−8
αθ(2)     1.2e−3
αθ(3)     2.4e−13

b. Classification Performance

The approach in method 200 gives the marginal posterior distribution of each fault signature. To use these methods in a binary classification setting where the fault signature can be classified as faulty (1) or not (0), its posterior distribution first needs to be compared with some fault tolerances.

In the presence of predefined fault tolerances: When predefined fault tolerances were available (say from sensor/actuator manufacturers), they can be used to label the inferred fault signatures as faulty (1) or not (0). A signature for which more samples from its inferred posterior distribution are within (than outside) the limits defined by the tolerances is labeled as non-faulty. The sensor/actuator with even one signature faulty is marked as faulty overall. FIG. 4 shows the F₁ scores for different inference methods and the baseline classifier for faulty/not faulty binary classification of the rotor speed sensor and the pitch actuator overall, computed on the 50 simulated faulty experiments comprising the test set that is neither used for training nor for validation of the classifier . The same tolerances that have been used to train were used here to mark the different fault signatures as faulty/non-faulty. It can be seen that on the ideal dataset, for the rotor speed sensor, the different inference methods have similar F₁ scores that are marginally lower (up to 1%) than the score for the baseline classifier . However, for the rotor pitch actuator, both the inference methods improve on the baseline classifier by at least 25%. On the realistic dataset, the different inference methods improve on the baseline classifier by at least 6% for the rotor speed sensor, and at least 15% for the rotor pitch actuator. Thus, the proposed model-based inference methods were observed to be giving a better classification performance than a pure data-driven classifier showing that incorporating dynamics helps in inference in a classification setting too.

In the absence of predefined fault tolerances, the 95% confidence intervals of the posterior distributions can be used as inference-driven tolerances for fault detection. If the confidence interval includes the ideal value of a signature, then the inferred signature corresponds to a fault-free (predicted label 0) condition, else it represents faulty (predicted label 1) condition. As mentioned in Table 2, these ideal values are 1 for the gain, 0 for the offset, and 0 for the relative noise fault signatures. The true label of the fault signature is 0 if its true value equals the ideal value, else it is 1. F₁ score can then be used to compare the true and predicted labels. FIG. 5 shows the F₁ scores for different inference methods for faulty/not faulty binary classification of the fault signatures across all the 100 faulty experiments in each of the ideal and realistic datasets. The use of 95% confidence intervals as fault tolerances gave an F₁ score of at least 73% on the ideal and 58% on the realistic dataset. Thus, the Bayesian regression methods were inherently useful for fault detection too as they generate confidence intervals as a byproduct of the inference. These intervals can serve as tolerances for a fault detection solution.

Lastly, the inference methods give a lower ₁ score for the actuator fault signatures than the corresponding sensor fault signatures in most cases, which could be a result of both upper and lower censoring for the pitch as compared to just lower censoring for the speed in the respective likelihood functions. Censoring can cause parameter non-identifiability leading to worse inference than that with no censoring.

c. Fault Tolerant Control Percentage Error (R_FTC)

FIG. 6 shows, for a particular combination of fault signatures, the generator power output when the faults inferred by Bayesian inference (method I) are used for fault rectification in software. It also shows the power output when the faults are not rectified at all and when the faults are completely rectified in hardware. The faults were injected at t=1 s and fault rectification (either in software or in hardware) began at t=900 s. It can be seen from FIG. 6 that once fault rectification starts (either in hardware or software), the power output improves over the output when the faults are not rectified at all.

Hypothesis testing was used next to do a pairwise comparison of the different inference methods in terms of the R_FTC business metric from t=900 s to t=1200 s for all the 100 faulty experiments in the ideal and realistic datasets. For the ideal dataset, the null hypothesis is that method I has an R_FTC greater than (or equal to) that from method I. The alternative hypothesis was that method I has an R_FTC less than that from method I. For the realistic dataset, the null hypothesis is that method I has an R_FTC equal to that from method I. The alternative hypothesis is that method I has an R_FTC not equal to that from method I. The Wilcoxon signed-rank test (one-sided for the ideal dataset and two-sided for the realistic dataset) is used for the hypothesis testing. Table 7 shows the resultant p-values. The table also shows the mean (±one standard deviation of the) R_FTC across the 100 experiments for the different methods. From the table, it can be seen that the fault tolerant pitch control scheme in software gets, on an average, within at most 57% of the ideal energy improvement possible through a complete fault repair in hardware on the ideal dataset and within at most 55% on the realistic dataset. Thus, the method 200 combined with fault tolerant control in software could give at least a partial improvement in energy output without needing a costly and time-consuming repair of the faulty sensor or actuator that can cause turbine downtime.

The results indicated that the method I underperformed as compared to I on the ideal dataset as I gives a statistically significantly greater R_FTC (by 36% on average) than I. The two inference methods were statistically indistinguishable in terms of the R_FTC on the realistic dataset.

TABLE 7
Mean RFTC, standard deviation of RFTC, and p -values from the
Wilcoxon signed-rank test for pairwise comparison of inference methods
I   and I   in terms of RFTC.
On the ideal dataset, null hypothesis H0:  >= ; and
alternative hypothesis HA:  < .
On the realistic dataset, null hypothesis H0:  = ; and
alternative hypothesis HA:  # .
		Realistic
	Ideal dataset	dataset
	I	I	I	I
Mean RFTC (%)	41.6	56.6	54.5	51.5
Standard deviation of	35.2	30.0	36.1	34.8
RFTC (%)
p-value	7.5e−9	0.3

d. Summary of Results

All the metrics indicated that, for the ideal dataset, using neural network approximation for dynamics worsens inference than using analytical dynamics equations due to an increased uncertainty in the estimates of the true rotor speed and commanded pitch. However, for the realistic dataset, the difference between the two inference methods is reduced due to the presence of real-world data issues. All the model-based inference methods were found to be better than a pure data-driven method of fault classification, thereby showing that incorporating dynamics helps in fault inference. The power of the Bayesian approach adopted by the system 100 is also highlighted by the usefulness of the 95% confidence intervals of the inferred posterior distributions as reasonable fault tolerances. Inference for the actuator fault signatures was found to be worse than that for the sensor fault signatures due to both lower and upper censoring leading to parameter non-identifiability. Lastly, the approach used in method 200 was found to be providing partial improvement in energy output via fault tolerant pitch control in software, without needing a complete repair in hardware.

The written description describes the subject matter herein to enable any person skilled in the art to make and use the embodiments. The scope of the subject matter embodiments is defined by the claims and may include other modifications that occur to those skilled in the art. Such other modifications are intended to be within the scope of the claims if they have similar elements that do not differ from the literal language of the claims or if they include equivalent elements with insubstantial differences from the literal language of the claims.

The embodiments of present disclosure herein address unresolved problem of fault analysis and diagnosis in wind turbine sensors and actuators. The embodiment, thus provides a Bayesian regression-based fault analysis in wind turbine sensors and actuators. Moreover, the embodiments herein further provide a mechanism for fault diagnosis using the Bayesian regression-based approach.

It is to be understood that the scope of the protection is extended to such a program and in addition to a computer-readable means having a message therein; such computer-readable storage means contain program-code means for implementation of one or more steps of the method, when the program runs on a server or mobile device or any suitable programmable device. The hardware device can be any kind of device which can be programmed including e.g., any kind of computer like a server or a personal computer, or the like, or any combination thereof. The device may also include means which could be e.g., hardware means like e.g., an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or a combination of hardware and software means, e.g., an ASIC and an FPGA, or at least one microprocessor and at least one memory with software processing components located therein. Thus, the means can include both hardware means and software means. The method embodiments described herein could be implemented in hardware and software. The device may also include software means. Alternatively, the embodiments may be implemented on different hardware devices, e.g., using a plurality of CPUs.

The embodiments herein can comprise hardware and software elements. The embodiments that are implemented in software include but are not limited to, firmware, resident software, microcode, etc. The functions performed by various components described herein may be implemented in other components or combinations of other components. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can comprise, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.

The illustrated steps are set out to explain the exemplary embodiments shown, and it should be anticipated that ongoing technological development will change the manner in which particular functions are performed. These examples are presented herein for purposes of illustration, and not limitation. Further, the boundaries of the functional building blocks have been arbitrarily defined herein for the convenience of the description. Alternative boundaries can be defined so long as the specified functions and relationships thereof are appropriately performed. Alternatives (including equivalents, extensions, variations, deviations, etc., of those described herein) will be apparent to persons skilled in the relevant art(s) based on the teachings contained herein. Such alternatives fall within the scope of the disclosed embodiments. Also, the words “comprising,” “having,” “containing,” and “including,” and other similar forms are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms “a,” “an,” and “the” include plural references unless the context clearly dictates otherwise.

Furthermore, one or more computer-readable storage media may be utilized in implementing embodiments consistent with the present disclosure. A computer-readable storage medium refers to any type of physical memory on which information or data readable by a processor may be stored. Thus, a computer-readable storage medium may store instructions for execution by one or more processors, including instructions for causing the processor(s) to perform steps or stages consistent with the embodiments described herein. The term “computer-readable medium” should be understood to include tangible items and exclude carrier waves and transient signals, i.e., be non-transitory. Examples include random access memory (RAM), read-only memory (ROM), volatile memory, nonvolatile memory, hard drives, CD ROMs, DVDs, flash drives, disks, and any other known physical storage media.

It is intended that the disclosure and examples be considered as exemplary only, with a true scope of disclosed embodiments being indicated by the following claims.

Claims

1. A processor implemented method, comprising: collecting, via one or more hardware processors, data from a wind turbine as input data;generating, via the one or more hardware processors, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data;determining, using a fault model via the one or more hardware processors, correlation of a measured value of the one or more parameters of the input data with associated prime values in presence of a plurality of fault signatures;determining a likelihood function, via the one or more hardware processors, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures;generating, using a Bayesian inference model via the one or more hardware processors, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; andgenerating, via the one or more hardware processors, one or more fault signature distributions and associated magnitude and uncertainty, by processing the generated posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in at least one of a sensor and actuator of the wind turbine.

2. The method of claim 1, wherein the input data comprises a plurality of state parameters, wind data, and measured values from at least one of the sensor and the actuator.

3. The method of claim 1, wherein the one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine.

4. The method of claim 1, wherein the one or more probable faults are in one or more sensors or actuators of the wind turbine.

5. A system, comprising: one or more hardware processors;a communication interface; anda memory storing a plurality of instructions, wherein the plurality of instructions cause the one or more hardware processors to: collect data from a wind turbine as input data;generate a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data;determine using a fault model, correlation of a measured value of the one or more parameters of the input data with associated prime values in presence of a plurality of fault signatures;determine a likelihood function, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures;generate, using a Bayesian inference model, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; andgenerate one or more fault signature distributions and associated magnitude and uncertainty, by processing the generated posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in αt least one of a sensor and actuator of the wind turbine.

6. The system of claim 5, wherein the input data comprises a plurality of state parameters, wind data, and measured values from at least one of the sensor and the actuator.

7. The system of claim 5, wherein the one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine.

8. The system of claim 5, wherein the one or more probable faults are in one or more sensors or actuators of the wind turbine.

9. One or more non-transitory machine-readable information storage mediums comprising one or more instructions which when executed by one or more hardware processors cause: collecting, data from a wind turbine as input data,generating, via the one or more hardware processors, a plurality of prime values associated with one or more parameters of the input data, by processing the input data using a dynamics model, wherein the plurality of prime values are an estimate of actual values of the one or more parameters of the input data;determining, using a fault model via the one or more hardware processors, correlation of a measured value of the one or more parameters of the input data with associated prime values in presence of a plurality of fault signatures;determining a likelihood function, via the one or more hardware processors, wherein the likelihood function indicates probability of the measured value of the one or more parameters given the associated prime values and fault signatures;generating, using a Bayesian inference model via the one or more hardware processors, a posterior information by combining the likelihood function with a prior information, wherein the posterior information is an updation of the prior information in light of one or more new observations indicated in the likelihood function; andgenerating, via the one or more hardware processors, one or more fault signature distributions and associated magnitude and uncertainty, by processing the generated posterior information, wherein the one or more fault signature distributions is indicative of one or more probable faults in at least one of a sensor and actuator of the wind turbine.

10. The one or more non-transitory machine readable information storage mediums of claim 9, wherein the input data comprises a plurality of state parameters, wind data, and measured values from at least one of the sensor and the actuator.

11. The one or more non-transitory machine readable information of claim 9, wherein the one or more fault signature distributions capture a plurality of different types of faults associated with at least one of a sensor or actuator of the wind turbine.

12. The one or more non-transitory machine readable information of claim 9, wherein the one or more probable faults are in one or more sensors or actuators of the wind turbine.