L = resubLoss(tree)
L = resubLoss(tree,Name,Value)
L = resubLoss(tree,'Subtrees',subtreevector)
[L,se] =
resubLoss(tree,'Subtrees',subtreevector)
[L,se,NLeaf]
= resubLoss(tree,'Subtrees',subtreevector)
[L,se,NLeaf,bestlevel]
= resubLoss(tree,'Subtrees',subtreevector)
[L,...] = resubLoss(tree,'Subtrees',subtreevector,Name,Value)
returns
the resubstitution loss, meaning the loss computed for the data that L
= resubLoss(tree
)fitctree
used to create tree
.
returns
the loss with additional options specified by one or more L
= resubLoss(tree
,Name,Value
)Name,Value
pair
arguments. You can specify several namevalue pair arguments in any
order as Name1,Value1,…,NameN,ValueN
.
returns
a vector of classification errors for the trees in the pruning sequence L
= resubLoss(tree
,'Subtrees'
,subtreevector)subtreevector
.
[
returns
the vector of standard errors of the classification errors.L
,se
] =
resubLoss(tree
,'Subtrees'
,subtreevector)
[
returns
the vector of numbers of leaf nodes in the trees of the pruning sequence.L
,se
,NLeaf
]
= resubLoss(tree
,'Subtrees'
,subtreevector)
[
returns
the best pruning level as defined in the L
,se
,NLeaf
,bestlevel
]
= resubLoss(tree
,'Subtrees'
,subtreevector)TreeSize
namevalue
pair. By default, bestlevel
is the pruning level
that gives loss within one standard deviation of minimal loss.
[L,...] = resubLoss(
returns
loss statistics with additional options specified by one or more tree
,'Subtrees'
,subtreevector,Name,Value
)Name,Value
pair
arguments. You can specify several namevalue pair arguments in any
order as Name1,Value1,…,NameN,ValueN
.

Classification error, a vector the length of 

Standard error of loss, a vector the length of 

Number of leaves (terminal nodes) in the pruned subtrees, a
vector the length of 

A scalar whose value depends on

The default classification error is the fraction of the training
data X
that tree
misclassifies.
Weighted classification error is the sum of weight i times
the Boolean value that is 1
when tree
misclassifies
the ith row of X
, divided by
the sum of the weights.
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)}.$$
'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)}.$$
'classiferror'
— Predict
the label with the largest posterior probability. The loss is then
the fraction of misclassified observations.
'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 in this form:
function loss = lossfun(C,S,W,COST)
N
is the number of rows of X
.
K
is the number of classes in the
classifier, represented in the ClassNames
property.
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 the ClassNames
property.
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. If you pass W
, the elements
are normalized to sum to the prior probabilities in the respective
classes.
COST
is a K
byK
numeric
matrix of misclassification costs. For example, you can use COST = ones(K)  eye(K)
,
which means a cost of 0
for correct classification,
and 1
for misclassification.
The output loss
should be a scalar.
Pass the function handle @
as
the value of the lossfun
LossFun
namevalue pair.
There are two costs associated with classification: the true misclassification cost per class, and the expected misclassification cost per observation.
You can set the true misclassification cost per class in the Cost
namevalue
pair when you create the classifier using the fitctree
method. Cost(i,j)
is
the cost of classifying an observation into class j
if
its true class is i
. By default, Cost(i,j)=1
if i~=j
,
and Cost(i,j)=0
if i=j
. In other
words, the cost is 0
for correct classification,
and 1
for incorrect classification.
There are two costs associated with classification: the true misclassification cost per class, and the expected misclassification cost per observation.
Suppose you have Nobs
observations that you
want to classify with a trained classifier. Suppose you have K
classes.
You place the observations into a matrix Xnew
with
one observation per row.
The expected cost matrix CE
has size Nobs
byK
.
Each row of CE
contains the expected (average)
cost of classifying the observation into each of the K
classes. CE(n,k)
is
$$\sum _{i=1}^{K}\widehat{P}\left(iXnew(n)\right)C\left(ki\right)},$$
where
K is the number of classes.
$$\widehat{P}\left(iXnew(n)\right)$$ is the posterior probability of class i for observation Xnew(n).
$$C\left(ki\right)$$ is the true misclassification cost of classifying an observation as k when its true class is i.
fitctree
 loss
 resubEdge
 resubMargin
 resubPredict