L = oobloss(ens)
L = oobloss(ens,Name,Value)
returns
the classification error for L
= oobloss(ens
)ens
computed for outofbag
data.
computes
error with additional options specified by one or more L
= oobloss(ens
,Name,Value
)Name,Value
pair
arguments. You can specify several namevalue pair arguments in any
order as Name1,Value1,…,NameN,ValueN
.

A classification bagged ensemble, constructed with 
Specify optional commaseparated pairs of Name,Value
arguments.
Name
is the argument
name and Value
is the corresponding
value. Name
must appear
inside single quotes (' '
).
You can specify several name and value pair
arguments in any order as Name1,Value1,...,NameN,ValueN
.

Indices of weak learners in the ensemble ranging from Default: 

Function handle or string representing a loss function. Builtin loss functions:
You can write your own loss function in the syntax described in Loss Functions. Default: 

String representing the meaning of the output
Default: 

Classification error of the outofbag observations, a scalar. 
Bagging, which stands for "bootstrap
aggregation", is a type of ensemble learning. To bag a weak
learner such as a decision tree on a dataset, fitensemble
generates
many bootstrap replicas of the dataset and grows decision trees on
these replicas. fitensemble
obtains each bootstrap
replica by randomly selecting N
observations out
of N
with replacement, where N
is
the dataset size. To find the predicted response of a trained ensemble, predict
take
an average over predictions from individual trees.
Drawing N
out of N
observations
with replacement omits on average 37% (1/e) of
observations for each decision tree. These are "outofbag" observations.
For each observation, oobLoss
estimates the outofbag
prediction by averaging over predictions from all trees in the ensemble
for which this observation is out of bag. It then compares the computed
prediction against the true response for this observation. It calculates
the outofbag error by comparing the outofbag predicted responses
against the true responses for all observations used for training.
This outofbag average is an unbiased estimator of the true ensemble
error.
The builtin loss functions are:
'binodeviance'
— For binary
classification, assume the classes y_{n} are 1
and 1
.
With weight vector w normalized to have sum 1
,
and predictions of row n of data X as f(X_{n}),
the binomial deviance is
$$\sum {w}_{n}\mathrm{log}\left(1+\mathrm{exp}\left(2{y}_{n}f\left({X}_{n}\right)\right)\right)}.$$
'classiferror'
— Fraction
of misclassified data, weighted by w.
'exponential'
— With the
same definitions as for 'binodeviance'
, the exponential
loss is
$$\sum {w}_{n}\mathrm{exp}\left({y}_{n}f\left({X}_{n}\right)\right)}.$$
'hinge'
— Classification
error measure that has the form
$$L=\frac{{\displaystyle \sum}_{j=1}^{n}{w}_{j}\mathrm{max}\left\{0,1{y}_{j}\prime f\left({X}_{j}\right)\right\}}{{\displaystyle \sum}_{j=1}^{n}{w}_{j}},$$
where:
w_{j} is weight j.
For binary classification, y_{j} = 1 for the positive class and 1 for the negative class. For problems where the number of classes K > 3, y_{j} is a vector of 0s, but with a 1 in the position corresponding to the true class, e.g., if the second observation is in the third class and K = 4, then y_{2} = [0 0 1 0]′.
$$f({X}_{j})$$ is, for binary classification, the posterior probability or, for K > 3, a vector of posterior probabilities for each class given observation j.
'mincost'
— Predict the
label with the smallest expected misclassification cost, with expectation
taken over the posterior probability, and cost as given by the Cost
property
of the classifier (a matrix). The loss is then the true misclassification
cost averaged over the observations.
To write your own loss function, create a function file of the form
function loss = lossfun(C,S,W,COST)
N
is the number of rows of X
.
K
is the number of classes in tree
,
represented in tree.ClassNames
.
C
is an N
byK
logical
matrix, with one true
per row for the true class.
The index for each class is its position in tree.ClassNames
.
S
is an N
byK
numeric
matrix. S
is a matrix of posterior probabilities
for classes with one row per observation, similar to the posterior
output
from predict
.
W
is a numeric vector with N
elements,
the observation weights.
COST
is a K
byK
numeric
matrix of misclassification costs. The default 'classiferror'
cost
function uses a cost of 0
for correct classification,
and 1
for misclassification. In other words, 'classiferror'
uses COST=ones(K)eye(K)
.
The output loss
should be a scalar.
Pass the function handle @
as
the value of the lossfun
lossfun
namevalue pair.
Find the outofbag error for a bagged ensemble from the Fisher iris data:
load fisheriris ens = fitensemble(meas,species,'Bag',100,... 'Tree','type','classification'); L = oobLoss(ens) L = 0.0467
loss
 oobEdge
 oobMargin
 oobPredict