loss
Classification error for discriminant analysis classifier
Description
returns the classification loss, which is 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
.
specifies additional options using one or more name-value arguments.L
= loss(mdl
,X
,Y
,Name=Value
)
Note
If the predictor data X
contains any missing values and
LossFun
is not set to "mincost"
or
"classiferror"
, the loss
function might
return NaN
. For more information, see loss can return NaN for predictor data with missing values.
Examples
Estimate Classification Error
Load Fisher's iris data set.
load fisheriris
Train a discriminant analysis model using all observations in the data.
Mdl = fitcdiscr(meas,species);
Estimate the classification error of the model using the training observations.
L = loss(Mdl,meas,species)
L = 0.0200
Alternatively, if Mdl
is not compact, then you can estimate the training-sample classification error by passing Mdl
to resubLoss
.
Input Arguments
mdl
— Trained discriminant analysis classifier
ClassificationDiscriminant
model object | CompactClassificationDiscriminant
model object
Trained discriminant analysis classifier, specified as a ClassificationDiscriminant
or CompactClassificationDiscriminant
model object trained with fitcdiscr
.
X
— Predictor data
matrix
Predictor data to classify, specified as a matrix. Each row of the matrix represents an
observation, and each column represents a predictor. The number of columns in
X
must equal the number of predictors in
mdl
.
Y
— Class labels
same data type as in mdl
Class labels, specified with the same data type as data in mdl
.
The number of elements of Y
must equal the number of rows of
X
.
Name-Value Arguments
Specify optional pairs of arguments as
Name1=Value1,...,NameN=ValueN
, where Name
is
the argument name and Value
is the corresponding value.
Name-value arguments must appear after other arguments, but the order of the
pairs does not matter.
Before R2021a, use commas to separate each name and value, and enclose
Name
in quotes.
Example: L =
loss(mdl,meas,species,LossFun="binodeviance")
LossFun
— Loss function
"mincost"
(default) | "binodeviance"
| "classifcost"
| "classiferror"
| "exponential"
| "hinge"
| "logit"
| "quadratic"
| function handle
Loss function, specified as a built-in loss function name or a function handle.
The following table lists the available loss functions.
Value Description "binodeviance"
Binomial deviance "classifcost"
Observed misclassification cost "classiferror"
Misclassified rate in decimal "exponential"
Exponential loss "hinge"
Hinge loss "logit"
Logistic loss "mincost"
Minimal expected misclassification cost (for classification scores that are posterior probabilities) "quadratic"
Quadratic loss "mincost"
is appropriate for classification scores that are posterior probabilities. Discriminant analysis models return posterior probabilities as classification scores by default (seepredict
).Specify your own function using function handle notation.
Suppose that n is the number of observations in
X
and K is the number of distinct classes (numel(mdl.ClassNames)
). Your function must have this signaturewhere:lossvalue =
lossfun
(C,S,W,Cost)The output argument
lossvalue
is a scalar.You choose the function name (
lossfun
).C
is an n-by-K logical matrix with rows indicating which class the corresponding observation belongs. The column order corresponds to the class order inmdl.ClassNames
.Construct
C
by settingC(p,q) = 1
if observationp
is in classq
, for each row. Set all other elements of rowp
to0
.S
is an n-by-K numeric matrix of classification scores. The column order corresponds to the class order inmdl.ClassNames
.S
is a matrix of classification scores, similar to the output ofpredict
.W
is an n-by-1 numeric vector of observation weights. If you passW
, the software normalizes the weights to sum to1
.Cost
is a K-by-K numeric matrix of misclassification costs. For example,Cost = ones(K) - eye(K)
specifies a cost of0
for correct classification, and1
for misclassification.
Specify your function using
LossFun=@
.lossfun
For more details on loss functions, see Classification Loss.
Data Types: char
| string
| function_handle
Weights
— Observation weights
ones(size(X,1),1)
(default) | numeric vector of length size(X,1)
Observation weights, specified as a numeric vector of length
size(X,1)
, which is the number of rows in X
.
Observation weights are nonnegative.
loss
normalizes the weights so that observation
weights in each class sum to the prior probability of that class. When you supply
weights
, loss
computes weighted
classification loss.
Output Arguments
L
— Classification loss
numeric scalar
Classification loss, returned as a numeric scalar. The interpretation of
L
depends on the values in Weights
and
LossFun
.
More About
Classification Loss
Classification loss functions measure the predictive inaccuracy of classification models. When you compare the same type of loss among many models, a lower loss indicates a better predictive model.
Consider the following scenario.
L is the weighted average classification loss.
n is the sample size.
For binary classification:
y_{j} is the observed class label. The software codes it as –1 or 1, indicating the negative or positive class (or the first or second class in the
ClassNames
property), respectively.f(X_{j}) is the positive-class classification score for observation (row) j of the predictor data X.
m_{j} = y_{j}f(X_{j}) is the classification score for classifying observation j into the class corresponding to y_{j}. Positive values of m_{j} indicate correct classification and do not contribute much to the average loss. Negative values of m_{j} indicate incorrect classification and contribute significantly to the average loss.
For algorithms that support multiclass classification (that is, K ≥ 3):
y_{j}^{*} is a vector of K – 1 zeros, with 1 in the position corresponding to the true, observed class y_{j}. For example, if the true class of the second observation is the third class and K = 4, then y_{2}^{*} = [
0 0 1 0
]′. The order of the classes corresponds to the order in theClassNames
property of the input model.f(X_{j}) is the length K vector of class scores for observation j of the predictor data X. The order of the scores corresponds to the order of the classes in the
ClassNames
property of the input model.m_{j} = y_{j}^{*}′f(X_{j}). Therefore, m_{j} is the scalar classification score that the model predicts for the true, observed class.
The weight for observation j is w_{j}. The software normalizes the observation weights so that they sum to the corresponding prior class probability stored in the
Prior
property. Therefore,$$\sum _{j=1}^{n}{w}_{j}}=1.$$
Given this scenario, the following table describes the supported loss functions that you can specify by using the LossFun
name-value argument.
Loss Function | Value of LossFun | Equation |
---|---|---|
Binomial deviance | "binodeviance" | $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}\mathrm{log}\left\{1+\mathrm{exp}\left[-2{m}_{j}\right]\right\}}.$$ |
Observed misclassification cost | "classifcost" | $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}}{c}_{{y}_{j}{\widehat{y}}_{j}},$$ where $${\widehat{y}}_{j}$$ is the class label corresponding to the class with the maximal score, and $${c}_{{y}_{j}{\widehat{y}}_{j}}$$ is the user-specified cost of classifying an observation into class $${\widehat{y}}_{j}$$ when its true class is y_{j}. |
Misclassified rate in decimal | "classiferror" | $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}}I\left\{{\widehat{y}}_{j}\ne {y}_{j}\right\},$$ where I{·} is the indicator function. |
Cross-entropy loss | "crossentropy" |
The weighted cross-entropy loss is $$L=-{\displaystyle \sum _{j=1}^{n}\frac{{\tilde{w}}_{j}\mathrm{log}({m}_{j})}{Kn}},$$ where the weights $${\tilde{w}}_{j}$$ are normalized to sum to n instead of 1. |
Exponential loss | "exponential" | $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}\mathrm{exp}\left(-{m}_{j}\right)}.$$ |
Hinge loss | "hinge" | $$L={\displaystyle \sum}_{j=1}^{n}{w}_{j}\mathrm{max}\left\{0,1-{m}_{j}\right\}.$$ |
Logit loss | "logit" | $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}\mathrm{log}\left(1+\mathrm{exp}\left(-{m}_{j}\right)\right)}.$$ |
Minimal expected misclassification cost | "mincost" |
The software computes the weighted minimal expected classification cost using this procedure for observations j = 1,...,n.
The weighted average of the minimal expected misclassification cost loss is $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}{c}_{j}}.$$ |
Quadratic loss | "quadratic" | $$L={\displaystyle \sum _{j=1}^{n}{w}_{j}{\left(1-{m}_{j}\right)}^{2}}.$$ |
If you use the default cost matrix (whose element value is 0 for correct classification
and 1 for incorrect classification), then the loss values for
"classifcost"
, "classiferror"
, and
"mincost"
are identical. For a model with a nondefault cost matrix,
the "classifcost"
loss is equivalent to the "mincost"
loss most of the time. These losses can be different if prediction into the class with
maximal posterior probability is different from prediction into the class with minimal
expected cost. Note that "mincost"
is appropriate only if classification
scores are posterior probabilities.
This figure compares the loss functions (except "classifcost"
,
"crossentropy"
, and "mincost"
) over the score
m for one observation. Some functions are normalized to pass through
the point (0,1).
Posterior Probability
The posterior probability that a point x belongs to class k is the product of the prior probability and the multivariate normal density. The density function of the multivariate normal with 1-by-d mean μ_{k} and d-by-d covariance Σ_{k} at a 1-by-d point x is
$$P\left(x|k\right)=\frac{1}{{\left({\left(2\pi \right)}^{d}\left|{\Sigma}_{k}\right|\right)}^{1/2}}\mathrm{exp}\left(-\frac{1}{2}\left(x-{\mu}_{k}\right){\Sigma}_{k}^{-1}{\left(x-{\mu}_{k}\right)}^{T}\right),$$
where $$\left|{\Sigma}_{k}\right|$$ is the determinant of Σ_{k}, and $${\Sigma}_{k}^{-1}$$ is the inverse matrix.
Let P(k) represent the prior probability of class k. Then the posterior probability that an observation x is of class k is
$$\widehat{P}\left(k|x\right)=\frac{P\left(x|k\right)P\left(k\right)}{P\left(x\right)},$$
where P(x) is a normalization constant, the sum over k of P(x|k)P(k).
Prior Probability
The prior probability is one of three choices:
'uniform'
— The prior probability of classk
is one over the total number of classes.'empirical'
— The prior probability of classk
is the number of training samples of classk
divided by the total number of training samples.Custom — The prior probability of class
k
is thek
th element of theprior
vector. Seefitcdiscr
.
After creating a classification model (Mdl
)
you can set the prior using dot notation:
Mdl.Prior = v;
where v
is a vector of positive elements
representing the frequency with which each element occurs. You do
not need to retrain the classifier when you set a new prior.
Cost
The matrix of expected costs per observation is defined in Cost.
Extended Capabilities
Tall Arrays
Calculate with arrays that have more rows than fit in memory.
This function fully supports tall arrays. You can use models trained on either in-memory or tall data with this function.
For more information, see Tall Arrays.
Version History
Introduced in R2011bR2022a: loss
can return NaN for predictor data with missing values
The loss
function no longer omits an observation with a
NaN score when computing the weighted average classification loss. Therefore,
loss
can now return NaN when the predictor data
X
contains any missing values and the name-value argument
LossFun
is not specified as "classifcost"
,
"classiferror"
, or "mincost"
. In most cases, if
the test set observations do not contain missing predictors, the
loss
function does not return NaN.
This change improves the automatic selection of a classification model when you use
fitcauto
.
Before this change, the software might select a model (expected to best classify new data)
with few non-NaN predictors.
If loss
in your code returns NaN, you can update your code
to avoid this result by doing one of the following:
Remove or replace the missing values by using
rmmissing
orfillmissing
, respectively.Specify the name-value argument
LossFun
as"classifcost"
,"classiferror"
, or"mincost"
.
The following table shows the classification models for which the
loss
object function might return NaN. For more details, see
the Compatibility Considerations for each loss
function.
Model Type | Full or Compact Model Object | loss Object
Function |
---|---|---|
Discriminant analysis classification model | ClassificationDiscriminant , CompactClassificationDiscriminant | loss |
Ensemble of learners for classification | ClassificationEnsemble , CompactClassificationEnsemble | loss |
Gaussian kernel classification model | ClassificationKernel | loss |
k-nearest neighbor classification model | ClassificationKNN | loss |
Linear classification model | ClassificationLinear | loss |
Neural network classification model | ClassificationNeuralNetwork , CompactClassificationNeuralNetwork | loss |
Support vector machine (SVM) classification model | loss |
See Also
Classes
Functions
Open Example
You have a modified version of this example. Do you want to open this example with your edits?
MATLAB Command
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
You can also select a web site from the following list:
How to Get Best Site Performance
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)