loss

Classification loss for linear classification models

Syntax

L = loss(Mdl,X,Y)

L = loss(___,Name,Value)

Description

L = loss(Mdl,X,Y) returns the classification losses for the binary, linear classification model Mdl using predictor data in X and corresponding class labels in Y. L contains classification error rates for each regularization strength in Mdl.

example

L = loss(___,Name,Value) uses any of the previous syntaxes and additional options specified by one or more Name,Value pair arguments. For example, you can specify that columns in the predictor data correspond to observations or specify the classification loss function.

Input Arguments

expand all

`Mdl` — Binary, linear classification model
`ClassificationLinear` model object

Binary, linear classification model, specified as a ClassificationLinear model object. You can create a ClassificationLinear model object using fitclinear.

`X` — Predictor data
full matrix | sparse matrix

Predictor data, specified as an n-by-p full or sparse matrix. This orientation of X indicates that rows correspond to individual observations, and columns correspond to individual predictor variables.

Note

If you orient your predictor matrix so that observations correspond to columns and specify 'ObservationsIn','columns', then you might experience a significant reduction in computation time.

The length of Y and the number of observations in X must be equal.

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, logical or numeric vector, or cell array of character vectors.

The data type of Y must be the same as the data type of Mdl.ClassNames. (The software treats string arrays as cell arrays of character vectors.)
The distinct classes in Y must be a subset of Mdl.ClassNames.
If Y is a character array, then each element must correspond to one row of the array.
The length of Y and the number of observations in X must be equal.

Name-Value Pair Arguments

Specify optional comma-separated pairs of Name,Value arguments. Name is the argument name and Value is the corresponding value. Name must appear inside quotes. You can specify several name and value pair arguments in any order as Name1,Value1,...,NameN,ValueN.

`'LossFun'` — Loss function
`'classiferror'` (default) | `'binodeviance'` | `'exponential'` | `'hinge'` | `'logit'` | `'mincost'` | `'quadratic'` | function handle

Loss function, specified as the comma-separated pair consisting of 'LossFun' and a built-in, loss-function name or function handle.

The following table lists the available loss functions. Specify one using its corresponding character vector or string scalar.

Value	Description
`'binodeviance'`	Binomial deviance
`'classiferror'`	Classification error
`'exponential'`	Exponential
`'hinge'`	Hinge
`'logit'`	Logistic
`'mincost'`	Minimal expected misclassification cost (for classification scores that are posterior probabilities)
`'quadratic'`	Quadratic

'mincost' is appropriate for classification scores that are posterior probabilities. For linear classification models, logistic regression learners return posterior probabilities as classification scores by default, but SVM learners do not (see predict).

Specify your own function by using function handle notation.
Let n be the number of observations in X and K be the number of distinct classes (numel(Mdl.ClassNames), where Mdl is the input model). Your function must have this signature:
```
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 the class to which the corresponding observation belongs. The column order corresponds to the class order in Mdl.ClassNames.
  Construct C by setting C(p,q) = 1, if observation p is in class q, for each row. Set all other elements of row p to 0.
- S is an n-by-K numeric matrix of classification scores. The column order corresponds to the class order in Mdl.ClassNames. S is a matrix of classification scores, similar to the output of predict.
- W is an n-by-1 numeric vector of observation weights. If you pass W, the software normalizes the weights to sum to 1.
- Cost is a K-by-K numeric matrix of misclassification costs. For example, Cost = ones(K) – eye(K) specifies a cost of 0 for correct classification, and 1 for misclassification.

Example: 'LossFun',@lossfun

Data Types: char | string | function_handle

`'ObservationsIn'` — Predictor data observation dimension
`'rows'` (default) | `'columns'`

Predictor data observation dimension, specified as the comma-separated pair consisting of 'ObservationsIn' and 'columns' or 'rows'.

Note

If you orient your predictor matrix so that observations correspond to columns and specify 'ObservationsIn','columns', then you might experience a significant reduction in optimization-execution time.

`'Weights'` — Observation weights
numeric vector of positive values

Observation weights, specified as the comma-separated pair consisting of 'Weights' and a numeric vector of positive values. If you supply weights, loss computes the weighted classification loss.

Let n be the number of observations in X.

numel(Weights) must be n.
By default, Weights is ones(n,1).

loss normalizes Weights to sum up to the value of the prior probability in the respective class.

Data Types: double | single

Output Arguments

expand all

`L` — Classification losses
numeric scalar | numeric row vector

Classification losses, returned as a numeric scalar or row vector. The interpretation of L depends on Weights and LossFun.

L is the same size as Mdl.Lambda. L(j) is the classification loss of the linear classification model trained using the regularization strength Mdl.Lambda(j).

Examples

expand all

Estimate Test-Sample Classification Loss

Open Live Script

Load the NLP data set.

load nlpdata

X is a sparse matrix of predictor data, and Y is a categorical vector of class labels. There are more than two classes in the data.

The models should identify whether the word counts in a web page are from the Statistics and Machine Learning Toolbox™ documentation. So, identify the labels that correspond to the Statistics and Machine Learning Toolbox™ documentation web pages.

Ystats = Y == 'stats';

Train a binary, linear classification model that can identify whether the word counts in a documentation web page are from the Statistics and Machine Learning Toolbox™ documentation. Specify to hold out 30% of the observations. Optimize the objective function using SpaRSA.

rng(1); % For reproducibility 
CVMdl = fitclinear(X,Ystats,'Solver','sparsa','Holdout',0.30);
CMdl = CVMdl.Trained{1};

CVMdl is a ClassificationPartitionedLinear model. It contains the property Trained, which is a 1-by-1 cell array holding a ClassificationLinear model that the software trained using the training set.

Extract the training and test data from the partition definition.

trainIdx = training(CVMdl.Partition);
testIdx = test(CVMdl.Partition);

Estimate the training- and test-sample classification error.

ceTrain = loss(CMdl,X(trainIdx,:),Ystats(trainIdx))

ceTrain = 1.3572e-04

ceTest = loss(CMdl,X(testIdx,:),Ystats(testIdx))

ceTest = 5.2804e-04

Because there is one regularization strength in CMdl, ceTrain and ceTest are numeric scalars.

Specify Custom Classification Loss

Open Live Script

Load the NLP data set. Preprocess the data as in Estimate Test-Sample Classification Loss, and transpose the predictor data.

load nlpdata
Ystats = Y == 'stats';
X = X';

Train a binary, linear classification model. Specify to hold out 30% of the observations. Optimize the objective function using SpaRSA. Specify that the predictor observations correspond to columns.

rng(1); % For reproducibility 
CVMdl = fitclinear(X,Ystats,'Solver','sparsa','Holdout',0.30,...
    'ObservationsIn','columns');
CMdl = CVMdl.Trained{1};

Extract the training and test data from the partition definition.

trainIdx = training(CVMdl.Partition);
testIdx = test(CVMdl.Partition);

Create an anonymous function that measures linear loss, that is,

$L = \frac{\sum_{j} - w_{j} y_{j} f_{j}}{\sum_{j} w_{j}} .$

$w_{j}$ is the weight for observation j, $y_{j}$ is response j (-1 for the negative class, and 1 otherwise), and $f_{j}$ is the raw classification score of observation j. Custom loss functions must be written in a particular form. For rules on writing a custom loss function, see the LossFun name-value pair argument.

linearloss = @(C,S,W,Cost)sum(-W.*sum(S.*C,2))/sum(W);

Estimate the training- and test-sample classification loss using the linear loss function.

ceTrain = loss(CMdl,X(:,trainIdx),Ystats(trainIdx),'LossFun',linearloss,...
    'ObservationsIn','columns')

ceTrain = -7.8330

ceTest = loss(CMdl,X(:,testIdx),Ystats(testIdx),'LossFun',linearloss,...
    'ObservationsIn','columns')

ceTest = -7.7383

Find Good Lasso Penalty Using Classification Loss

Open Live Script

To determine a good lasso-penalty strength for a linear classification model that uses a logistic regression learner, compare test-sample classification error rates.

Load the NLP data set. Preprocess the data as in Specify Custom Classification Loss.

load nlpdata
Ystats = Y == 'stats';
X = X'; 

rng(10); % For reproducibility
Partition = cvpartition(Ystats,'Holdout',0.30);
testIdx = test(Partition);
XTest = X(:,testIdx);
YTest = Ystats(testIdx);

Create a set of 11 logarithmically-spaced regularization strengths from $1 0^{- 6}$ through $1 0^{- 0.5}$ .

Lambda = logspace(-6,-0.5,11);

Train binary, linear classification models that use each of the regularization strengths. Optimize the objective function using SpaRSA. Lower the tolerance on the gradient of the objective function to 1e-8.

CVMdl = fitclinear(X,Ystats,'ObservationsIn','columns',...
    'CVPartition',Partition,'Learner','logistic','Solver','sparsa',...
    'Regularization','lasso','Lambda',Lambda,'GradientTolerance',1e-8)

CVMdl = 
  classreg.learning.partition.ClassificationPartitionedLinear
    CrossValidatedModel: 'Linear'
           ResponseName: 'Y'
        NumObservations: 31572
                  KFold: 1
              Partition: [1x1 cvpartition]
             ClassNames: [0 1]
         ScoreTransform: 'none'


  Properties, Methods

Extract the trained linear classification model.

Mdl = CVMdl.Trained{1}

Mdl = 
  ClassificationLinear
      ResponseName: 'Y'
        ClassNames: [0 1]
    ScoreTransform: 'logit'
              Beta: [34023x11 double]
              Bias: [1x11 double]
            Lambda: [1x11 double]
           Learner: 'logistic'


  Properties, Methods

Mdl is a ClassificationLinear model object. Because Lambda is a sequence of regularization strengths, you can think of Mdl as 11 models, one for each regularization strength in Lambda.

Estimate the test-sample classification error.

ce = loss(Mdl,X(:,testIdx),Ystats(testIdx),'ObservationsIn','columns');

Because there are 11 regularization strengths, ce is a 1-by-11 vector of classification error rates.

Higher values of Lambda lead to predictor variable sparsity, which is a good quality of a classifier. For each regularization strength, train a linear classification model using the entire data set and the same options as when you cross-validated the models. Determine the number of nonzero coefficients per model.

Mdl = fitclinear(X,Ystats,'ObservationsIn','columns',...
    'Learner','logistic','Solver','sparsa','Regularization','lasso',...
    'Lambda',Lambda,'GradientTolerance',1e-8);
numNZCoeff = sum(Mdl.Beta~=0);

In the same figure, plot the test-sample error rates and frequency of nonzero coefficients for each regularization strength. Plot all variables on the log scale.

figure;
[h,hL1,hL2] = plotyy(log10(Lambda),log10(ce),...
    log10(Lambda),log10(numNZCoeff + 1)); 
hL1.Marker = 'o';
hL2.Marker = 'o';
ylabel(h(1),'log_{10} classification error')
ylabel(h(2),'log_{10} nonzero-coefficient frequency')
xlabel('log_{10} Lambda')
title('Test-Sample Statistics')
hold off

Choose the index of the regularization strength that balances predictor variable sparsity and low classification error. In this case, a value between $1 0^{- 4}$ to $1 0^{- 1}$ should suffice.

idxFinal = 7;

Select the model from Mdl with the chosen regularization strength.

MdlFinal = selectModels(Mdl,idxFinal);

MdlFinal is a ClassificationLinear model containing one regularization strength. To estimate labels for new observations, pass MdlFinal and the new data to predict.

More About

expand all

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, respectively.
- f(X_j) is the raw classification score for observation (row) j of the predictor data X.
- m_j = y_jf(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^*₂ = [0 0 1 0]′. The order of the classes corresponds to the order in the ClassNames 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. The software also normalizes the prior probabilities so they sum to 1. 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 pair argument.

Loss Function	Value of `LossFun`	Equation
Binomial deviance	`'binodeviance'`	$L = \sum_{j = 1}^{n} w_{j} \log {1 + \exp [- 2 m_{j}]} .$
Exponential loss	`'exponential'`	$L = \sum_{j = 1}^{n} w_{j} \exp (- m_{j}) .$
Classification error	`'classiferror'`	$L = \sum_{j = 1}^{n} w_{j} I {{\hat{y}}_{j} \neq y_{j}} .$ It is the weighted fraction of misclassified observations where ${\hat{y}}_{j}$ is the class label corresponding to the class with the maximal posterior probability. I{x} is the indicator function.
Hinge loss	`'hinge'`	$L = \sum_{j = 1}^{n} w_{j} \max {0, 1 - m_{j}} .$
Logit loss	`'logit'`	$L = \sum_{j = 1}^{n} w_{j} \log (1 + \exp (- m_{j})) .$
Minimal cost	`'mincost'`	Minimal cost. The software computes the weighted minimal cost using this procedure for observations j = 1,...,n. Estimate the 1-by-K vector of expected classification costs for observation j: $γ_{j} = f {(X_{j})}^{'} C .$ f(X_j) is the column vector of class posterior probabilities for binary and multiclass classification. C is the cost matrix that the input model stores in the `Cost` property. For observation j, predict the class label corresponding to the minimum expected classification cost: ${\hat{y}}_{j} = \min_{j = 1, ..., K} (γ_{j}) .$ Using C, identify the cost incurred (c_j) for making the prediction. The weighted, average, minimum cost loss is $L = \sum_{j = 1}^{n} w_{j} c_{j} .$
Quadratic loss	`'quadratic'`	$L = \sum_{j = 1}^{n} w_{j} {(1 - m_{j})}^{2} .$

This figure compares the loss functions (except 'mincost') for one observation over m. Some functions are normalized to pass through [0,1].

Algorithms

By default, observation weights are prior class probabilities. If you supply weights using Weights, then the software normalizes them to sum to the prior probabilities in the respective classes. The software uses the renormalized weights to estimate the weighted classification loss.

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 (MATLAB).

Documentation

loss

Syntax

Description

Input Arguments

`Mdl` — Binary, linear classification model
`ClassificationLinear` model object

`X` — Predictor data
full matrix | sparse matrix

Note

`Y` — Class labels
categorical array | character array | string array | logical vector | numeric vector | cell array of character vectors

Name-Value Pair Arguments

`'LossFun'` — Loss function
`'classiferror'` (default) | `'binodeviance'` | `'exponential'` | `'hinge'` | `'logit'` | `'mincost'` | `'quadratic'` | function handle

`'ObservationsIn'` — Predictor data observation dimension
`'rows'` (default) | `'columns'`

Note

`'Weights'` — Observation weights
numeric vector of positive values

Output Arguments

`L` — Classification losses
numeric scalar | numeric row vector

Examples

Estimate Test-Sample Classification Loss

Specify Custom Classification Loss

Find Good Lasso Penalty Using Classification Loss

More About

Classification Loss

Algorithms

Extended Capabilities

Tall Arrays
Calculate with arrays that have more rows than fit in memory.

See Also

Introduced in R2016a

Statistics and Machine Learning Toolbox Documentation

Support

Documentation

loss

Syntax

Description

Input Arguments

Mdl — Binary, linear classification model ClassificationLinear model object

X — Predictor data full matrix | sparse matrix

Note

Y — Class labels categorical array | character array | string array | logical vector | numeric vector | cell array of character vectors

Name-Value Pair Arguments

'LossFun' — Loss function 'classiferror' (default) | 'binodeviance' | 'exponential' | 'hinge' | 'logit' | 'mincost' | 'quadratic' | function handle

'ObservationsIn' — Predictor data observation dimension 'rows' (default) | 'columns'

Note

'Weights' — Observation weights numeric vector of positive values

Output Arguments

L — Classification losses numeric scalar | numeric row vector

Examples

Estimate Test-Sample Classification Loss

Specify Custom Classification Loss

Find Good Lasso Penalty Using Classification Loss

More About

Classification Loss

Algorithms

Extended Capabilities

Tall Arrays Calculate with arrays that have more rows than fit in memory.

See Also

Introduced in R2016a

Statistics and Machine Learning Toolbox Documentation

Support

`Mdl` — Binary, linear classification model
`ClassificationLinear` model object

`X` — Predictor data
full matrix | sparse matrix

`Y` — Class labels
categorical array | character array | string array | logical vector | numeric vector | cell array of character vectors

`'LossFun'` — Loss function
`'classiferror'` (default) | `'binodeviance'` | `'exponential'` | `'hinge'` | `'logit'` | `'mincost'` | `'quadratic'` | function handle

`'ObservationsIn'` — Predictor data observation dimension
`'rows'` (default) | `'columns'`

`'Weights'` — Observation weights
numeric vector of positive values

`L` — Classification losses
numeric scalar | numeric row vector

Tall Arrays
Calculate with arrays that have more rows than fit in memory.