edge

Class: ClassificationLinear

Classification edge for linear classification models

Description

example

e = edge(Mdl,X,Y) returns the classification edges for the binary, linear classification model Mdl using predictor data in X and corresponding class labels in Y. e contains a classification edge for each regularization strength in Mdl.

example

e = edge(___,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 supply observation weights.

Input Arguments

expand all

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

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

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

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.

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.

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(n,1).

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

Data Types: double | single

Output Arguments

expand all

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

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

Examples

expand all

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.

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.

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',...
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.

expand all

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