margin
Class: ClassificationLinear
Classification margins for linear classification models
Syntax
Description
returns the classification
margins for the binary, linear classification model
m
= margin(Mdl
,X
,Y
)Mdl
using predictor data in X
and
corresponding class labels in Y
. m
contains classification margins for each regularization strength in
Mdl
.
returns the classification margins for the trained linear classifier
m
= margin(Mdl
,Tbl
,ResponseVarName
)Mdl
using the predictor data in table
Tbl
and the class labels in
Tbl.ResponseVarName
.
Input Arguments
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 ofMdl.ClassNames
. (The software treats string arrays as cell arrays of character vectors.)The distinct classes in
Y
must be a subset ofMdl.ClassNames
.If
Y
is a character array, then each element must correspond to one row of the array.The length of
Y
must be equal to the number of observations inX
orTbl
.
Data Types: categorical
| char
| string
| logical
| single
| double
| cell
dimension
— Predictor data observation dimension
'rows'
(default) | 'columns'
Predictor data observation dimension, specified as
'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. You cannot specify 'ObservationsIn','columns'
for predictor data in a table.
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 the predictors used to train Mdl
. Multicolumn variables
and cell arrays other than cell arrays of character vectors are not allowed.
If Tbl
contains the response variable used to train Mdl
, then you do not need to specify ResponseVarName
or Y
.
If you train Mdl
using sample data contained in a table, then the input
data for margin
must also be in a 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 Mdl
, then you do not need to specify ResponseVarName
.
If you specify ResponseVarName
, then you must specify it as a character
vector or string scalar. For example, if the response variable is stored as
Tbl.Y
, then specify ResponseVarName
as
'Y'
. Otherwise, the software treats all columns of
Tbl
, including Tbl.Y
, as predictors.
The response variable must be a categorical, character, or string array; a logical or numeric vector; or a 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
Output Arguments
m
— Classification margins
numeric column vector | numeric matrix
Classification margins, returned as a numeric column vector or matrix.
m
is n-by-L,
where n is the number of observations in X
and L is
the number of regularization strengths in Mdl
(that
is, numel(Mdl.Lambda)
).
m(
is
the classification margin of observation i using
the trained linear classification model that has regularization strength i
,j
)Mdl.Lambda(
.j
)
Examples
Estimate Test-Sample Margins
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 margins.
mTrain = margin(CMdl,X(trainIdx,:),Ystats(trainIdx)); mTest = margin(CMdl,X(testIdx,:),Ystats(testIdx));
Because there is one regularization strength in CMdl
, mTrain
and mTest
are column vectors with lengths equal to the number of training and test observations, respectively.
Plot both sets of margins using box plots.
figure; boxplot([mTrain; mTest],[zeros(size(mTrain,1),1); ones(size(mTest,1),1)], ... 'Labels',{'Training set','Test set'}); h = gca; h.YLim = [-5 60]; title 'Training- and Test-Set Margins'
The distributions of the margins between the training and test sets appear similar.
Feature Selection Using Test-Sample Margins
One way to perform feature selection is to compare test-sample margins from multiple models. Based solely on this criterion, the classifier with the larger margins is the better classifier.
Load the NLP data set. Preprocess the data as in Estimate Test-Sample Margins.
load nlpdata 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 10% of the predictor variables.
p = size(X,1); % Number of predictors
idxPart = randsample(p,ceil(0.1*p));
Train two binary, linear classification models: one that uses the all of the predictors and one that uses the random 10%. 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 margins for each classifier. Plot the distribution of the margins sets using box plots.
fullMargins = margin(CMdl,XTest,YTest,'ObservationsIn','columns'); partMargins = margin(PCMdl,XTest(idxPart,:),YTest,... 'ObservationsIn','columns'); figure; boxplot([fullMargins partMargins],'Labels',... {'All Predictors','10% of the Predictors'}); h = gca; h.YLim = [-20 60]; title('Test-Sample Margins')
The margin distribution of CMdl
is situated higher than the margin distribution of PCMdl
.
Find Good Lasso Penalty Using Margins
To determine a good lasso-penalty strength for a linear classification model that uses a logistic regression learner, compare distributions of test-sample margins.
Load the NLP data set. Preprocess the data as in Estimate Test-Sample Margins.
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 through .
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 = ClassificationPartitionedLinear CrossValidatedModel: 'Linear' ResponseName: 'Y' NumObservations: 31572 KFold: 1 Partition: [1x1 cvpartition] ClassNames: [0 1] ScoreTransform: 'none'
Extract the trained linear classification model.
Mdl = CVMdl.Trained{1}
Mdl = ClassificationLinear ResponseName: 'Y' ClassNames: [0 1] ScoreTransform: 'logit' Beta: [34023x11 double] Bias: [-11.3599 -11.3599 -11.3599 -11.3599 -11.3599 -7.2163 -5.1919 -3.7624 -3.1671 -2.9610 -2.9610] Lambda: [1.0000e-08 7.9433e-08 6.3096e-07 5.0119e-06 3.9811e-05 3.1623e-04 0.0025 0.0200 0.1585 1.2589 10] Learner: 'logistic'
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 margins.
m = margin(Mdl,X(:,testIdx),Ystats(testIdx),'ObservationsIn','columns'); size(m)
ans = 1×2
9471 11
Because there are 11 regularization strengths, m
has 11 columns.
Plot the test-sample margins for each regularization strength. Because logistic regression scores are in [0,1], margins are in [-1,1]. Rescale the margins to help identify the regularization strength that maximizes the margins over the grid.
figure; boxplot(10000.^m) ylabel('Exponentiated test-sample margins') xlabel('Lambda indices')
Several values of Lambda
yield margin distributions that are compacted near . 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 centers of the margin distributions start decreasing.
LambdaFinal = Lambda(5);
Train a linear classification model using the entire data set and specify the desired regularization strength.
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
.
More About
Classification Margin
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
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 = yf(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.
Classification Score
For linear classification models, the raw classification score for classifying the observation x, a row vector, into the positive class is defined by
For the model with regularization strength j, is the estimated column vector of coefficients (the model property
Beta(:,j)
) and 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
).
Extended Capabilities
Tall Arrays
Calculate with arrays that have more rows than fit in memory.
The
margin
function supports tall arrays with the following usage
notes and limitations:
margin
does not support talltable
data.
For more information, see Tall Arrays.
GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.
This function fully supports GPU arrays. For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).
Version History
Introduced in R2016aR2024a: Specify GPU arrays (requires Parallel Computing Toolbox)
margin
fully supports GPU arrays.
See Also
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)