**Class: **ClassificationLinear

Classification edge for linear classification models

uses
any of the previous syntaxes and additional options specified by one
or more `e`

= edge(___,`Name,Value`

)`Name,Value`

pair arguments. For example,
you can specify that columns in the predictor data correspond to observations
or supply observation weights.

`Mdl`

— Binary, linear classification model`ClassificationLinear`

model objectBinary, linear classification model, specified as a `ClassificationLinear`

model object.
You can create a `ClassificationLinear`

model object
using `fitclinear`

.

`X`

— Predictor datafull 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.

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

**Data Types: **`categorical`

| `char`

| `string`

| `logical`

| `single`

| `double`

| `cell`

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`

.

`'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'`

.

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 weightsnumeric 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, `edge`

computes the weighted classification edge.

Let * n* be the number of observations
in

`X`

.`numel(Weights)`

must be.`n`

By default,

`Weights`

is`ones(`

.,1)`n`

`edge`

normalizes `Weights`

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

**Data Types: **`double`

| `single`

`e`

— Classification edgesnumeric scalar | numeric row vector

Classification edges, returned as a numeric scalar or row vector.

`e`

is the same size as `Mdl.Lambda`

. `e(`

is
the classification edge of the linear classification model trained
using the regularization strength * j*)

`Mdl.Lambda(``j`

)

.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 holdout 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 edges.

eTrain = edge(CMdl,X(trainIdx,:),Ystats(trainIdx))

eTrain = 15.6660

eTest = edge(CMdl,X(testIdx,:),Ystats(testIdx))

eTest = 15.4767

One way to perform feature selection is to compare test-sample edges from multiple models. Based solely on this criterion, the classifier with the highest edge is the best classifier.

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. For quicker execution time, orient the predictor data so that individual observations correspond to columns.

Ystats = Y == 'stats'; X = X'; rng(1); % For reproducibility

Create a data partition which holds out 30% of the observations for testing.

Partition = cvpartition(Ystats,'Holdout',0.30); testIdx = test(Partition); % Test-set indices XTest = X(:,testIdx); YTest = Ystats(testIdx);

`Partition`

is a `cvpartition`

object that defines the data set partition.

Randomly choose half of the predictor variables.

```
p = size(X,1); % Number of predictors
idxPart = randsample(p,ceil(0.5*p));
```

Train two binary, linear classification models: one that uses the all of the predictors and one that uses half of the predictors. Optimize the objective function using SpaRSA, and indicate that observations correspond to columns.

CVMdl = fitclinear(X,Ystats,'CVPartition',Partition,'Solver','sparsa',... 'ObservationsIn','columns'); PCVMdl = fitclinear(X(idxPart,:),Ystats,'CVPartition',Partition,'Solver','sparsa',... 'ObservationsIn','columns');

`CVMdl`

and `PCVMdl`

are `ClassificationPartitionedLinear`

models.

Extract the trained `ClassificationLinear`

models from the cross-validated models.

CMdl = CVMdl.Trained{1}; PCMdl = PCVMdl.Trained{1};

Estimate the test sample edge for each classifier.

fullEdge = edge(CMdl,XTest,YTest,'ObservationsIn','columns')

fullEdge = 15.4767

partEdge = edge(PCMdl,XTest(idxPart,:),YTest,'ObservationsIn','columns')

partEdge = 13.4458

Based on the test-sample edges, the classifier that uses all of the predictors is the better model.

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

Load the NLP data set. Preprocess the data as in Feature Selection Using Test-Sample Edges.

load nlpdata Ystats = Y == 'stats'; X = X'; 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}^{-8}$$ through $$1{0}^{1}$$.

Lambda = logspace(-8,1,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`

.

rng(10); % For reproducibility 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 edges.

e = edge(Mdl,X(:,testIdx),Ystats(testIdx),'ObservationsIn','columns')

`e = `*1×11*
0.9986 0.9986 0.9986 0.9986 0.9986 0.9932 0.9764 0.9181 0.8332 0.8128 0.8128

Because there are 11 regularization strengths, `e`

is a 1-by-11 vector of edges.

Plot the test-sample edges for each regularization strength. Identify the regularization strength that maximizes the edges over the grid.

figure; plot(log10(Lambda),log10(e),'-o') [~, maxEIdx] = max(e); maxLambda = Lambda(maxEIdx); hold on plot(log10(maxLambda),log10(e(maxEIdx)),'ro'); ylabel('log_{10} test-sample edge') xlabel('log_{10} Lambda') legend('Edge','Max edge') hold off

Several values of `Lambda`

yield similarly high edges. Higher values of lambda lead to predictor variable sparsity, which is a good quality of a classifier.

Choose the regularization strength that occurs just before the edge starts decreasing.

LambdaFinal = Lambda(5);

Train a linear classification model using the entire data set and specify the regularization strength yielding the maximal edge.

MdlFinal = fitclinear(X,Ystats,'ObservationsIn','columns',... 'Learner','logistic','Solver','sparsa','Regularization','lasso',... 'Lambda',LambdaFinal);

To estimate labels for new observations, pass `MdlFinal`

and the new data to `predict`

.

The *classification edge* is
the weighted mean of the *classification margins*.

One way to choose among multiple classifiers, for example to perform feature selection, is to choose the classifier that yields the greatest edge.

The *classification margin* for binary classification
is, for each observation, the difference between the classification score for the true class
and the classification score for the false class.

The software defines the classification margin for binary classification as

$$m=2yf\left(x\right).$$

*x* is an observation. If the true label of
*x* is the positive class, then *y* is 1, and –1
otherwise. *f*(*x*) is the positive-class classification
score for the observation *x*. The classification margin is commonly
defined as *m* =
*y**f*(*x*).

If the margins are on the same scale, then they serve as a classification confidence measure. Among multiple classifiers, those that yield greater margins are better.

For linear classification models, the raw *classification
score* for classifying the observation *x*, a row vector,
into the positive class is defined by

$${f}_{j}(x)=x{\beta}_{j}+{b}_{j}.$$

For the model with regularization strength *j*, $${\beta}_{j}$$ is the estimated column vector of coefficients (the model property
`Beta(:,j)`

) and $${b}_{j}$$ is the estimated, scalar bias (the model property
`Bias(j)`

).

The raw classification score for classifying *x* into
the negative class is –*f*(*x*).
The software classifies observations into the class that yields the
positive score.

If the linear classification model consists of logistic regression learners, then the
software applies the `'logit'`

score transformation to the raw
classification scores (see `ScoreTransform`

).

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 normalized weights to
estimate the weighted edge.

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

This function fully supports tall arrays. For more information, see Tall Arrays (MATLAB).

A modified version of this example exists on your system. Do you want to open this version instead?

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.

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

Select web siteYou can also select a web site from the following list:

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

- América Latina (Español)
- Canada (English)
- United States (English)

- 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)