loss

R2026b

Classification error for XGBoost model

Since R2026a

Syntax

L = loss(mdl,tbl,ResponseVarName)

L = loss(mdl,tbl,Y)

L = loss(mdl,X,Y)

L = loss(___,Name=Value)

Description

L = loss(mdl,tbl,ResponseVarName) returns the Classification Loss L for the compact classification XGBoost model ens using the predictor data in table tbl and the true class labels in tbl.ResponseVarName. The interpretation of L depends on the loss function and weighting scheme. In general, better classifiers yield smaller classification loss values. The default LossFun value is "classiferror" (misclassification rate in decimal).

L = loss(mdl,tbl,Y) uses the predictor data in table tbl and the true class labels in Y.

L = loss(mdl,X,Y) uses the predictor data in matrix X and the true class labels in Y.

L = loss(___,Name=Value) specifies 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 perform computations in parallel.

Examples

Estimate Classification Cost

Import a pretrained XGBoost classification model trained using the ionosphere data set. The pretrained model is provided with this example.

load ionosphere
modelfile = "trainedXGBoostModel.json";
Mdl = importModelFromXGBoost(modelfile)

Mdl = 
  CompactClassificationXGBoost
               ResponseName: 'Y'
                 ClassNames: [0 1]
             ScoreTransform: 'logit'
                 NumTrained: 30
    ImportedModelParameters: [1×1 struct]


  Properties, Methods

The model is imported as a CompactClassificationXGBoost model object.

Convert the response data to a boolean array to match the imported model.

Y = (Y=="g");

Use the loss function to evaluate the classification cost of the model.

loss(Mdl,X,Y,LossFun="classifcost")

ans = single

0.0476

Input Arguments

mdl — Compact classification XGBoost model

CompactClassificationXGBoost model object

Compact classification XGBoost model, specified as a CompactClassificationXGBoost model object created with importModelFromXGBoost.

tbl — Sample data

table

Sample data, specified as a table. Each row of tbl corresponds to one observation, and each column corresponds to one predictor variable. tbl must contain all of the predictors used to train the model. Multicolumn variables and cell arrays other than cell arrays of character vectors are not allowed.

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 mdl.ResponseName is the response variable name, 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 logical or numeric vector.

Data Types: char | string

Y — Class labels

logical vector | numeric vector

Class labels, specified as a logical or numeric vector. Y must have the same data type as tbl or X.

Y must be of the same type as the classification used to train mdl, and its number of elements must equal the number of rows of tbl or X.

Data Types: logical | single | double

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 variable. The number of rows in X must equal the number of rows in Y.

The variables that make up the columns of X must have the same order as the predictor variables used to train mdl.

Data Types: double | single

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.

Example: loss(mdl,X,LossFun="exponential",UseParallel="auto") specifies to use an exponential loss function, and to run in parallel.

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.

The following table describes the values for the built-in 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.

• Bagged and subspace ensembles return posterior probabilities by default (ens.Method is "Bag" or "Subspace").

• To use posterior probabilities as classification scores when the ensemble method is "AdaBoostM1", "AdaBoostM2", "GentleBoost", or "LogitBoost", you must specify the double-logit score transform by entering the following:

  ens.ScoreTransform = "doublelogit";

• For all other ensemble methods, the software does not support posterior probabilities as classification scores.

You can 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), where mdl is the input model). Your function must have the signature

lossvalue = lossfun(C,S,W,Cost)

where:

• 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 in mdl.ClassNames.

  Create 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.

For more details on loss functions, see Classification Loss.

Example: LossFun="binodeviance"

Example: LossFun=@Lossfun

Data Types: char | string | function_handle

Prior — Class weights

mdl.Prior (default) | "empirical" | "uniform" | numeric vector

Since R2026b

Class weights, or prior probabilities, specified as "empirical", "uniform", or a numeric vector.

Value	Description
"empirical"	loss uses the class frequencies in Y or Tbl.ResponseVarName. The function returns an unweighted loss, with respect to class.
"uniform"	loss assigns a weight of 1/K to each class, where K is the number of classes.
Numeric vector	Specify a custom weight for each class. The sum of the weights must equal 1.

By default, loss uses the class prior probabilities specified in the Prior property of the classification model.

Example: Prior="empirical"

Data Types: single | double | char | string

UseParallel — Option to perform computations in parallel

"off" (default) | "auto" | "on"

Option to perform computations in parallel using a parallel pool of workers, specified as one of these values:

• "off" — Run in serial on the MATLAB^® client.

• "auto" — Use a parallel pool if one is open or if MATLAB can automatically create one. If a parallel pool is not available, run in serial on the MATLAB client.

• "on" — Use a parallel pool if one is open or if MATLAB can automatically create one. If a parallel pool is not available, throw an error.

If you do not have a parallel pool open and automatic pool creation is enabled, MATLAB opens a pool using the default cluster profile. To use a parallel pool to run computations in MATLAB, you must have Parallel Computing Toolbox™. For more information, see Run MATLAB Functions with Automatic Parallel Support (Parallel Computing Toolbox).

Before R2026b: To run in parallel, set UseParallel to true.

Example: UseParallel="auto"

Data Types: char | string

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. If you supply weights, loss normalizes them so that the observation weights in each class sum to the prior probability of that class.

If you specify Weights as a numeric vector, the size of Weights must be equal to the number of observations in X or tbl. The software normalizes Weights to sum up to the value of the prior probability in the respective class.

If you specify Weights as the name of a variable in tbl, you must specify it 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.

Example: Weights="W"

Data Types: single | double | char | string

Output Arguments

L — Classification loss

numeric scalar

Classification loss, returned as a numeric scalar. L is a scalar value, the loss for the entire ensemble of trees.

For more information, see Classification Loss.

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_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 class weights (prior probabilities) specified by the Prior name-value argument. Therefore,

  $${\displaystyle \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\log \left\{1+\exp \left[-2m_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 yj.
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"	"crossentropy" is appropriate only for neural network models. The weighted cross-entropy loss is $$L=-{\displaystyle \sum _{j=1}^n\frac{{\tilde{w}}_j\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\exp \left(-m_j\right)}.$$
Hinge loss	"hinge"	$$L={\displaystyle \sum }_{j=1}^n{w}_j\max \left\{0,1-m_j\right\}.$$
Logistic loss	"logit"	$$L={\displaystyle \sum _{j=1}^n{w}_j\log \left(1+\exp \left(-m_j\right)\right)}.$$
Minimal expected misclassification cost	"mincost"	"mincost" is appropriate only if classification scores are posterior probabilities. The software computes the weighted minimal expected classification cost using this procedure for observations j = 1,...,n. Estimate the expected misclassification cost of classifying the observation Xj into the class k: $${\gamma }_{jk}={\left(f{\left(X_j\right)}^{\prime }C\right)}_k.$$ f(Xj) is the column vector of class posterior probabilities for the observation Xj. C is the cost matrix stored in the Cost property of the model. For observation j, predict the class label corresponding to the minimal expected misclassification cost: $${\widehat{y}}_j=\underset{k=1,\mathrm{...},K}{\text{argmin}}{\gamma }_{jk}.$$ Using C, identify the cost incurred (cj) for making the prediction. 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).

Tips

• By default, loss uses the class probabilities specified during training (which are stored in the Prior property of the classification model) to compute the classification loss. To return the class-unweighted loss, specify Prior="empirical". (since R2026b)

Extended Capabilities

Tall Arrays

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

Usage notes and limitations:

• You cannot use the UseParallel name-value argument with tall arrays.

For more information, see Tall Arrays.

Automatic Parallel Support

Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.

The loss function has automatic parallel support. To run computations in parallel, set the UseParallel argument to "on" or "auto".

For more information, see Run MATLAB Functions with Automatic Parallel Support (Parallel Computing Toolbox).

You cannot use the UseParallel name-value argument with tall arrays, GPU arrays, or code generation.

GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Version History

Introduced in R2026a

R2026b: Enhanced control over parallel execution with UseParallel argument

The UseParallel name-value argument now accepts "off", "auto", or "on" values instead of true or false. This change gives you more control over when to use a parallel pool for parallel execution. Specifying the UseParallel name-value argument as true or false is not recommended.

This table shows how to update your code depending on your goal.

Goal	Not Recommended	Recommended
Write code that runs on the MATLAB client.	UseParallel=false	UseParallel="off"
Write portable code that runs on a parallel pool and, if a pool is not available, runs on the MATLAB client.	UseParallel=true	UseParallel="auto"
Write code that runs on a parallel pool and errors if a pool is not available.	N/A	UseParallel="on"

There are no plans to remove support for the true or false values.

R2026b: Compute the class-unweighted loss

Compute the class-unweighted loss by setting the Prior name-value argument to "empirical" in the call to loss. You can also compute a class-weighted loss by setting Prior to the value "uniform" or a numeric vector whose entries sum to 1.