L = loss(mdl,X,Y)
L = loss(mdl,X,Y,Name,Value)
returns
a scalar representing how well L
= loss(mdl
,X
,Y
)mdl
classifies the
data in X
, when Y
contains the
true classifications.
When computing the loss, loss
normalizes the
class probabilities in Y
to the class probabilities
used for training, stored in the Prior
property
of mdl
.
returns
the loss with additional options specified by one or more L
= loss(mdl
,X
,Y
,Name,Value
)Name,Value
pair
arguments.

Classification error, a scalar. The meaning of the error depends
on the values in 
The default classification error is the fraction of data X
that mdl
misclassifies,
where Y
represents the true classifications.
The weighted classification error is the sum of weight i times
the Boolean value that is 1
when mdl
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 KNN 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 run fitcknn
. 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 KNN classification: the
true misclassification cost per class, and the expected misclassification
cost per observation. The third output of predict
is
the expected misclassification cost per observation.
Suppose you have Nobs
observations that you
want to classify with a trained classifier mdl
.
Suppose you have K
classes. You place the observations
into a matrix Xnew
with one observation per row.
The command
[label,score,cost] = predict(mdl,Xnew)
returns, among other outputs, a cost
matrix
of size Nobs
byK
. Each row
of the cost
matrix contains the expected (average)
cost of classifying the observation into each of the K
classes. cost(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.