loss
Classification loss for discriminant analysis classifier
Description
returns the classification loss, a scalar
representing how well the trained discriminant analysis classifier L
= loss(Mdl
,Tbl
,ResponseVarName
)Mdl
classifies the predictor data in table Tbl
compared to the true class
labels in Tbl.ResponseVarName
.
The classification loss (L
) is a generalization or resubstitution
quality measure. Its interpretation depends on the loss function and weighting scheme, but,
in general, better classifiers yield smaller classification loss values.
When computing L
, loss
normalizes
the class probabilities in Tbl.ResponseVarName
to the class
probabilities used for training, stored in the Prior
property of
Mdl
.
specifies additional options using one or more name-value arguments in addition to any of
the input argument combinations in the previous syntaxes. For example, you can specify a
classification loss function and the observation weights.L
= loss(___,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
model object trained with fitcdiscr
, or a CompactClassificationDiscriminant
model
object created with compact
.
Tbl
— Sample data
table
Sample data used to train the model, specified as a table. Each row of
Tbl
corresponds to one observation, and each column corresponds
to one predictor variable. Categorical predictor variables are not supported.
Optionally, Tbl
can contain additional columns for the response
variable (which can be categorical) and observation weights. Tbl
must contain all of the predictor variables used to train Mdl
.
Multicolumn variables and cell arrays other than cell arrays of character vectors are
not allowed.
If Tbl
contains the response variable used to train
Mdl
, then you do not need to specify
ResponseVarName
or Y
.
If you trained Mdl
using sample data contained in a table, then
the input data for loss
must also be in a table.
Data Types: table
ResponseVarName
— Response variable name
name of a variable in Tbl
Response variable name, specified as the name of a variable in Tbl
. If
Tbl
contains the response
variable used to train Mdl
,
then you do not need to specify
ResponseVarName
.
If you specify ResponseVarName
, you must specify it as a character vector
or string scalar. For example, if the response
variable Y
is stored as
Tbl.Y
, then specify it as
"Y"
. Otherwise, the software
treats all columns of Tbl
,
including Y
, as
predictors.
The response variable must be a categorical, character, or string array, a logical or numeric vector, or a cell array of character vectors. If the response variable is a character array, then each element must correspond to one row of the array.
Data Types: char
| string
X
— Predictor data
numeric matrix
Predictor data, specified as a numeric matrix. Each row of X
corresponds to one observation, and each column corresponds to one predictor variable.
Categorical predictor variables are not supported. The variables in the columns of
X
must be the same as the variables used to train
Mdl
. The number of rows in X
must equal
the number of rows in Y
.
If you trained Mdl
using sample data contained in a matrix, then
the input data for loss
must also be in a matrix.
Data Types: single
| double
Y
— Class labels
categorical array | character array | string array | logical vector | numeric vector | cell array of character vectors
Class labels, specified as a categorical, character, or string array, a logical or numeric
vector, or a cell array of character vectors. Y
must be
of the same type as the classification used to train Mdl
.
(The software treats string
arrays as cell arrays of character vectors.)
The length of Y
must equal the number of rows in
Tbl
or X
.
Data Types: categorical
| char
| string
| logical
| single
| double
| cell
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 describes the values for the built-in loss functions. Specify one using the corresponding character vector or string scalar.
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 classifiers return posterior
probabilities as classification scores by default (see predict
).
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 the signature
lossvalue = lossfun
(C,S,W,Cost)
The output argument
lossvalue
is a scalar.You specify the function name (
lossfun
).C
is an n-by-K logical matrix with rows indicating the class to which the corresponding observation belongs. The column order corresponds to the class order inMdl.ClassNames
.Create
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.
Example: LossFun="binodeviance"
Example: LossFun=@
Lossfun
Data Types: char
| string
| function_handle
Weights
— Observation weights
ones(size(X,1),1)
(default) | numeric vector | name of variable in Tbl
Observation weights, specified as a numeric vector or the name of a variable in
Tbl
. The software weighs the observations in each row of
X
or Tbl
with the corresponding weight in
Weights
.
If you specify Weights
as a numeric vector, then the size of
Weights
must be equal to the number of rows in
X
or Tbl
.
If you specify Weights
as the name of a variable in
Tbl
, you must do so as a character vector or string scalar. For
example, if the weights are stored as Tbl.W
, then specify
Weights
as "W"
. Otherwise, the software treats
all columns of Tbl
, including Tbl.W
, as
predictors.
If you do not specify your own loss function, then the software normalizes
Weights
to sum up to the value of the prior probability in the
respective class.
Example: Weights="W"
Data Types: single
| double
| char
| string
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
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)