Safety and Reliability – Safe Societies in a Changing World – Haugen et al.

(Eds)
© 2018 Taylor & Francis Group, London, ISBN 978-0-8153-8682-7

Fault diagnosis of wind turbine structures using decision tree learning

algorithms with big data

I. Abdallah, V. Dertimanis, H. Mylonas, K. Tatsis & E. Chatzi

Department of Civil, Environmental and Geomatic Engineering, ETH Zürich, Zürich, Switzerland

N. Dervilis & K. Worden

Department of Mechanical Engineering, The University of Sheffield, Sheffield, UK

E. Maguire
Vattenfall AB, Edinburgh, UK

ABSTRACT: In the context of Operation and Maintenance of wind energy infrastructure, it is impor-
tant to develop decision support tools, able to guide engineers in the management of these assets. This
task is particularly challenging given the multiplicity of uncertainties involved, from the point of view of
the aggregated data, the available knowledge with respect to the wind turbine structures, as well as the
varying operational and environmental loads. We propose to propagate wind turbine telemetry through a
decision tree learning algorithm to detect faults, damage, and abnormal operations. The use of decision
trees is motivated by the fact that they tend to be easier to implement and interpret than other quantitative
data-driven methods. Furthermore, the telemetry consists of data from condition and structural health
monitoring systems, which lends itself nicely in the field of Big Data as large amounts are continuously
sampled at high rate from thousands of wind turbines. In this paper, we review several decision tree algo-
rithms, we then train an ensemble Bagged decision tree classifier on a dataset from an offshore wind farm
comprising 48 wind turbines, and use it to automatically extract paths linking excessive vibrations faults
to their possible root causes. We finally give an outlook of a cloud computing based architecture to imple-
ment decision tree learning involving Apache Hadoop and Spark.

1 INTRODUCTION WTs, for operation, maintenance (O&M) and deci-

Wind Turbines (WTs) maintenance and inspection
relies on conventional techniques (Yang & Sun
2013), such as visual inspection, non-destructive
evaluation and standard signal processing, trend
analysis and statistics of data streamed from
the Supervisory Control And Data Acquisition
(SCADA). Specialized Condition Monitoring
(CM) systems are only available on specific com-
ponents such as the gearbox and main bearing
(Hameed et al. 2009), while far forming part of
the actual engineering practice (Grasse et al. 2011)
Structural Health Monitoring (SHM) systems are
deployed mostly for research purposes, or tempo-
rarily during the certification stage. In fact, there
exists a dislocation between (i) data derived from
CM systems (e.g. power output, rotor RPM), (ii)
data obtained from specialized SHM (e.g. tower
acceleration, strain on blade root), and (iii) spe-
cialized maintenance strategies of individual WT
components. As a result, there are currently no
holistic approach, and systematic, quantitative and
automated tools for monitoring and diagnostics of
sion making within their life-cycle. Towards this
end, we propose to perform automated fault diag-
nostics and root cause analysis of faults on wind
turbines (WTs) on the basis of decision tree clas-
sifiers. A decision tree is a predictive model that
maps observations to their target values or labels.
The key concept lies in running WT telemetry data
through a decision tree learning algorithm for
detecting faults, errors, damage patterns, anoma-
lies and abnormal operation (i.e., end states).
A decision tree essentially comprises a machine
learning tool for classification of event outcomes.
For a given initiating event, multiple end states are
possible, linking each event to an associated prob-
ability of occurrence. Once built and trained, and
given a new set of measurements, the decision tree
may be used to predict end states and classify (dis-
cover) previously unknown end states. By examin-
ing the paths that lead to failure-predicting leaf
nodes, one may distinguish the possible sources
(root causes) of error. The remainder of this arti-
cle is organized as follows. In section 2 we revisit
the decision tree learning theory. In section  3 we

3053
train an ensemble of bagged decision tree clas-
sifiers with the standard CART algorithm on a
condition monitoring data set from the Lillgrund
offshore wind farm comprising 48 wind turbines
and use it to perform a diagnostics to elucidate
the root cause of excessive vibrations. Finally, in
section  4 we further our discussion to show how
decision tree learning can be expanded to big data
based applications for monitoring and diagnostics
for wind turbines using the object-oriented based
decision tree concept cite (Abdallah 2017).
2 DECISION TREES
A Decision Tree (also called Classification or Pre-
diction Tree) is designed to classify or predict a dis-
crete category from the data. Decision Trees (DTs)
are a non-parametric supervised learning method
used for classification (and regression). In the
machine learning sense, the goal is to create a clas-
sification model (classification tree) that predicts
the value of a target variable (also known as label
or class) by learning simple decision rules inferred
from the data features (also known as attributes
or predictors). From Figure 1 an internal node N
denotes a test on an attribute, an edge E represents
an outcome of the test, and the Leaf nodes C rep-
resent class labels or class distribution.
Four reasons motivated us to work with deci-
sion tree classifiers. First, they can be learned
and updated from data relatively fast compared
to other methods. Second, they are visually more
intuitive, simpler and easier to assimilate and
interpret by humans/engineers. Third, unlike other
classification methods, with decision tree classifi-
ers one is able to perform data-driven root cause
analysis of faults; one can trace a path from the
end state (e.g. blade damage) to the initiating event
(e.g. wrong parameters in control system), a way
that follows the sequence and chronology of how
events are interlinked. Last, it has been shown that
Figure  1. Graphical representation of a decision tree
(DT) classifier. DT terminologies are also shown.
3054
the accuracy of decision tree classifiers is compara-
ble or superior (especially ensemble descision tree
classifiers) to other models and in fact display the
best combination of error rate and speed (Lim,
Loh, & Shih 1997, Hand 1997, Lim, Loh, & Shih
2000, Caruana & Niculescu-Mizil 2006).
A decision tree is is a tree-structured classifier
built by starting with a single node that encom-
passes the entire data and recursively splitting the
data within a node, generally into two branches
(some algorithms can perform multiway splits) by
selecting the variable (dimension) that best clas-
sifies the samples according to a split criterion,
i.e. the one that maximizes the information gain
(Equation 1) among the random subsample of
dimensions obtained at every point. The splitting
continues until a terminal leaf is created that meets
a stopping criterion such as a minimum leaf size or
a variance threshold. Each terminal leaf contains
data that belongs to one or more classes. Within
this leaf, a model is applied that provides a fairly
comprehensible prediction, especially in situations
where many variables may exist that interact in a
nonlinear manner as is often the case on wind tur-
bines (Carrasco Kind & Brunner 2013). Algorithm
1 shows pseudocode of a generic decision tree
learning algorithm.
Formally, the splitting is done by choosing the
attribute that maximizes the Information Gain
(IG), which is defined in terms of the impurity
degree index:
Tm
IG (T , M ) = I d (T ) − ∑
m ∈M T
I d (Tm ) (1)
where T is the training data in a given node, M is
one of the possible dimensions along which the
node may be split, m are the possible values of
M, |T | is the size of the training data, |Tm| is the
number of objects for a given subset m within the
current node, and Id is the function that represents
the degree of impurity of the information. There
are three standard methods to compute the impu-
rity index (Id). The first method is by using the
information entropy (H), which is defined by:
n
I d (T ) ≡ H (T ) = − ∑ fi log 2 ( fi ) (2)
i =1
where i is the class to be predicted, n is all pos-
sible classes, and fi is the fraction of the training
data belonging to class i. The second option, is to
measure the Gini impurity (G). In this case, a leaf
is considered pure if all the data contained within
it have the same class. The Gini impurity can be
computed inside each node using the following
simplified equation:
 n
I d (T ) ≡ G (T ) = 1 − ∑ fi 2 (3)
i =1
The third method is to use the classification
error (CE):
I d (T ) ≡ CE (T ) = 1 − max fi (4)
where the maximum values are taken among the
fractions fi within the data T that have class i. Fig-
ure 2 shows the three impurity indices, for a node
with data that are categorized into two classes, as
a function of the fraction of the data having a spe-
cific class. If all of the data belong to one class, the
impurity is zero. On the other hand, if half of the
data have one class and the remaining data belong
to the other class, the impurity is at its maximum
(Carrasco Kind and Brunner 2013).
There exist several algorithms for training deci-
sion trees from data including ID3, C4.5, C5.0,
J48, SPRINT, FACT, FIRM, SLIQ, CHAID,
QUEST, CRUISE, PUBLIC, BOAT, RAINFOR-
EST, MARS, RIPPER and CART. In the following
we will briefly mention some ofthe more common
algorithms. Ross Quinlan developed ID3 (Quinlan
1986) which stands for Iterative Dichotomiser 3,
and its later iterations include C4.5 and C5.0. ID3
attempts to generate the smallest multiway tree. If
the problem involves real-valued variables, they
are first binned into intervals, each interval being
treated as an unordered nominal attribute. C4.5
converts the trained trees into sets of if-then rules
(Quinlan 1994) and improves on ID3 by allowing
both discrete and continuous attributes, missing
Figure 2. Impurity index Id for a two-class example as a
function of the probability of one of the classes f1 using
the information entropy, Gini impurity and classification
error. In all cases, the impurity is at its maximum when
the fraction of data within a node with class 1 is 0.5, and
zero when all data are in the same category.
3055
attribute values, attributes with differing costs,
and pruning trees to avoid over-fitting are usually
applied to improve the ability of the tree to gen-
eralise to unseen data. The accuracy of each rule
is then evaluated to determine the order in which
they should be applied. C5.0 is essentially the same
as C4.5 but uses less memory and builds smaller
rule sets while being more accurate.
CART (Breiman, Friedman, Olshen, & Stone
1984) which stands for Classification and Regres-
sion Trees is very similar to C4.5, but it differs in
that it supports numerical target variables (regres-
sion) and constructs binary tree based on a numer-
ical splitting criterion recursively applied to the
data instead of constructing rule sets.
According to (Lim, Loh, & Shih 2000) C4.5 and
QUEST have the best combinations of error rate
and speed, but C4.5 tends to produce trees with
twice as many leaves as those from Quest. QUEST
is a binary-split decision tree algorithm for classifi-
cation and regression (Loh & Shih 1997). It uses a
significance test to select variables for splitting. An
advantage of the QUEST tree algorithm is that it is
not biased in split-variable selection, unlike CART
which is biased towards selecting split-variables
which allow more splits, and those which have
more missing values.
CRUISE is one of the most accurate decision
tree classifiers (Loh 2011) that is also efficiently
capable of performing multiway splits. (Kim &
Loh 2001) proposed CRUISE which stands for
Classification Rule with Unbiased Interaction
Selection and Estimation that splits each node into
as many as subnodes, which precludes the use of
greedy search methods. CRUISE is practically free
of selection bias (Kim & Loh 2001) and is capable
of integrating interactions between variables when
growing the tree. CRUISE borrows and improves
upon ideas from many sources, but especially from
FACT, QUEST, and GUIDE for split selection
and CART for pruning.
Finally a word about RainForest which is not a
decision tree classifier per se but rather a frame-
work. RainForest was proposed to make decision
tree construction more scalable (same as BOAT
which is in fact faster than RainForest by a fac-
tor of three while constructing exactly the same
decision tree, and can handle a wide range of
splitting criteria (Gehrke et al. 1999)). Accord-
ing to (Gehrke et al. 2000), a thorough examina-
tion of the algorithms in the literature (including
C4.5, CART, CHAID, FACT, ID3 and extensions,
SLIQ, Sprint and QUEST) shows that the greedy
schema described in Algorithm 4 can be refined
to a generic RainForest tree induction schema. In
fact, most decision tree algorithms consider every
attribute individually and need the distribution of
class labels for each distinct value of an attribute
to decide on the splitting criteria. Rainforest is a
comprehensive approach for decision tree classi-
fiers that separates the scalability aspects of algo-
rithms for constructing a decision tree from the
central features that determines the quality of the
tree. Rainforest concentrates on the growth phase
of a decision tree due to the time consuming nature
of this step RainForest, closes the gap between the
limitations to main memory datasets of algorithms
in the machine learning and statistics literature and
the scalability requirements of a data mining envi-
ronment (Singh & Sulekh 2017).
Next we present a demonstration of deci-
sion tree classifier learning based on a real-world
SCADA data set from the Lillgrund offshore wind
farm.
3 DEMONSTRATION
Condition monitoring data from 48 wind turbines
was collected over a period of 12 months and
3056
sampled every 10 minutes, across 64 channels. In
total, more than 2.5 million records were available,
of which 980 excessive vibration error events are
recorded across all wind turbines. The error event
of interest in this demonstration is excessive struc-
tural vibrations.
Data Pre-processing The first step prepares the
data for the construction of the prediction tree
classifier. Knowledge of the process is helpful in
the elimination of parameters (features) that are
not significant. The SCADA system recorded
parameters can be grouped into the following
categories: (i) system related data, e.g., turbine
number and index, time stamp, are turbine specific
and, therefore, can be excluded from the decision
tree classifier training, (ii) operating performance
parameters such as power output, pitch and rotor
speed, (iii) environmental parameters such as wind
speed and wind direction, (iv) temperature meas-
urements for various components such as gearbox,
bearings and generator, and finally (4) dynam-
ics parameters such as tower top accelerations.
The attributes chosen in this demonstration are
shown in Table  1. The table includes both origi-
nal sensor attributes such as maximum generator
rotational speed over a 10min period (GRpm_max)
and additional derived parameters such as the dif-
ference between max and min wind speed over a
10min period (DMaxMinV). We open a small
parenthesis here. As with most pattern recogni-
tion methods, tree-based classification methods
work best if the proper features are selected to
start with; preprocessing by a data dimensionality
reduction techniques such as principal component
analysis (PCA) or independent component analy-
sis (ICA) or optimal feature selection approaches
such as the wrapper approach integrated with the
genetic or the best-first search algorithms can be
effective because they find important axes to be
used as guideline for the selection of the features
upon which a decision tree is trained. However,
Table 1. The attributes (features) used as input to train
the decision tree classifier.
Attributes Description
HSGenTmp Mean temperature of gear bear-
ing on generator side
Po_max Max value of active power
DMaxMeanPow Difference between max and
mean active power
GRpm_max Max generator RPM
DMaxMeanGRpm Difference between max and
mean generator RPM
Pi_min Min collective pitch
DMaxMinV Difference between max and
min wind speed
in this demonstration we chose not to in order to
test the limit of a decision tree classifier for fault
diagnostics; for instance wind speed, power and
RPM are strongly inter-dependent attributes, but
for the same wind speed a wind turbine could be
found operating at two different power output lev-
els (during distinct time periods) or two different
generator RPM levels, and both cases are consid-
ered normal operating modes. How so? Indeed this
happens very often when a wind turbine has to
de-rate the power output following a demand from
the grid side or reduce the generator RPM under
a specific noise or load control mode. The target
variable TurbineState for classification is shown in
Table 2. It can take two labels, NoFault indicating
that the wind turbine is producing electric power
under normal operating conditions, and Vibr indi-
cating an excessive vibration fault resulting in the
wind turbine shutting down, furthermore trigger-
ing a message to be send to the vibration support
technical team (in order for some corrective action
to take place).
Bagged decision tree construction The second
step is the construction of the Bagged decision
tree classifier. An ensemble of decision trees is
often more accurate than any single tree classi-
fier (Bauer & Kohavi 1999, Dietterich 1996). Bag-
ging (Breiman 1996), boosting (Schapire 1990)
and random forest are three popular methods of
creating accurate ensembles. Previous research
indicates that boosting is more prone to overfit-
ting the training data (Freund & Schapire 1996,
Opitz & Maclin 1999). Consequently, the pres-
ence of noise causes a greater decrease in the per-
formance of boosting. Therefore, this study uses
bagging to create an ensemble of bagged decision
tree classifiers (using the standard CART algo-
rithm) to better address the noise in the condition
monitoring data. Other decision tree algorithms
and ensemble approaches will be investigated in
future work. This technique can be summarized
as, (i) take a bootstrap sample from the data set,
(ii) train an un-pruned classification tree and
(iii) aggregate the trained tree classifiers. In more
detail, Bagging predictors comprise a method for
generating multiple versions of a predictor, each
Table  2. Target variable: Turbine State. Turbine state
is defined in this demonstration according to two labels.
Class label Description
NoFault Normal operation, turbine is producing
power, no faults
Vibr Structural vibrations error resulting in:
“Inform Vibration Support”
3057
on random subsets of the original dataset, and fus-
ing these into a unique final aggregated predictor.
This aggregated predictor can typically be used
for reducing the variance of a black-box estima-
tor, by introducing randomization into the con-
struction procedure and forming an ensemble (for
proof refer to (Breiman 1996, Bühlmann 2012)).
The bagging algorithm consists in (1) construct-
ing a bootstrap sample (X *(1) ,Y*(1) ) ,…, (X *( n ) ,Y*( n ) )
by randomly drawing n times with replacement
from the original data ( X (1) ,Y (1) ) ,…,( X ( n ) ,Y ( n ) ) ,
(2) computing the bootstrapped estimator (i.e. tree
classifier) gˆ* = hn ( X *(1) ,Y*(1) ) ,…, ( X *( n ) ,Y*( n ) ) where
the function hn(.) defines the estimator as a func-
tion of the data, and (3) repeating steps 1 and 2
M times, where M is often chosen as 50 or 100,
yielding { gˆ*k , k = 1,…, M } and the bagged estima-
tor is gˆbagg = ∑ k = 1 gˆ*k M . In theory, M → ∞ if the
M
bagged estimator is
gˆbagg = E [ gˆ*k ] (5)
In the machine learning and statistics literature,
the two main performance measures for a clas-
sification tree algorithm are its predictive quality
and construction time of the resulting tree. In this
paper the predictive quality is given by the misclas-
sification rate on the validation data set. As shown
in Figure 4, the misclassification rate of the trained
Bagged tree is less than 1% when the bag size is
more than 10.
Fault diagnostics (offline) The final step uses
the newly generated decision tree classifier (e.g.
Figure  3) to create diagnostics for individual
target fault classes, i.e. Vibr. One aspect of fault
diagnostics deals with offline root cause analysis,
which we will demonstrate here. When diagnos-
ing faults, we are interested in identifying the root
causes (or sequence of events) that lead to a large
portion of the overall abnormal behavior, where
the decision tree edges leading to faults become
root cause candidates. In the literature, one can
find a limited number of proposed programatic
algorithms by which decision tree classifiers can
be scanned/probed for root cause analysis (Solé,
Muntés-Mulero, Rana, & Estrada 2017). One
implementation is as follows (Zheng, Lloyd, &
Brewer 2004):
1. Ignore the leaf nodes that correspond to nor-
mal operations (i.e. NoFault) as they will not be
useful in diagnosing faults.
2. Identify, in the decision tree, all leaf nodes with
the target fault class of interest, i.e. Vibr
3. Ranking: list the leaf nodes with the target fault
class ranked by failure count to prioritize their
importance.

Figure  3. Part of the decision tree classifier based on
the SCADA data from 48 wind turbines.
4. Noise Filtering: in diagnostics, we are interested
in identifying the root causes that result in a
large proportion of the overall faults. Thus we
retain the leaf nodes accounting for more than
a certain threshold of the total number of faults
(e.g.) threshold = 5%)
5. Extract traces (paths) containing the target
fault leaf node (C), and all edges (E) and inter-
nal nodes (N) up to the root node (R).
6. Extract rules at each internal node of the traces
7. Node Merging: we merge nodes on a path by
eliminating ancestor nodes that are logically
subsumed by successor nodes.
Below is an example of an automated extraction
of a sequential trace of events (root causes) from
the trained decision tree classifier (see Figure  3),
leading from the classified fault to the root of the
tree:
Vibr ← 1503.6 <= GRpm _ mar < 1539.05 ←
110.455 <= DMaxMeanGRpm < 380.51 ←
DMaxMinV > = 10.65
This sequential trace of events indicate that the
fault Vibr can possibly occur when, over a period
of 10 minutes, the maximum generator speed is
in the range 1503.6–1549.05 RPM, the difference
between max and mean generator speed is in the
range of 110.45–380.51  RPM and the difference
between the max and min wind speed exceeds
10.65 m/s. Note that it is not possible to infer from
the data the time interval during which the large
change in wind speed occured but it could well be
an indication of agust or excessive turbulence over
3058
a short period of time resulting in the excessive
vibration fault. Another example of an automated
extraction of a sequential trace of events (root
causes) leading from the classified fault to the root
of the tree is as follows:
Vibr ← Po _ max < 2377 ← DMaxMinV > =
8.05 ←DMaxMeanGRpm > = 380.51
This sequential trace of events indicate that the
fault Vibr can possibly occur when, over a period
of 10 minutes, the maximum electric power out-
put does not exceed, 2377  kW, the difference
between max and mean generator speed exceeds
380.51 RPM and the difference between the max
and min wind speed exceeds 8.05 m/s.
This approach to data-driven root cause analysis
elegantly elucidates the traces of events that lead to
a fault. These traces can subsequently be used by an
engineer to design simulation scenarios to try and
replicate the faults and to propose mitigating actions.
4 OUTLOOK: BIG DATA BASED
MONITORING AND DIAGNOSTICS
FRAMEWORK
So far we demonstrated how offline root cause
analysis can be conducted via an ensemble based
Bagged decision tree learning from SCADA data
of 48 wind turbines based on the CART algorithm.
In this section we summarize an outlook for a
monitoring and diagnostics framework that would
perform on big data and in real-time. The intent is
for this framework to be deployed on a cloud such
as Azure and scale as the volume of streamed data
increases. Figure 5 shows an overview of the archi-
tecture of the framework. The main features of the
framework include:
Figure 4. Misclassification rate of the validation set as
a function of tree bag size.
Figure 5. Graphical summary of the proposed framework decision tree learning with big data for fault diagnostics.
• Hardware-software package, able to acquire
and fuse in real-time both condition monitoring
(CM) (e.g. electric power output, rotor speed)
and specialized structural health monitoring
(SHM) data (e.g. tower accelerations, strains on
blade) from WT components (e.g. blades, gear-
box, tower, etc.).
• Computational core: object-oriented decision
tree learning algorithm, Bayesian network (BN)
based computation of probabilities and root-
cause discovery algorithm (as demonstrated in
the previous section).
• Distributed cloud based data storage and analyt-
ics of the high rate of real-time data streaming
from the measuring unit on the WT, which inter-
faces with the real-time decision-tree software
unit. Hence, the toolkit does not need to save
data and do heavy computations on remote WT.
• Online user interface to visualize the output
from the decision tree (decision support tool).
In the following we elaborate a bit more on: (i)
the cloud computing, storage and analytics, and
(ii) object-oriented decision tree learning aspects.
i. For efficient fusion of the large bulk of infor-
mation made available from the condition and
structural health monitoring systems consti-
tutes a Big Data problem, as large amounts
of data are continuously sampled at high and
diverse rates from the WTs within a wind farm.
Thus, the integration of a distributed cloud
3059
based data storage and analytics is a natural
fit with consequent reduction in the cost of
handling and manipulating of said data (see
Figure  6). In the proposed framework, large
scale storage of historical data from WTs
is done via the Hadoop Data File System
(HDFS). HDFS is a distributed file system that
is fault tolerant and can load large volumes
of data, in a distributed manner, even if any
errors occurs. Telemetry and data acquisition
is supported by Apache Kafka which is a dis-
tributed streaming platform that aims to pro-
vide a unified, high-throughput, low-latency
methodology for handling real-time data feeds.
Kafka is a fault-tolerant system, meaning that
if any error occurs, published data would still
be available in case the application or Kafka
is stopped, is offline and then restarted. Thus,
Kafka can be guaranteed not to miss any data
that is issued from the wind turbines. Finally,
for data processing purposes, Apache Spark is
used. Spark is an in-memory fast and general
engine for large-scale data processing. In addi-
tion, Spark can scale to thousands of machines
in a fault-tolerant manner. These characteris-
tics make Apache Spark very suitable to proc-
ess and analyze the large volumes of data that
are gathered from the wind turbines (Canizo,
Onieva, Conde, Charramendieta, & Trujillo
2017).

Figure 6. Cloud computing and storage.
ii. A priori Decision Trees are built first to serve
the fundamental diagnostic tasks by combining
engineering knowledge of the system, failure
modes and domain knowledge. The dynamic
decision tree classifiers are trained over time
from wind turbine telemetry (CM & SHM
data). The limitation in traditional decision tree
classifiers appears when the component displays
a behaviour with feedback (i.e., after a repair/
update in the system) or for evolving systems
(e.g. when new sensors are integrated or aging
of the system), which implies a need to estab-
lish several decision trees based on the possible
ordering of the events or based on new initiat-
ing events. One way around this is an innova-
tion that we introduced in this framework in
the form of object-oriented decision tree learn-
ing (Wyss & Durán 2001). To this end, a WT
is viewed as a multi-layered system of objects
(e.g. structure, controller, actuator, etc.) that are
defined on the basis of abstract super-classes,
attributed with specific properties and methods.
Decision trees classifier are further mapped
into Bayesian Networks for further assessment
of the conditional probabilities (Bearfield &
Marsh 2005, Jassens, Wets, Brijs, Van Vanhoof,
Arentz, & Timmermans 2006). The integration
of the object-oriented decision tree learning
and BN delivers updated probability of occur-
rence associated with each event and end state,
which would form a solid indicator of the risk
of future failure of any given component.
5 CONCLUSIONS
We presented a review of several decision tree clas-
sification algorithms. We then demonstrated how
data-driven and automated root cause analysis can
be conducted via an ensemble based Bagged deci-
sion tree learning from SCADA data of 48 wind
turbines based on the CART algorithm. Root cause
3060
analysis is here cast in the sense of programmati-
cally discovering the sequence of events (paths)
leading from a classified fault at the leaf, all the
way to the root of the decision tree classifier. These
traces can subsequently be used by an engineer to
design simulation scenarios to try and replicate the
faults and to propose mitigating actions. Finally,
we briefly presented an architecture for a moni-
toring and diagnostics framework that would per-
form on big data. In particular we highlighted the
need for cloud based storage and computing, and
an innovative approach based on object-oriented
decision tree learning that extends the traditional
decision tree classifier concept. In the future, more
concrete implementations and results of the pro-
posed framework will be disseminated.
ACKNOWLEDGEMENTS
The authors acknowledge the support of the Euro-
pean Research Council via the ERC Starting Grant
WINDMIL (ERC-2015-StG #679843) on the
topic of Smart Monitoring, Inspection and Life-
Cycle Assessment of Wind Turbines. We would
like to thank Vattenfall AB for providing access to
the SCADA data from the Lillgrund offshore wind
farm.
REFERENCES
Abdallah, I., V. Dertimanis, & E. Chatzi (2017). Data-
driven identification, classification and update of
decision tress for monitoring and diagnostics of wind
turbines. In 2nd ECCOMAS Thematic Conference,
UNCECOMP, Rhodes Island, Greece.
Bauer, E. & R. Kohavi (1999). An empirical comparison of
voting classification algorithms: Bagging, boosting, and
variants. Mach. Learn. 36, 105–139.
Bearfield, G. & W. Marsh (2005). Generalising event trees
using bayesian networks with a case study of train
derailment. In International Conf. on Comp. Saf., Reli.,
and Sec., SAFECOMP, Fredrikstad, Norway, pp.
52–66.
Breiman, L. (1996). Bagging predictors. Mach. Learn. 24,
123–140.
Breiman, L., J. Friedman, R. Olshen, & C. Stone (1984).
Classification and Regression Trees. Wadsworth Inc.
Bühlmann, P. (2012). Bagging, boosting and ensemble
methods. In J. Gentle and Y. Mori (Eds.), Handbook of
comp. stat., Chapter 33, pp. 985–1022. Springer.
Canizo, M., E. Onieva, A. Conde, S. Charramendieta, &
S. Trujillo (2017). Real-time predictive maintenance for
wind turbines using big data frameworks. In Proc. on
IEEE Int. Conf. on Prognostics and Health Manage-
ment, Allen, TX, USA, pp. 70–77.
Carrasco Kind, M. & R. Brunner (2013). Tpz: Photometric
redshift pdfs and ancillary information by using predic-
tion trees and random forests. Monthly Notices of the
Royal Astronomical Society 432, 1483–1501.
Caruana, R. & A. Niculescu-Mizil (2006). An empirical
comparison of supervised learning algorithms. In Proc.
of the 23rd inter. conf. on Mach. lear., Pittsburgh, Penn-
sylvania, USA, pp. 161–168.
Dietterich, T. (1996). Applying the weak learning frame-
work to understand and improve c4.5. In Proc. 13th
International Conference on Machine Learning, pp.
96–104.
Freund, Y. & R. Schapire (1996). Experiments with a new
boosting algorithm. In Proc. 13th International Confer-
ence on Machine Learning, pp. 148–156.
Gehrke, J., R. Ramakrishnan, & V. Ganti (2000). Rainforest
—A framework for fast decision tree construction of
large datasets. Data Min. Knowl. Discov. 4(2/3), 127–162.
Gehrke, J., V. Ganti, R. Ramakrishnany, & W. Lohz (1999).
BOAToptimistic decision tree construction. In Proc.
of the 1999 ACM SIGMOD intern. conf. on Manag. of
data, Stockholm, Sweden, pp. 169–180.
Grasse, F., V. Trappe, S. Thoens, & S. Said (2011). Struc-
tural health monitoring of wind turbine blades by strain
measurement and vibration analysis. In Proc. of the 8th
International Conference on Struct. Dyn.(EURODYN),
Leuven, Belgium.
Hameed, Z., Y.S. Hong, S.H. Ahn, & C.K. Song (2009).
Condition monitoring and fault detection of wind tur-
bines and related algorithms: A review. Renewable and
Sustainable Energy Reviews 13, 1–39.
Hand, D. (1997). Construction and Assessment of Classifi-
cation Rules. Chichester: John Wiley and Sons.
Jassens, D., G. Wets, T. Brijs, K. Vanhoof, T. Arentz, & H.
Timmermans (2006). Integrating Bayesian Networks
and decision trees in a sequential rule-based transporta-
tion model. Euro. J. Oper. Res. 1, 16–34.
Kim, H. & W. Loh (2001). Classification trees with unbi-
ased multiway splits. J. Amer. Statist. Assoc. 96, 598–604.
Lim, T., W. Loh, & Y. Shih (1997). An empirical compari-
son of decision trees and other classification methods.
3061
Technical Report TR 979, Department of Statistics,
UW Madison.
Lim, T., W. Loh, & Y. Shih (2000). A comparison of predic-
tion accuracy, complexity, and training time of thirty-
three old and new classification algorithms. Machine
Learning Journal. 4, 203–228.
Loh, W. & Y. Shih (1997). Split selection methods for clas-
sification trees. Statistica Sinica 7, 815–840.
Loh, W.Y. (2011). Classification and regression trees. Wiley
Interdiscip. Rev. Data Min. Knowl. Discov. 1, 14–23.
Opitz, D. & R. Maclin (1999). The strength of weak learn
ability. Popular ensemble methods: an empirical study 1,
169–198.
Quinlan, J.R. (1986). Induction of decision trees. Machine
Learning 1, 81–106.
Quinlan, J.R. (1994). Programs for Machine Learning.
Morgan Kaufmann Publishers.
Schapire, R. (1990). The strength of weak learn ability.
Mach. Learn. 5, 197–227.
Singh, K. & R. Sulekh (2017). The comparison of vari-
ous decision tree algorithms for data analysis. Interna-
tional Journal Of Engineering And Computer Science 6,
21557–21562.
Solé, M., V. Muntés-Mulero, A.I. Rana, & G. Estrada
(2017). Survey on Models and Techniques for Root-
Cause Analysis. ArXiv e-prints.
Wyss, G.D. & F.A. Duŕan (2001). OBEST: The object
based event scenario tree methodology. Technical
Report SAND2001-0828, Sandia National Laborato-
ries, Albuquerque, CA, USA.
Yang, B. & D. Sun (2013). Testing, inspecting and moni-
toring technologies for wind turbine blades: A survey.
Renewable and Sustainable Energy Reviews 22, 515–526.
Zheng, A.X., J. Lloyd, & E. Brewer (2004). Failure diagno-
sis using decision trees. In Proc. of the 1st Intern. Conf.
on Autonomic Comp., ICAC, Washington, DC, USA,
pp. 36–43.