loss
Find classification error for support vector machine (SVM) classifier
Syntax
Description
returns the classification error (see Classification Loss), a
scalar representing how well the trained support vector machine (SVM) classifier
(L
= loss(SVMModel
,Tbl
,ResponseVarName
)SVMModel
) 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.
specifies options using one or more name-value pair arguments in addition to the
input arguments in previous syntaxes. For example, you can specify the loss
function and the classification weights.L
= loss(___,Name,Value
)
Note
If the predictor data in X
or Tbl
contains
any missing values and LossFun
is not set to
"classifcost"
, "classiferror"
, or
"mincost"
, the loss
function can
return NaN. For more details, see loss can return NaN for predictor data with missing values.
Examples
Determine Test Sample Classification Error of SVM Classifiers
Load the ionosphere
data set.
load ionosphere rng(1); % For reproducibility
Train an SVM classifier. Specify a 15% holdout sample for testing, standardize the data, and specify that 'g'
is the positive class.
CVSVMModel = fitcsvm(X,Y,'Holdout',0.15,'ClassNames',{'b','g'},... 'Standardize',true); CompactSVMModel = CVSVMModel.Trained{1}; % Extract the trained, compact classifier testInds = test(CVSVMModel.Partition); % Extract the test indices XTest = X(testInds,:); YTest = Y(testInds,:);
CVSVMModel
is a ClassificationPartitionedModel
classifier. It contains the property Trained
, which is a 1-by-1 cell array holding a CompactClassificationSVM
classifier that the software trained using the training set.
Determine how well the algorithm generalizes by estimating the test sample classification error.
L = loss(CompactSVMModel,XTest,YTest)
L = 0.0787
The SVM classifier misclassifies approximately 8% of the test sample.
Determine Test Sample Hinge Loss of SVM Classifiers
Load the ionosphere
data set.
load ionosphere rng(1); % For reproducibility
Train an SVM classifier. Specify a 15% holdout sample for testing, standardize the data, and specify that 'g'
is the positive class.
CVSVMModel = fitcsvm(X,Y,'Holdout',0.15,'ClassNames',{'b','g'},... 'Standardize',true); CompactSVMModel = CVSVMModel.Trained{1}; % Extract the trained, compact classifier testInds = test(CVSVMModel.Partition); % Extract the test indices XTest = X(testInds,:); YTest = Y(testInds,:);
CVSVMModel
is a ClassificationPartitionedModel
classifier. It contains the property Trained
, which is a 1-by-1 cell array holding a CompactClassificationSVM
classifier that the software trained using the training set.
Determine how well the algorithm generalizes by estimating the test sample hinge loss.
L = loss(CompactSVMModel,XTest,YTest,'LossFun','hinge')
L = 0.2998
The hinge loss is approximately 0.3. Classifiers with hinge losses close to 0 are preferred.
Input Arguments
SVMModel
— SVM classification model
ClassificationSVM
model object | CompactClassificationSVM
model object
SVM classification model, specified as a ClassificationSVM
model object or CompactClassificationSVM
model object returned by fitcsvm
or compact
,
respectively.
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. Optionally, Tbl
can contain
additional columns for the response variable and observation
weights. Tbl
must contain all of the
predictors used to train SVMModel
.
Multicolumn variables and cell arrays other than cell arrays of
character vectors are not allowed.
If Tbl
contains the response variable used to
train SVMModel
, then you do not need to
specify ResponseVarName
or
Y
.
If you trained SVMModel
using sample data
contained in a table, then the input data for
loss
must also be in a
table.
If you set 'Standardize',true
in fitcsvm
when training SVMModel
, then the software
standardizes the columns of the predictor data using the
corresponding means in SVMModel.Mu
and the
standard deviations in SVMModel.Sigma
.
Data Types: table
ResponseVarName
— Response variable name
name of variable in Tbl
Response variable name, specified as the name of a variable in
Tbl
. If Tbl
contains the
response variable used to train SVMModel
, then you do not
need to specify ResponseVarName
.
You must specify ResponseVarName
as a character vector
or string scalar. For example, if the response variable Y
is stored as Tbl.Y
, then specify
ResponseVarName
as 'Y'
.
Otherwise, the software treats all columns of Tbl
,
including Y
, as predictors when training the
model.
The response variable must be a categorical, character, or string array, logical or numeric vector, or 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 (also known as an instance
or example), and each column corresponds to one variable (also known as a feature). The
variables in the columns of X
must be the same as the variables
that trained the SVMModel
classifier.
The length of Y
and the number of rows in X
must be
equal.
If you set 'Standardize',true
in fitcsvm
to train SVMModel
, then the software
standardizes the columns of X
using the corresponding means in
SVMModel.Mu
and the standard deviations in
SVMModel.Sigma
.
Data Types: double
| single
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, logical or numeric
vector, or cell array of character vectors. Y
must be the same as the data type of
SVMModel.ClassNames
. (The software treats string arrays as cell arrays of character
vectors.)
The length of Y
must equal the number of rows in Tbl
or the number of rows in 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: loss(SVMModel,Tbl,Y,'Weights',W)
weighs the
observations in each row of Tbl
using the corresponding weight
in each row of the variable W
in
Tbl
.
LossFun
— Loss function
'classiferror'
(default) | 'binodeviance'
| 'classifcost'
| 'exponential'
| 'hinge'
| 'logit'
| 'mincost'
| 'quadratic'
| function handle
Loss function, specified as a built-in loss function name or a function handle.
This table lists the available loss functions. Specify one using its 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. You can specify to use posterior probabilities as classification scores for SVM models by setting'FitPosterior',true
when you cross-validate the model usingfitcsvm
.Specify your own function by using function handle notation.
Suppose that
n
is the number of observations inX
, andK
is the number of distinct classes (numel(SVMModel.ClassNames)
) used to create the input model (SVMModel
). 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 ann
-by-K
logical matrix with rows indicating the class to which the corresponding observation belongs. The column order corresponds to the class order inSVMModel.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 ann
-by-K
numeric matrix of classification scores, similar to the output ofpredict
. The column order corresponds to the class order inSVMModel.ClassNames
.W
is ann
-by-1 numeric vector of observation weights. If you passW
, the software normalizes the weights to sum to1
.Cost
is aK
-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.
Example: 'LossFun','binodeviance'
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.
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.
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).
Classification Score
The SVM classification score for classifying observation x is the signed distance from x to the decision boundary ranging from -∞ to +∞. A positive score for a class indicates that x is predicted to be in that class. A negative score indicates otherwise.
The positive class classification score $$f(x)$$ is the trained SVM classification function. $$f(x)$$ is also the numerical predicted response for x, or the score for predicting x into the positive class.
$$f(x)={\displaystyle \sum _{j=1}^{n}{\alpha}_{j}}{y}_{j}G({x}_{j},x)+b,$$
where $$({\alpha}_{1},\mathrm{...},{\alpha}_{n},b)$$ are the estimated SVM parameters, $$G({x}_{j},x)$$ is the dot product in the predictor space between x and the support vectors, and the sum includes the training set observations. The negative class classification score for x, or the score for predicting x into the negative class, is –f(x).
If G(x_{j},x) = x_{j}′x (the linear kernel), then the score function reduces to
$$f\left(x\right)=\left(x/s\right)\prime \beta +b.$$
s is the kernel scale and β is the vector of fitted linear coefficients.
For more details, see Understanding Support Vector Machines.
References
[1] Hastie, T., R. Tibshirani, and J. Friedman. The Elements of Statistical Learning, second edition. Springer, New York, 2008.
Extended Capabilities
Tall Arrays
Calculate with arrays that have more rows than fit in memory.
The
loss
function fully supports tall arrays. For more information,
see Tall Arrays.
GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.
Usage notes and limitations:
The
loss
function does not support one-class classification models.
For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).
Version History
Introduced in R2014aR2022a: loss
returns a different value for
a model with a nondefault cost matrix
If you specify a nondefault cost matrix when you train the input model object, the loss
function returns a different value compared to previous releases.
The loss
function uses the prior
probabilities stored in the Prior
property to normalize the observation
weights of the input data. Also, the function uses the cost matrix stored in the
Cost
property if you specify the LossFun
name-value
argument as "classifcost"
or "mincost"
. The way the
function uses the Prior
and Cost
property values has not
changed. However, the property values stored in the input model object have changed for a model
with a nondefault cost matrix, so the function might return a different value.
For details about the property value change, see Cost property stores the user-specified cost matrix.
If you want the software to handle the cost matrix, prior
probabilities, and observation weights in the same way as in previous releases, adjust the prior
probabilities and observation weights for the nondefault cost matrix, as described in Adjust Prior Probabilities and Observation Weights for Misclassification Cost Matrix. Then, when you train a
classification model, specify the adjusted prior probabilities and observation weights by using
the Prior
and Weights
name-value arguments, respectively,
and use the default cost matrix.
R2022a: 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
or the predictor variables in Tbl
contain 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
ClassificationSVM
| CompactClassificationSVM
| fitcsvm
| predict
Comando MATLAB
Hai fatto clic su un collegamento che corrisponde a questo comando MATLAB:
Esegui il comando inserendolo nella finestra di comando MATLAB. I browser web non supportano i comandi MATLAB.
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)