fitclinear
Fit binary linear classifier to highdimensional data
Syntax
Description
fitclinear
trains linear classification models for twoclass (binary) learning with highdimensional, full or sparse predictor data. Available linear classification models include regularized support vector machines (SVM) and logistic regression models. fitclinear
minimizes the objective function using techniques that reduce computing time (e.g., stochastic gradient descent).
For reduced computation time on a highdimensional data set that includes many predictor variables, train a linear classification model by using fitclinear
. For low through mediumdimensional predictor data sets, see Alternatives for LowerDimensional Data.
To train a linear classification model for multiclass learning by combining SVM or logistic regression binary classifiers using errorcorrecting output codes, see fitcecoc
.
returns a linear classification model using the predictor variables in the table
Mdl
= fitclinear(Tbl
,ResponseVarName
)Tbl
and the class labels in
Tbl.ResponseVarName
.
specifies options using one or more namevalue pair arguments in addition to any
of the input argument combinations in previous syntaxes. For example, you can
specify that the columns of the predictor matrix correspond to observations,
implement logistic regression, or specify to crossvalidate. A good practice is
to crossvalidate using the Mdl
= fitclinear(X
,Y
,Name,Value
)'Kfold'
namevalue pair argument.
The crossvalidation results determine how well the model generalizes.
[
also returns hyperparameter optimization details when you pass an
Mdl
,FitInfo
,HyperparameterOptimizationResults
]
= fitclinear(___)OptimizeHyperparameters
namevalue pair.
Examples
Train Linear Classification Model
Train a binary, linear classification model using support vector machines, dual SGD, and ridge regularization.
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.
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. Train the model using the entire data set. Determine how well the optimization algorithm fit the model to the data by extracting a fit summary.
rng(1); % For reproducibility
[Mdl,FitInfo] = fitclinear(X,Ystats)
Mdl = ClassificationLinear ResponseName: 'Y' ClassNames: [0 1] ScoreTransform: 'none' Beta: [34023x1 double] Bias: 1.0059 Lambda: 3.1674e05 Learner: 'svm' Properties, Methods
FitInfo = struct with fields:
Lambda: 3.1674e05
Objective: 5.3783e04
PassLimit: 10
NumPasses: 10
BatchLimit: []
NumIterations: 238561
GradientNorm: NaN
GradientTolerance: 0
RelativeChangeInBeta: 0.0562
BetaTolerance: 1.0000e04
DeltaGradient: 1.4582
DeltaGradientTolerance: 1
TerminationCode: 0
TerminationStatus: {'Iteration limit exceeded.'}
Alpha: [31572x1 double]
History: []
FitTime: 0.8858
Solver: {'dual'}
Mdl
is a ClassificationLinear
model. You can pass Mdl
and the training or new data to loss
to inspect the insample classification error. Or, you can pass Mdl
and new predictor data to predict
to predict class labels for new observations.
FitInfo
is a structure array containing, among other things, the termination status (TerminationStatus
) and how long the solver took to fit the model to the data (FitTime
). It is good practice to use FitInfo
to determine whether optimizationtermination measurements are satisfactory. Because training time is small, you can try to retrain the model, but increase the number of passes through the data. This can improve measures like DeltaGradient
.
Find Good Lasso Penalty Using CrossValidation
To determine a good lassopenalty strength for a linear classification model that uses a logistic regression learner, implement 5fold crossvalidation.
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';
Create a set of 11 logarithmicallyspaced regularization strengths from $$1{0}^{6}$$ through $$1{0}^{0.5}$$.
Lambda = logspace(6,0.5,11);
Crossvalidate the models. To increase execution speed, transpose the predictor data and specify that the observations are in columns. Estimate the coefficients using SpaRSA. Lower the tolerance on the gradient of the objective function to 1e8
.
X = X'; rng(10); % For reproducibility CVMdl = fitclinear(X,Ystats,'ObservationsIn','columns','KFold',5,... 'Learner','logistic','Solver','sparsa','Regularization','lasso',... 'Lambda',Lambda,'GradientTolerance',1e8)
CVMdl = ClassificationPartitionedLinear CrossValidatedModel: 'Linear' ResponseName: 'Y' NumObservations: 31572 KFold: 5 Partition: [1x1 cvpartition] ClassNames: [0 1] ScoreTransform: 'none' Properties, Methods
numCLModels = numel(CVMdl.Trained)
numCLModels = 5
CVMdl
is a ClassificationPartitionedLinear
model. Because fitclinear
implements 5fold crossvalidation, CVMdl
contains 5 ClassificationLinear
models that the software trains on each fold.
Display the first trained linear classification model.
Mdl1 = CVMdl.Trained{1}
Mdl1 = ClassificationLinear ResponseName: 'Y' ClassNames: [0 1] ScoreTransform: 'logit' Beta: [34023x11 double] Bias: [13.1918 13.1918 13.1918 13.1918 9.0803 7.1989 ... ] Lambda: [1.0000e06 3.5481e06 1.2589e05 4.4668e05 ... ] Learner: 'logistic' Properties, Methods
Mdl1
is a ClassificationLinear
model object. fitclinear
constructed Mdl1
by training on the first four folds. Because Lambda
is a sequence of regularization strengths, you can think of Mdl1
as 11 models, one for each regularization strength in Lambda
.
Estimate the crossvalidated classification error.
ce = kfoldLoss(CVMdl);
Because there are 11 regularization strengths, ce
is a 1by11 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 crossvalidated 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',1e8); numNZCoeff = sum(Mdl.Beta~=0);
In the same figure, plot the crossvalidated, classification 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)); hL1.Marker = 'o'; hL2.Marker = 'o'; ylabel(h(1),'log_{10} classification error') ylabel(h(2),'log_{10} nonzerocoefficient frequency') xlabel('log_{10} Lambda') title('TestSample 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
.
Optimize Linear Classifier
This example shows how to minimize the crossvalidation error in a linear classifier using fitclinear
. The example uses the NLP data set.
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. Identify the relevant labels.
X = X';
Ystats = Y == 'stats';
Optimize the classification using the 'auto'
parameters.
For reproducibility, set the random seed and use the 'expectedimprovementplus'
acquisition function.
rng default Mdl = fitclinear(X,Ystats,'ObservationsIn','columns','Solver','sparsa',... 'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',... struct('AcquisitionFunctionName','expectedimprovementplus'))
=====================================================================================================  Iter  Eval  Objective  Objective  BestSoFar  BestSoFar  Lambda  Learner    result   runtime  (observed)  (estim.)    =====================================================================================================  1  Best  0.041619  7.9197  0.041619  0.041619  0.077903  logistic   2  Best  0.00072849  8.6074  0.00072849  0.0028767  2.1405e09  logistic   3  Accept  0.049221  9.0699  0.00072849  0.00075737  0.72101  svm   4  Accept  0.00079184  7.8816  0.00072849  0.00074989  3.4734e07  svm   5  Accept  0.00076017  7.3993  0.00072849  0.00072915  1.1738e08  logistic   6  Accept  0.00085519  8.5031  0.00072849  0.00072735  2.473e09  svm   7  Accept  0.00079184  7.0025  0.00072849  0.00072504  3.1854e08  svm   8  Accept  0.00088686  7.7765  0.00072849  0.00072219  3.1717e10  svm   9  Accept  0.00076017  6.4699  0.00072849  0.00068087  3.1837e10  logistic   10  Accept  0.00079184  7.9615  0.00072849  0.00072894  1.1258e07  svm   11  Accept  0.00072849  7.3135  0.00072849  0.00070014  3.0254e09  logistic   12  Best  0.00066515  9.1424  0.00066515  0.00074706  1.9706e07  logistic   13  Accept  0.00066515  7.2682  0.00066515  0.00062538  6.3482e08  logistic   14  Accept  0.00069682  9.9849  0.00066515  0.00065022  7.5612e08  logistic   15  Accept  0.00066515  8.1818  0.00066515  0.00065314  8.6693e08  logistic   16  Accept  0.00069682  9.1597  0.00066515  0.00066257  9.3481e08  logistic   17  Accept  0.00076017  5.9323  0.00066515  0.00066275  8.4679e10  logistic   18  Accept  0.00088686  13.14  0.00066515  0.00066414  3.0816e07  logistic   19  Accept  0.0012669  7.6276  0.00066515  0.00066548  0.0008715  svm   20  Accept  0.00085519  5.7376  0.00066515  0.00066703  5.2543e05  svm  =====================================================================================================  Iter  Eval  Objective  Objective  BestSoFar  BestSoFar  Lambda  Learner    result   runtime  (observed)  (estim.)    =====================================================================================================  21  Accept  0.00091854  4.8697  0.00066515  0.00066729  0.00023384  svm   22  Accept  0.00079184  10.853  0.00066515  0.00066745  4.1954e06  svm   23  Accept  0.0010452  25.604  0.00066515  0.00068253  7.1565e06  logistic   24  Accept  0.0010136  26.681  0.00066515  0.00067696  1.9805e06  logistic   25  Accept  0.00079184  8.4275  0.00066515  0.00067719  1.2205e06  svm   26  Accept  0.00076017  9.2075  0.00066515  0.00068293  3.6687e08  logistic   27  Accept  0.00076017  7.8866  0.00066515  0.00068328  9.8797e09  svm   28  Accept  0.00082351  10.111  0.00066515  0.00068351  1.2236e05  svm   29  Accept  0.049221  1.0949  0.00066515  0.00068257  3.1358  logistic   30  Accept  0.0013303  11.363  0.00066515  0.00067789  0.00072735  logistic 
__________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 313.2648 seconds Total objective function evaluation time: 278.1766 Best observed feasible point: Lambda Learner __________ ________ 1.9706e07 logistic Observed objective function value = 0.00066515 Estimated objective function value = 0.00073542 Function evaluation time = 9.1424 Best estimated feasible point (according to models): Lambda Learner __________ ________ 8.6693e08 logistic Estimated objective function value = 0.00067789 Estimated function evaluation time = 8.7508
Mdl = ClassificationLinear ResponseName: 'Y' ClassNames: [0 1] ScoreTransform: 'logit' Beta: [34023x1 double] Bias: 10.0538 Lambda: 8.6693e08 Learner: 'logistic' Properties, Methods
Input Arguments
X
— Predictor data
full matrix  sparse matrix
Predictor data, specified as an nbyp full or sparse matrix.
The length of Y
and the number of observations
in X
must be equal.
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.
Data Types: single
 double
Y
— Class labels
categorical array  character array  string array  logical vector  numeric vector  cell array of character vectors
Class labels to which the classification model is trained, specified as a categorical, character, or string array, logical or numeric vector, or cell array of character vectors.
fitclinear
supports only binary classification. EitherY
must contain exactly two distinct classes, or you must specify two classes for training by using the'ClassNames'
namevalue pair argument. For multiclass learning, seefitcecoc
.The length of
Y
must be equal to the number of observations inX
orTbl
.If
Y
is a character array, then each label must correspond to one row of the array.A good practice is to specify the class order using the
ClassNames
namevalue pair argument.
Data Types: char
 string
 cell
 categorical
 logical
 single
 double
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. Multicolumn variables and cell arrays other than cell arrays of character vectors are not allowed.
Optionally, Tbl
can contain a column for the response variable and a column for the observation weights.
The response variable must be a categorical, character, or string array, a logical or numeric vector, or a cell array of character vectors.
fitclinear
supports only binary classification. Either the response variable must contain exactly two distinct classes, or you must specify two classes for training by using theClassNames
namevalue argument. For multiclass learning, seefitcecoc
.A good practice is to specify the order of the classes in the response variable by using the
ClassNames
namevalue argument.
The column for the weights must be a numeric vector.
You must specify the response variable in
Tbl
by usingResponseVarName
orformula
and specify the observation weights inTbl
by usingWeights
.Specify the response variable by using
ResponseVarName
—fitclinear
uses the remaining variables as predictors. To use a subset of the remaining variables inTbl
as predictors, specify predictor variables by usingPredictorNames
.Define a model specification by using
formula
—fitclinear
uses a subset of the variables inTbl
as predictor variables and the response variable, as specified informula
.
If Tbl
does not contain the response variable, then specify a response variable by using Y
. The length of the response variable Y
and the number of rows in Tbl
must be equal. To use a subset of the variables in Tbl
as predictors, specify predictor variables by using PredictorNames
.
Data Types: table
ResponseVarName
— Response variable name
name of variable in Tbl
Response variable name, specified as the name of a variable in
Tbl
.
You must specify ResponseVarName
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 when training
the model.
The response variable must be a categorical, character, or string array; a logical or numeric
vector; or a cell array of character vectors. If
Y
is a character array, then each
element of the response variable must correspond to one row of
the array.
A good practice is to specify the order of the classes by using the
ClassNames
namevalue
argument.
Data Types: char
 string
formula
— Explanatory model of response variable and subset of predictor variables
character vector  string scalar
Explanatory model of the response variable and a subset of the predictor variables,
specified as a character vector or string scalar in the form
"Y~x1+x2+x3"
. In this form, Y
represents the
response variable, and x1
, x2
, and
x3
represent the predictor variables.
To specify a subset of variables in Tbl
as predictors for
training the model, use a formula. If you specify a formula, then the software does not
use any variables in Tbl
that do not appear in
formula
.
The variable names in the formula must be both variable names in Tbl
(Tbl.Properties.VariableNames
) and valid MATLAB^{®} identifiers. You can verify the variable names in Tbl
by
using the isvarname
function. If the variable names
are not valid, then you can convert them by using the matlab.lang.makeValidName
function.
Data Types: char
 string
Note
The software treats NaN
, empty character vector
(''
), empty string (""
),
<missing>
, and <undefined>
elements as missing values, and removes observations with any of these characteristics:
Missing value in the response variable (for example,
Y
orValidationData
{2}
)At least one missing value in a predictor observation (for example, row in
X
orValidationData{1}
)NaN
value or0
weight (for example, value inWeights
orValidationData{3}
)
For memoryusage economy, it is best practice to remove observations containing missing values from your training data manually before training.
NameValue Arguments
Specify optional pairs of arguments as
Name1=Value1,...,NameN=ValueN
, where Name
is
the argument name and Value
is the corresponding value.
Namevalue arguments must appear after other arguments, but the order of the
pairs does not matter.
Before R2021a, use commas to separate each name and value, and enclose
Name
in quotes.
Example: 'ObservationsIn','columns','Learner','logistic','CrossVal','on'
specifies that the columns of the predictor matrix corresponds to observations, to implement logistic regression, to implement 10fold crossvalidation.
Note
You cannot use any crossvalidation namevalue argument together with the
'OptimizeHyperparameters'
namevalue argument. You can modify the
crossvalidation for 'OptimizeHyperparameters'
only by using the
'HyperparameterOptimizationOptions'
namevalue argument.
Lambda
— Regularization term strength
'auto'
(default)  nonnegative scalar  vector of nonnegative values
Regularization term strength, specified as the commaseparated pair consisting of 'Lambda'
and 'auto'
, a nonnegative scalar, or a vector of nonnegative values.
For
'auto'
,Lambda
= 1/n.If you specify a crossvalidation, namevalue pair argument (e.g.,
CrossVal
), then n is the number of infold observations.Otherwise, n is the training sample size.
For a vector of nonnegative values,
fitclinear
sequentially optimizes the objective function for each distinct value inLambda
in ascending order.If
Solver
is'sgd'
or'asgd'
andRegularization
is'lasso'
,fitclinear
does not use the previous coefficient estimates as a warm start for the next optimization iteration. Otherwise,fitclinear
uses warm starts.If
Regularization
is'lasso'
, then any coefficient estimate of 0 retains its value whenfitclinear
optimizes using subsequent values inLambda
.fitclinear
returns coefficient estimates for each specified regularization strength.
Example: 'Lambda',10.^((10:2:2))
Data Types: char
 string
 double
 single
Learner
— Linear classification model type
'svm'
(default)  'logistic'
Linear classification model type, specified as the commaseparated
pair consisting of 'Learner'
and 'svm'
or 'logistic'
.
In this table, $$f\left(x\right)=x\beta +b.$$
β is a vector of p coefficients.
x is an observation from p predictor variables.
b is the scalar bias.
Value  Algorithm  Response Range  Loss Function 

'svm'  Support vector machine  y ∊ {–1,1}; 1 for the positive class and –1 otherwise  Hinge: $$\ell \left[y,f\left(x\right)\right]=\mathrm{max}\left[0,1yf\left(x\right)\right]$$ 
'logistic'  Logistic regression  Same as 'svm'  Deviance (logistic): $$\ell \left[y,f\left(x\right)\right]=\mathrm{log}\left\{1+\mathrm{exp}\left[yf\left(x\right)\right]\right\}$$ 
Example: 'Learner','logistic'
ObservationsIn
— Predictor data observation dimension
'rows'
(default)  'columns'
Predictor data observation dimension, specified as 'rows'
or
'columns'
.
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. You cannot specify
'ObservationsIn','columns'
for predictor data in a
table.
Example: 'ObservationsIn','columns'
Data Types: char
 string
Regularization
— Complexity penalty type
'lasso'
 'ridge'
Complexity penalty type, specified as the commaseparated pair
consisting of 'Regularization'
and 'lasso'
or 'ridge'
.
The software composes the objective function for minimization
from the sum of the average loss function (see Learner
)
and the regularization term in this table.
Value  Description 

'lasso'  Lasso (L1) penalty: $$\lambda {\displaystyle \sum _{j=1}^{p}\left{\beta}_{j}\right}$$ 
'ridge'  Ridge (L2) penalty: $$\frac{\lambda}{2}{\displaystyle \sum _{j=1}^{p}{\beta}_{j}^{2}}$$ 
To specify the regularization term strength, which is λ in
the expressions, use Lambda
.
The software excludes the bias term (β_{0}) from the regularization penalty.
If Solver
is 'sparsa'
,
then the default value of Regularization
is 'lasso'
.
Otherwise, the default is 'ridge'
.
Tip
For predictor variable selection, specify
'lasso'
. For more on variable selection, see Introduction to Feature Selection.For optimization accuracy, specify
'ridge'
.
Example: 'Regularization','lasso'
Solver
— Objective function minimization technique
'sgd'
 'asgd'
 'dual'
 'bfgs'
 'lbfgs'
 'sparsa'
 string array  cell array of character vectors
Objective function minimization technique, specified as the
commaseparated pair consisting of 'Solver'
and a
character vector or string scalar, a string array, or a cell array of
character vectors with values from this table.
Value  Description  Restrictions 

'sgd'  Stochastic gradient descent (SGD) [4][2]  
'asgd'  Average stochastic gradient descent (ASGD) [7]  
'dual'  Dual SGD for SVM [1][6]  Regularization must be 'ridge' and Learner must be 'svm' . 
'bfgs'  BroydenFletcherGoldfarbShanno quasiNewton algorithm (BFGS) [3]  Inefficient if X is very highdimensional. 
'lbfgs'  Limitedmemory BFGS (LBFGS) [3]  Regularization must be 'ridge' . 
'sparsa'  Sparse Reconstruction by Separable Approximation (SpaRSA) [5]  Regularization must be 'lasso' . 
If you specify:
A ridge penalty (see
Regularization
) andX
contains 100 or fewer predictor variables, then the default solver is'bfgs'
.An SVM model (see
Learner
), a ridge penalty, andX
contains more than 100 predictor variables, then the default solver is'dual'
.A lasso penalty and
X
contains 100 or fewer predictor variables, then the default solver is'sparsa'
.
Otherwise, the default solver is
'sgd'
. Note that the default solver can change when
you perform hyperparameter optimization. For more information, see Regularization method determines the solver used during hyperparameter optimization.
If you specify a string array or cell array of solver names, then, for
each value in Lambda
, the software uses the
solutions of solver j as a warm start for solver
j + 1.
Example: {'sgd' 'lbfgs'}
applies SGD to solve the
objective, and uses the solution as a warm start for
LBFGS.
Tip
SGD and ASGD can solve the objective function more quickly than other solvers, whereas LBFGS and SpaRSA can yield more accurate solutions than other solvers. Solver combinations like
{'sgd' 'lbfgs'}
and{'sgd' 'sparsa'}
can balance optimization speed and accuracy.When choosing between SGD and ASGD, consider that:
SGD takes less time per iteration, but requires more iterations to converge.
ASGD requires fewer iterations to converge, but takes more time per iteration.
If the predictor data is high dimensional and
Regularization
is'ridge'
, setSolver
to any of these combinations:'sgd'
'asgd'
'dual'
ifLearner
is'svm'
'lbfgs'
{'sgd','lbfgs'}
{'asgd','lbfgs'}
{'dual','lbfgs'}
ifLearner
is'svm'
Although you can set other combinations, they often lead to solutions with poor accuracy.
If the predictor data is moderate through low dimensional and
Regularization
is'ridge'
, setSolver
to'bfgs'
.If
Regularization
is'lasso'
, setSolver
to any of these combinations:'sgd'
'asgd'
'sparsa'
{'sgd','sparsa'}
{'asgd','sparsa'}
Example: 'Solver',{'sgd','lbfgs'}
Beta
— Initial linear coefficient estimates
zeros(p
,1)
(default)  numeric vector  numeric matrix
p
,1)Initial linear coefficient estimates (β),
specified as the commaseparated pair consisting of 'Beta'
and
a pdimensional numeric vector or a pbyL numeric
matrix. p is the number of predictor variables
in X
and L is the number of
regularizationstrength values (for more details, see Lambda
).
If you specify a pdimensional vector, then the software optimizes the objective function L times using this process.
The software optimizes using
Beta
as the initial value and the minimum value ofLambda
as the regularization strength.The software optimizes again using the resulting estimate from the previous optimization as a warm start, and the next smallest value in
Lambda
as the regularization strength.The software implements step 2 until it exhausts all values in
Lambda
.
If you specify a pbyL matrix, then the software optimizes the objective function L times. At iteration
j
, the software usesBeta(:,
as the initial value and, after it sortsj
)Lambda
in ascending order, usesLambda(
as the regularization strength.j
)
If you set 'Solver','dual'
, then the software
ignores Beta
.
Data Types: single
 double
Bias
— Initial intercept estimate
numeric scalar  numeric vector
Initial intercept estimate (b), specified
as the commaseparated pair consisting of 'Bias'
and
a numeric scalar or an Ldimensional numeric vector. L is
the number of regularizationstrength values (for more details, see Lambda
).
If you specify a scalar, then the software optimizes the objective function L times using this process.
The software optimizes using
Bias
as the initial value and the minimum value ofLambda
as the regularization strength.The uses the resulting estimate as a warm start to the next optimization iteration, and uses the next smallest value in
Lambda
as the regularization strength.The software implements step 2 until it exhausts all values in
Lambda
.
If you specify an Ldimensional vector, then the software optimizes the objective function L times. At iteration
j
, the software usesBias(
as the initial value and, after it sortsj
)Lambda
in ascending order, usesLambda(
as the regularization strength.j
)By default:
If
Learner
is'logistic'
, then let g_{j} be 1 ifY(
is the positive class, and 1 otherwise.j
)Bias
is the weighted average of the g for training or, for crossvalidation, infold observations.If
Learner
is'svm'
, thenBias
is 0.
Data Types: single
 double
FitBias
— Linear model intercept inclusion flag
true
(default)  false
Linear model intercept inclusion flag, specified as the commaseparated
pair consisting of 'FitBias'
and true
or false
.
Value  Description 

true  The software includes the bias term b in the linear model, and then estimates it. 
false  The software sets b = 0 during estimation. 
Example: 'FitBias',false
Data Types: logical
PostFitBias
— Flag to fit linear model intercept after optimization
false
(default)  true
Flag to fit the linear model intercept after optimization, specified
as the commaseparated pair consisting of 'PostFitBias'
and true
or false
.
Value  Description 

false  The software estimates the bias term b and the coefficients β during optimization. 
true 
To estimate b, the software:

If you specify true
, then FitBias
must
be true.
Example: 'PostFitBias',true
Data Types: logical
Verbose
— Verbosity level
0
(default)  nonnegative integer
Verbosity level, specified as the commaseparated pair consisting
of 'Verbose'
and a nonnegative integer. Verbose
controls
the amount of diagnostic information fitclinear
displays
at the command line.
Value  Description 

0  fitclinear does not display diagnostic
information. 
1  fitclinear periodically displays and
stores the value of the objective function, gradient magnitude, and
other diagnostic information. FitInfo.History contains
the diagnostic information. 
Any other positive integer  fitclinear displays and stores diagnostic
information at each optimization iteration. FitInfo.History contains
the diagnostic information. 
Example: 'Verbose',1
Data Types: double
 single
BatchSize
— Minibatch size
positive integer
Minibatch size, specified as the commaseparated pair consisting
of 'BatchSize'
and a positive integer. At each
iteration, the software estimates the subgradient using BatchSize
observations
from the training data.
If
X
is a numeric matrix, then the default value is10
.If
X
is a sparse matrix, then the default value ismax([10,ceil(sqrt(ff))])
, whereff = numel(X)/nnz(X)
(the fullness factor ofX
).
Example: 'BatchSize',100
Data Types: single
 double
LearnRate
— Learning rate
positive scalar
Learning rate, specified as the commaseparated pair consisting of 'LearnRate'
and a positive scalar. LearnRate
controls the optimization step size by scaling the subgradient.
If
Regularization
is'ridge'
, thenLearnRate
specifies the initial learning rate γ_{0}.fitclinear
determines the learning rate for iteration t, γ_{t}, using$${\gamma}_{t}=\frac{{\gamma}_{0}}{{\left(1+\lambda {\gamma}_{0}t\right)}^{c}}.$$
If
Regularization
is'lasso'
, then, for all iterations,LearnRate
is constant.
By default, LearnRate
is 1/sqrt(1+max((sum(X.^2,obsDim))))
, where obsDim
is 1
if the observations compose the columns of the predictor data X
, and 2
otherwise.
Example: 'LearnRate',0.01
Data Types: single
 double
OptimizeLearnRate
— Flag to decrease learning rate
true
(default)  false
Flag to decrease the learning rate when the software detects
divergence (that is, overstepping the minimum), specified as the
commaseparated pair consisting of 'OptimizeLearnRate'
and true
or false
.
If OptimizeLearnRate
is 'true'
,
then:
For the few optimization iterations, the software starts optimization using
LearnRate
as the learning rate.If the value of the objective function increases, then the software restarts and uses half of the current value of the learning rate.
The software iterates step 2 until the objective function decreases.
Example: 'OptimizeLearnRate',true
Data Types: logical
TruncationPeriod
— Number of minibatches between lasso truncation runs
10
(default)  positive integer
Number of minibatches between lasso truncation runs, specified
as the commaseparated pair consisting of 'TruncationPeriod'
and
a positive integer.
After a truncation run, the software applies a soft threshold
to the linear coefficients. That is, after processing k = TruncationPeriod
minibatches,
the software truncates the estimated coefficient j using
$${\widehat{\beta}}_{j}^{\ast}=\{\begin{array}{ll}{\widehat{\beta}}_{j}{u}_{t}\hfill & \text{if}\text{\hspace{0.17em}}{\widehat{\beta}}_{j}>{u}_{t},\hfill \\ 0\hfill & \text{if}\text{\hspace{0.17em}}\left{\widehat{\beta}}_{j}\right\le {u}_{t},\hfill \\ {\widehat{\beta}}_{j}+{u}_{t}\hfill & \text{if}\text{\hspace{0.17em}}{\widehat{\beta}}_{j}<{u}_{t}.\hfill \end{array}\begin{array}{r}\hfill \text{\hspace{0.17em}}\text{\hspace{0.17em}}\\ \hfill \text{\hspace{0.17em}}\text{\hspace{0.17em}}\\ \hfill \text{\hspace{0.17em}}\text{\hspace{0.17em}}\end{array}$$
For SGD, $${\widehat{\beta}}_{j}$$ is the estimate of coefficient j after processing k minibatches. $${u}_{t}=k{\gamma}_{t}\lambda .$$ γ_{t} is the learning rate at iteration t. λ is the value of
Lambda
.For ASGD, $${\widehat{\beta}}_{j}$$ is the averaged estimate coefficient j after processing k minibatches, $${u}_{t}=k\lambda .$$
If Regularization
is 'ridge'
,
then the software ignores TruncationPeriod
.
Example: 'TruncationPeriod',100
Data Types: single
 double
CategoricalPredictors
— Categorical predictors list
vector of positive integers  logical vector  character matrix  string array  cell array of character vectors  'all'
Categorical predictors list, specified as one of the values in this table. The descriptions assume that the predictor data has observations in rows and predictors in columns.
Value  Description 

Vector of positive integers 
Each entry in the vector is an index value indicating that the corresponding predictor is
categorical. The index values are between 1 and If 
Logical vector 
A 
Character matrix  Each row of the matrix is the name of a predictor variable. The names must match the entries in PredictorNames . Pad the names with extra blanks so each row of the character matrix has the same length. 
String array or cell array of character vectors  Each element in the array is the name of a predictor variable. The names must match the entries in PredictorNames . 
"all"  All predictors are categorical. 
By default, if the
predictor data is in a table (Tbl
), fitclinear
assumes that a variable is categorical if it is a logical vector, categorical vector, character
array, string array, or cell array of character vectors. If the predictor data is a matrix
(X
), fitclinear
assumes that all predictors are
continuous. To identify any other predictors as categorical predictors, specify them by using
the 'CategoricalPredictors'
namevalue argument.
For the identified categorical predictors, fitclinear
creates
dummy variables using two different schemes, depending on whether a categorical variable
is unordered or ordered. For an unordered categorical variable,
fitclinear
creates one dummy variable for each level of the
categorical variable. For an ordered categorical variable,
fitclinear
creates one less dummy variable than the number of
categories. For details, see Automatic Creation of Dummy Variables.
Example: 'CategoricalPredictors','all'
Data Types: single
 double
 logical
 char
 string
 cell
ClassNames
— Names of classes to use for training
categorical array  character array  string array  logical vector  numeric vector  cell array of character vectors
Names of classes to use for training, specified as a categorical, character, or string
array; a logical or numeric vector; or a cell array of character vectors.
ClassNames
must have the same data type as the response variable
in Tbl
or Y
.
If ClassNames
is a character array, then each element must correspond to one row of the array.
Use ClassNames
to:
Specify the order of the classes during training.
Specify the order of any input or output argument dimension that corresponds to the class order. For example, use
ClassNames
to specify the order of the dimensions ofCost
or the column order of classification scores returned bypredict
.Select a subset of classes for training. For example, suppose that the set of all distinct class names in
Y
is["a","b","c"]
. To train the model using observations from classes"a"
and"c"
only, specify"ClassNames",["a","c"]
.
The default value for ClassNames
is the set of all distinct class names in the response variable in Tbl
or Y
.
Example: "ClassNames",["b","g"]
Data Types: categorical
 char
 string
 logical
 single
 double
 cell
Cost
— Misclassification cost
square matrix  structure array
Misclassification cost, specified as the commaseparated pair consisting of
'Cost'
and a square matrix or structure.
If you specify the square matrix
cost
('Cost',cost
), thencost(i,j)
is the cost of classifying a point into classj
if its true class isi
. That is, the rows correspond to the true class, and the columns correspond to the predicted class. To specify the class order for the corresponding rows and columns ofcost
, use theClassNames
namevalue pair argument.If you specify the structure
S
('Cost',S
), then it must have two fields:S.ClassNames
, which contains the class names as a variable of the same data type asY
S.ClassificationCosts
, which contains the cost matrix with rows and columns ordered as inS.ClassNames
The default value for Cost
is
ones(
, where K
) –
eye(K
)K
is
the number of distinct classes.
fitclinear
uses Cost
to adjust the prior
class probabilities specified in Prior
. Then,
fitclinear
uses the adjusted prior probabilities for
training.
Example: 'Cost',[0 2; 1 0]
Data Types: single
 double
 struct
PredictorNames
— Predictor variable names
string array of unique names  cell array of unique character vectors
Predictor variable names, specified as a string array of unique names or cell array of unique
character vectors. The functionality of 'PredictorNames'
depends on
the way you supply the training data.
If you supply
X
andY
, then you can use'PredictorNames'
to assign names to the predictor variables inX
.The order of the names in
PredictorNames
must correspond to the predictor order inX
. Assuming thatX
has the default orientation, with observations in rows and predictors in columns,PredictorNames{1}
is the name ofX(:,1)
,PredictorNames{2}
is the name ofX(:,2)
, and so on. Also,size(X,2)
andnumel(PredictorNames)
must be equal.By default,
PredictorNames
is{'x1','x2',...}
.
If you supply
Tbl
, then you can use'PredictorNames'
to choose which predictor variables to use in training. That is,fitclinear
uses only the predictor variables inPredictorNames
and the response variable during training.PredictorNames
must be a subset ofTbl.Properties.VariableNames
and cannot include the name of the response variable.By default,
PredictorNames
contains the names of all predictor variables.A good practice is to specify the predictors for training using either
'PredictorNames'
orformula
, but not both.
Example: 'PredictorNames',{'SepalLength','SepalWidth','PetalLength','PetalWidth'}
Data Types: string
 cell
Prior
— Prior probabilities
'empirical'
(default)  'uniform'
 numeric vector  structure array
Prior probabilities for each class, specified as the commaseparated pair consisting
of 'Prior'
and 'empirical'
,
'uniform'
, a numeric vector, or a structure array.
This table summarizes the available options for setting prior probabilities.
Value  Description 

'empirical'  The class prior probabilities are the class relative frequencies
in Y . 
'uniform'  All class prior probabilities are equal to
1/K , where
K is the number of classes. 
numeric vector  Each element is a class prior probability. Order the elements
according to their order in Y . If you specify
the order using the 'ClassNames' namevalue
pair argument, then order the elements accordingly. 
structure array 
A structure

fitclinear
normalizes the prior probabilities in
Prior
to sum to 1.
Example: 'Prior',struct('ClassNames',{{'setosa','versicolor'}},'ClassProbs',1:2)
Data Types: char
 string
 double
 single
 struct
ResponseName
— Response variable name
"Y"
(default)  character vector  string scalar
Response variable name, specified as a character vector or string scalar.
If you supply
Y
, then you can useResponseName
to specify a name for the response variable.If you supply
ResponseVarName
orformula
, then you cannot useResponseName
.
Example: "ResponseName","response"
Data Types: char
 string
ScoreTransform
— Score transformation
"none"
(default)  "doublelogit"
 "invlogit"
 "ismax"
 "logit"
 function handle  ...
Score transformation, specified as a character vector, string scalar, or function handle.
This table summarizes the available character vectors and string scalars.
Value  Description 

"doublelogit"  1/(1 + e^{–2x}) 
"invlogit"  log(x / (1 – x)) 
"ismax"  Sets the score for the class with the largest score to 1, and sets the scores for all other classes to 0 
"logit"  1/(1 + e^{–x}) 
"none" or "identity"  x (no transformation) 
"sign"  –1 for x < 0 0 for x = 0 1 for x > 0 
"symmetric"  2x – 1 
"symmetricismax"  Sets the score for the class with the largest score to 1, and sets the scores for all other classes to –1 
"symmetriclogit"  2/(1 + e^{–x}) – 1 
For a MATLAB function or a function you define, use its function handle for the score transform. The function handle must accept a matrix (the original scores) and return a matrix of the same size (the transformed scores).
Example: "ScoreTransform","logit"
Data Types: char
 string
 function_handle
Weights
— Observation weights
nonnegative numeric vector  name of variable in Tbl
Observation weights, specified as a nonnegative numeric vector or the name of a
variable in Tbl
. The software weights each observation in
X
or Tbl
with the corresponding value in
Weights
. The length of Weights
must equal
the number of observations in X
or Tbl
.
If you specify the input data as a table Tbl
, then
Weights
can be the name of a variable in
Tbl
that contains a numeric vector. In this case, you must
specify Weights
as a character vector or string scalar. For
example, if the weights vector W
is stored as
Tbl.W
, then specify it as 'W'
. Otherwise, the
software treats all columns of Tbl
, including W
,
as predictors or the response variable when training the model.
By default, Weights
is ones(n,1)
, where
n
is the number of observations in X
or
Tbl
.
The software normalizes Weights
to sum to the value of the prior
probability in the respective class.
Data Types: single
 double
 char
 string
CrossVal
— Crossvalidation flag
'off'
(default)  'on'
Crossvalidation flag, specified as the commaseparated pair
consisting of 'Crossval'
and 'on'
or 'off'
.
If you specify 'on'
, then the software implements
10fold crossvalidation.
To override this crossvalidation setting, use one of these
namevalue pair arguments: CVPartition
, Holdout
,
or KFold
. To create a crossvalidated model,
you can use one crossvalidation namevalue pair argument at a time
only.
Example: 'Crossval','on'
CVPartition
— Crossvalidation partition
[]
(default)  cvpartition
partition object
Crossvalidation partition, specified as the commaseparated
pair consisting of 'CVPartition'
and a cvpartition
partition
object as created by cvpartition
.
The partition object specifies the type of crossvalidation, and also
the indexing for training and validation sets.
To create a crossvalidated model, you can use one of these
four options only: '
CVPartition
'
, '
Holdout
'
,
or '
KFold
'
.
Holdout
— Fraction of data for holdout validation
scalar value in the range (0,1)
Fraction of data used for holdout validation, specified as the
commaseparated pair consisting of 'Holdout'
and
a scalar value in the range (0,1). If you specify 'Holdout',
,
then the software: p
Randomly reserves
% of the data as validation data, and trains the model using the rest of the datap
*100Stores the compact, trained model in the
Trained
property of the crossvalidated model.
To create a crossvalidated model, you can use one of these
four options only: '
CVPartition
'
, '
Holdout
'
,
or '
KFold
'
.
Example: 'Holdout',0.1
Data Types: double
 single
KFold
— Number of folds
10
(default)  positive integer value greater than 1
Number of folds to use in a crossvalidated classifier, specified
as the commaseparated pair consisting of 'KFold'
and
a positive integer value greater than 1. If you specify, e.g., 'KFold',k
,
then the software:
Randomly partitions the data into k sets
For each set, reserves the set as validation data, and trains the model using the other k – 1 sets
Stores the
k
compact, trained models in the cells of ak
by1 cell vector in theTrained
property of the crossvalidated model.
To create a crossvalidated model, you can use one of these
four options only: '
CVPartition
'
, '
Holdout
'
,
or '
KFold
'
.
Example: 'KFold',8
Data Types: single
 double
BatchLimit
— Maximal number of batches
positive integer
Maximal number of batches to process, specified as the commaseparated
pair consisting of 'BatchLimit'
and a positive
integer. When the software processes BatchLimit
batches,
it terminates optimization.
By default:
If you specify
BatchLimit
, thenfitclinear
uses the argument that results in processing the fewest observations, eitherBatchLimit
orPassLimit
.
Example: 'BatchLimit',100
Data Types: single
 double
BetaTolerance
— Relative tolerance on linear coefficients and bias term
1e4
(default)  nonnegative scalar
Relative tolerance on the linear coefficients and the bias term (intercept), specified
as the commaseparated pair consisting of 'BetaTolerance'
and a
nonnegative scalar.
Let $${B}_{t}=\left[{\beta}_{t}{}^{\prime}\text{\hspace{0.17em}}\text{\hspace{0.17em}}{b}_{t}\right]$$, that is, the vector of the coefficients and the bias term at optimization iteration t. If $${\Vert \frac{{B}_{t}{B}_{t1}}{{B}_{t}}\Vert}_{2}<\text{BetaTolerance}$$, then optimization terminates.
If the software converges for the last solver specified in
Solver
, then optimization terminates. Otherwise, the software uses
the next solver specified in Solver
.
Example: 'BetaTolerance',1e6
Data Types: single
 double
NumCheckConvergence
— Number of batches to process before next convergence check
positive integer
Number of batches to process before next convergence check, specified as the
commaseparated pair consisting of 'NumCheckConvergence'
and a
positive integer.
To specify the batch size, see BatchSize
.
The software checks for convergence about 10 times per pass through the entire data set by default.
Example: 'NumCheckConvergence',100
Data Types: single
 double
PassLimit
— Maximal number of passes
1
(default)  positive integer
Maximal number of passes through the data, specified as the commaseparated pair consisting of 'PassLimit'
and a positive integer.
fitclinear
processes all observations when it completes one pass through the data.
When fitclinear
passes through the data PassLimit
times, it terminates optimization.
If you specify BatchLimit
, then
fitclinear
uses the argument that results in
processing the fewest observations, either
BatchLimit
or
PassLimit
.
Example: 'PassLimit',5
Data Types: single
 double
ValidationData
— Validation data for optimization convergence detection
cell array  table
Validation data for optimization convergence detection, specified as the commaseparated pair
consisting of 'ValidationData'
and a cell array or table.
During optimization, the software periodically estimates the loss of ValidationData
. If the validationdata loss increases, then the software terminates optimization. For more details, see Algorithms. To optimize hyperparameters using crossvalidation, see crossvalidation options such as CrossVal
.
You can specify ValidationData
as a table if you use a table
Tbl
of predictor data that contains the response variable. In this
case, ValidationData
must contain the same predictors and response
contained in Tbl
. The software does not apply weights to observations,
even if Tbl
contains a vector of weights. To specify weights, you must
specify ValidationData
as a cell array.
If you specify ValidationData
as a cell array, then it must have the following format:
ValidationData{1}
must have the same data type and orientation as the predictor data. That is, if you use a predictor matrixX
, thenValidationData{1}
must be an mbyp or pbym full or sparse matrix of predictor data that has the same orientation asX
. The predictor variables in the training dataX
andValidationData{1}
must correspond. Similarly, if you use a predictor tableTbl
of predictor data, thenValidationData{1}
must be a table containing the same predictor variables contained inTbl
. The number of observations inValidationData{1}
and the predictor data can vary.ValidationData{2}
must match the data type and format of the response variable, eitherY
orResponseVarName
. IfValidationData{2}
is an array of class labels, then it must have the same number of elements as the number of observations inValidationData{1}
. The set of all distinct labels ofValidationData{2}
must be a subset of all distinct labels ofY
. IfValidationData{1}
is a table, thenValidationData{2}
can be the name of the response variable in the table. If you want to use the sameResponseVarName
orformula
, you can specifyValidationData{2}
as[]
.Optionally, you can specify
ValidationData{3}
as an mdimensional numeric vector of observation weights or the name of a variable in the tableValidationData{1}
that contains observation weights. The software normalizes the weights with the validation data so that they sum to 1.
If you specify ValidationData
and want to display the validation loss at
the command line, specify a value larger than 0 for Verbose
.
If the software converges for the last solver specified in Solver
, then optimization terminates. Otherwise, the software uses the next solver specified in Solver
.
By default, the software does not detect convergence by monitoring validationdata loss.
BetaTolerance
— Relative tolerance on linear coefficients and bias term
1e4
(default)  nonnegative scalar
Relative tolerance on the linear coefficients and the bias term (intercept), specified
as the commaseparated pair consisting of 'BetaTolerance'
and a
nonnegative scalar.
Let $${B}_{t}=\left[{\beta}_{t}{}^{\prime}\text{\hspace{0.17em}}\text{\hspace{0.17em}}{b}_{t}\right]$$, that is, the vector of the coefficients and the bias term at optimization iteration t. If $${\Vert \frac{{B}_{t}{B}_{t1}}{{B}_{t}}\Vert}_{2}<\text{BetaTolerance}$$, then optimization terminates.
If you also specify DeltaGradientTolerance
, then optimization
terminates when the software satisfies either stopping criterion.
If the software converges for the last solver specified in
Solver
, then optimization terminates. Otherwise, the software uses
the next solver specified in Solver
.
Example: 'BetaTolerance',1e6
Data Types: single
 double
DeltaGradientTolerance
— Gradientdifference tolerance
1
(default)  nonnegative scalar
Gradientdifference tolerance between upper and lower pool KarushKuhnTucker
(KKT) complementarity conditions violators, specified as the
commaseparated pair consisting of 'DeltaGradientTolerance'
and
a nonnegative scalar.
If the magnitude of the KKT violators is less than
DeltaGradientTolerance
, then the software terminates optimization.If the software converges for the last solver specified in
Solver
, then optimization terminates. Otherwise, the software uses the next solver specified inSolver
.
Example: 'DeltaGapTolerance',1e2
Data Types: double
 single
NumCheckConvergence
— Number of passes through entire data set to process before next convergence check
5
(default)  positive integer
Number of passes through entire data set to process before next convergence check,
specified as the commaseparated pair consisting of
'NumCheckConvergence'
and a positive integer.
Example: 'NumCheckConvergence',100
Data Types: single
 double
PassLimit
— Maximal number of passes
10
(default)  positive integer
Maximal number of passes through the data, specified as the
commaseparated pair consisting of 'PassLimit'
and
a positive integer.
When the software completes one pass through the data, it has processed all observations.
When the software passes through the data PassLimit
times,
it terminates optimization.
Example: 'PassLimit',5
Data Types: single
 double
ValidationData
— Validation data for optimization convergence detection
cell array  table
Validation data for optimization convergence detection, specified as the commaseparated pair
consisting of 'ValidationData'
and a cell array or table.
During optimization, the software periodically estimates the loss of ValidationData
. If the validationdata loss increases, then the software terminates optimization. For more details, see Algorithms. To optimize hyperparameters using crossvalidation, see crossvalidation options such as CrossVal
.
You can specify ValidationData
as a table if you use a table
Tbl
of predictor data that contains the response variable. In this
case, ValidationData
must contain the same predictors and response
contained in Tbl
. The software does not apply weights to observations,
even if Tbl
contains a vector of weights. To specify weights, you must
specify ValidationData
as a cell array.
If you specify ValidationData
as a cell array, then it must have the following format:
ValidationData{1}
must have the same data type and orientation as the predictor data. That is, if you use a predictor matrixX
, thenValidationData{1}
must be an mbyp or pbym full or sparse matrix of predictor data that has the same orientation asX
. The predictor variables in the training dataX
andValidationData{1}
must correspond. Similarly, if you use a predictor tableTbl
of predictor data, thenValidationData{1}
must be a table containing the same predictor variables contained inTbl
. The number of observations inValidationData{1}
and the predictor data can vary.ValidationData{2}
must match the data type and format of the response variable, eitherY
orResponseVarName
. IfValidationData{2}
is an array of class labels, then it must have the same number of elements as the number of observations inValidationData{1}
. The set of all distinct labels ofValidationData{2}
must be a subset of all distinct labels ofY
. IfValidationData{1}
is a table, thenValidationData{2}
can be the name of the response variable in the table. If you want to use the sameResponseVarName
orformula
, you can specifyValidationData{2}
as[]
.Optionally, you can specify
ValidationData{3}
as an mdimensional numeric vector of observation weights or the name of a variable in the tableValidationData{1}
that contains observation weights. The software normalizes the weights with the validation data so that they sum to 1.
If you specify ValidationData
and want to display the validation loss at
the command line, specify a value larger than 0 for Verbose
.
If the software converges for the last solver specified in Solver
, then optimization terminates. Otherwise, the software uses the next solver specified in Solver
.
By default, the software does not detect convergence by monitoring validationdata loss.
BetaTolerance
— Relative tolerance on linear coefficients and bias term
1e4
(default)  nonnegative scalar
Relative tolerance on the linear coefficients and the bias term (intercept), specified as the commaseparated pair consisting of 'BetaTolerance'
and a nonnegative scalar.
Let $${B}_{t}=\left[{\beta}_{t}{}^{\prime}\text{\hspace{0.17em}}\text{\hspace{0.17em}}{b}_{t}\right]$$, that is, the vector of the coefficients and the bias term at optimization iteration t. If $${\Vert \frac{{B}_{t}{B}_{t1}}{{B}_{t}}\Vert}_{2}<\text{BetaTolerance}$$, then optimization terminates.
If you also specify GradientTolerance
, then optimization terminates when the software satisfies either stopping criterion.
If the software converges for the last solver specified in
Solver
, then optimization terminates. Otherwise, the software uses
the next solver specified in Solver
.
Example: 'BetaTolerance',1e6
Data Types: single
 double
GradientTolerance
— Absolute gradient tolerance
1e6
(default)  nonnegative scalar
Absolute gradient tolerance, specified as the commaseparated pair consisting of 'GradientTolerance'
and a nonnegative scalar.
Let $$\nabla {\mathcal{L}}_{t}$$ be the gradient vector of the objective function with respect to the coefficients and bias term at optimization iteration t. If $${\Vert \nabla {\mathcal{L}}_{t}\Vert}_{\infty}=\mathrm{max}\left\nabla {\mathcal{L}}_{t}\right<\text{GradientTolerance}$$, then optimization terminates.
If you also specify BetaTolerance
, then optimization terminates when the
software satisfies either stopping criterion.
If the software converges for the last solver specified in the
software, then optimization terminates. Otherwise, the software uses
the next solver specified in Solver
.
Example: 'GradientTolerance',1e5
Data Types: single
 double
HessianHistorySize
— Size of history buffer for Hessian approximation
15
(default)  positive integer
Size of history buffer for Hessian approximation, specified
as the commaseparated pair consisting of 'HessianHistorySize'
and
a positive integer. That is, at each iteration, the software composes
the Hessian using statistics from the latest HessianHistorySize
iterations.
The software does not support 'HessianHistorySize'
for
SpaRSA.
Example: 'HessianHistorySize',10
Data Types: single
 double
IterationLimit
— Maximal number of optimization iterations
1000
(default)  positive integer
Maximal number of optimization iterations, specified as the
commaseparated pair consisting of 'IterationLimit'
and
a positive integer. IterationLimit
applies to these
values of Solver
: 'bfgs'
, 'lbfgs'
,
and 'sparsa'
.
Example: 'IterationLimit',500
Data Types: single
 double
ValidationData
— Validation data for optimization convergence detection
cell array  table
Validation data for optimization convergence detection, specified as the commaseparated pair
consisting of 'ValidationData'
and a cell array or table.
During optimization, the software periodically estimates the loss of ValidationData
. If the validationdata loss increases, then the software terminates optimization. For more details, see Algorithms. To optimize hyperparameters using crossvalidation, see crossvalidation options such as CrossVal
.
You can specify ValidationData
as a table if you use a table
Tbl
of predictor data that contains the response variable. In this
case, ValidationData
must contain the same predictors and response
contained in Tbl
. The software does not apply weights to observations,
even if Tbl
contains a vector of weights. To specify weights, you must
specify ValidationData
as a cell array.
If you specify ValidationData
as a cell array, then it must have the following format:
ValidationData{1}
must have the same data type and orientation as the predictor data. That is, if you use a predictor matrixX
, thenValidationData{1}
must be an mbyp or pbym full or sparse matrix of predictor data that has the same orientation asX
. The predictor variables in the training dataX
andValidationData{1}
must correspond. Similarly, if you use a predictor tableTbl
of predictor data, thenValidationData{1}
must be a table containing the same predictor variables contained inTbl
. The number of observations inValidationData{1}
and the predictor data can vary.ValidationData{2}
must match the data type and format of the response variable, eitherY
orResponseVarName
. IfValidationData{2}
is an array of class labels, then it must have the same number of elements as the number of observations inValidationData{1}
. The set of all distinct labels ofValidationData{2}
must be a subset of all distinct labels ofY
. IfValidationData{1}
is a table, thenValidationData{2}
can be the name of the response variable in the table. If you want to use the sameResponseVarName
orformula
, you can specifyValidationData{2}
as[]
.Optionally, you can specify
ValidationData{3}
as an mdimensional numeric vector of observation weights or the name of a variable in the tableValidationData{1}
that contains observation weights. The software normalizes the weights with the validation data so that they sum to 1.
If you specify ValidationData
and want to display the validation loss at
the command line, specify a value larger than 0 for Verbose
.
If the software converges for the last solver specified in Solver
, then optimization terminates. Otherwise, the software uses the next solver specified in Solver
.
By default, the software does not detect convergence by monitoring validationdata loss.
OptimizeHyperparameters
— Parameters to optimize
'none'
(default)  'auto'
 'all'
 string array or cell array of eligible parameter names  vector of optimizableVariable
objects
Parameters to optimize, specified as the commaseparated pair consisting of 'OptimizeHyperparameters'
and one of the following:
'none'
— Do not optimize.'auto'
— Use{'Lambda','Learner'}
.'all'
— Optimize all eligible parameters.String array or cell array of eligible parameter names.
Vector of
optimizableVariable
objects, typically the output ofhyperparameters
.
The optimization attempts to minimize the crossvalidation loss (error) for fitclinear
by varying the parameters. For information about crossvalidation loss (albeit in a different context), see Classification Loss. To control the crossvalidation type and other aspects of the optimization, use the HyperparameterOptimizationOptions
namevalue pair.
Note
The values of 'OptimizeHyperparameters'
override any values you specify
using other namevalue arguments. For example, setting
'OptimizeHyperparameters'
to 'auto'
causes
fitclinear
to optimize hyperparameters corresponding to the
'auto'
option and to ignore any specified values for the
hyperparameters.
The eligible parameters for fitclinear
are:
Lambda
—fitclinear
searches among positive values, by default logscaled in the range[1e5/NumObservations,1e5/NumObservations]
.Learner
—fitclinear
searches among'svm'
and'logistic'
.Regularization
—fitclinear
searches among'ridge'
and'lasso'
.When
Regularization
is'ridge'
, the function sets theSolver
value to'lbfgs'
by default.When
Regularization
is'lasso'
, the function sets theSolver
value to'sparsa'
by default.
Set nondefault parameters by passing a vector of optimizableVariable
objects that have nondefault values. For example,
load fisheriris params = hyperparameters('fitclinear',meas,species); params(1).Range = [1e4,1e6];
Pass params
as the value of OptimizeHyperparameters
.
By default, the iterative display appears at the command line,
and plots appear according to the number of hyperparameters in the optimization. For the
optimization and plots, the objective function is the misclassification rate. To control the
iterative display, set the Verbose
field of the
'HyperparameterOptimizationOptions'
namevalue argument. To control the
plots, set the ShowPlots
field of the
'HyperparameterOptimizationOptions'
namevalue argument.
For an example, see Optimize Linear Classifier.
Example: 'OptimizeHyperparameters','auto'
HyperparameterOptimizationOptions
— Options for optimization
structure
Options for optimization, specified as a structure. This argument modifies the effect of the
OptimizeHyperparameters
namevalue argument. All fields in the
structure are optional.
Field Name  Values  Default 

Optimizer 
 'bayesopt' 
AcquisitionFunctionName 
Acquisition functions whose names include
 'expectedimprovementpersecondplus' 
MaxObjectiveEvaluations  Maximum number of objective function evaluations.  30 for 'bayesopt' and
'randomsearch' , and the entire grid for
'gridsearch' 
MaxTime  Time limit, specified as a positive real scalar. The time limit is in seconds, as
measured by  Inf 
NumGridDivisions  For 'gridsearch' , the number of values in each dimension. The value can be
a vector of positive integers giving the number of
values for each dimension, or a scalar that
applies to all dimensions. This field is ignored
for categorical variables.  10 
ShowPlots  Logical value indicating whether to show plots. If true , this field plots
the best observed objective function value against the iteration number. If you
use Bayesian optimization (Optimizer is
'bayesopt' ), then this field also plots the best
estimated objective function value. The best observed objective function values
and best estimated objective function values correspond to the values in the
BestSoFar (observed) and BestSoFar
(estim.) columns of the iterative display, respectively. You can
find these values in the properties ObjectiveMinimumTrace and EstimatedObjectiveMinimumTrace of
Mdl.HyperparameterOptimizationResults . If the problem
includes one or two optimization parameters for Bayesian optimization, then
ShowPlots also plots a model of the objective function
against the parameters.  true 
SaveIntermediateResults  Logical value indicating whether to save results when Optimizer is
'bayesopt' . If
true , this field overwrites a
workspace variable named
'BayesoptResults' at each
iteration. The variable is a BayesianOptimization object.  false 
Verbose  Display at the command line:
For details, see the  1 
UseParallel  Logical value indicating whether to run Bayesian optimization in parallel, which requires Parallel Computing Toolbox™. Due to the nonreproducibility of parallel timing, parallel Bayesian optimization does not necessarily yield reproducible results. For details, see Parallel Bayesian Optimization.  false 
Repartition  Logical value indicating whether to repartition the crossvalidation at every
iteration. If this field is The setting
 false 
Use no more than one of the following three options.  
CVPartition  A cvpartition object, as created by cvpartition  'Kfold',5 if you do not specify a crossvalidation
field 
Holdout  A scalar in the range (0,1) representing the holdout fraction  
Kfold  An integer greater than 1 
Example: 'HyperparameterOptimizationOptions',struct('MaxObjectiveEvaluations',60)
Data Types: struct
Output Arguments
Mdl
— Trained linear classification model
ClassificationLinear
model object  ClassificationPartitionedLinear
crossvalidated model object
Trained linear classification model, returned as a ClassificationLinear
model object
or ClassificationPartitionedLinear
crossvalidated model object.
If you set any of the namevalue pair arguments KFold
, Holdout
, CrossVal
, or CVPartition
, then Mdl
is a ClassificationPartitionedLinear
crossvalidated model object. Otherwise, Mdl
is a ClassificationLinear
model object.
To reference properties of Mdl
, use dot notation. For example, enter Mdl.Beta
in the Command Window to display the vector or matrix of estimated coefficients.
Note
Unlike other classification models, and for economical memory usage, ClassificationLinear
and ClassificationPartitionedLinear
model objects do not store the training data or training process details (for example, convergence history).
FitInfo
— Optimization details
structure array
Optimization details, returned as a structure array.
Fields specify final values or namevalue pair argument specifications,
for example, Objective
is the value of the objective
function when optimization terminates. Rows of multidimensional fields
correspond to values of Lambda
and columns correspond
to values of Solver
.
This table describes some notable fields.
Field  Description  

TerminationStatus 
 
FitTime  Elapsed, wallclock time in seconds  
History  A structure array of optimization information for each
iteration. The field

To access fields, use dot notation.
For example, to access the vector of objective function values for
each iteration, enter FitInfo.History.Objective
.
It is good practice to examine FitInfo
to
assess whether convergence is satisfactory.
HyperparameterOptimizationResults
— Crossvalidation optimization of hyperparameters
BayesianOptimization
object  table of hyperparameters and associated values
Crossvalidation optimization of hyperparameters, returned as a BayesianOptimization
object or a table of hyperparameters and associated
values. The output is nonempty when the value of
'OptimizeHyperparameters'
is not 'none'
. The
output value depends on the Optimizer
field value of the
'HyperparameterOptimizationOptions'
namevalue pair
argument:
Value of Optimizer Field  Value of HyperparameterOptimizationResults 

'bayesopt' (default)  Object of class BayesianOptimization 
'gridsearch' or 'randomsearch'  Table of hyperparameters used, observed objective function values (crossvalidation loss), and rank of observations from lowest (best) to highest (worst) 
More About
Warm Start
A warm start is initial estimates of the beta coefficients and bias term supplied to an optimization routine for quicker convergence.
Alternatives for LowerDimensional Data
Highdimensional linear classification and regression models minimize objective functions relatively quickly, but at the cost of some accuracy, the numericonly predictor variables restriction, and the model must be linear with respect to the parameters. If your predictor data set is low through mediumdimensional, or contains heterogeneous variables, then you should use the appropriate classification or regression fitting function. To help you decide which fitting function is appropriate for your lowdimensional data set, use this table.
Model to Fit  Function  Notable Algorithmic Differences 

SVM 
 
Linear regression 
 
Logistic regression 

Tips
It is a best practice to orient your predictor matrix so that observations correspond to columns and to specify
'ObservationsIn','columns'
. As a result, you can experience a significant reduction in optimizationexecution time.If your predictor data has few observations but many predictor variables, then:
Specify
'PostFitBias',true
.For SGD or ASGD solvers, set
PassLimit
to a positive integer that is greater than 1, for example, 5 or 10. This setting often results in better accuracy.
For SGD and ASGD solvers,
BatchSize
affects the rate of convergence.If
BatchSize
is too small, thenfitclinear
achieves the minimum in many iterations, but computes the gradient per iteration quickly.If
BatchSize
is too large, thenfitclinear
achieves the minimum in fewer iterations, but computes the gradient per iteration slowly.
Large learning rates (see
LearnRate
) speed up convergence to the minimum, but can lead to divergence (that is, overstepping the minimum). Small learning rates ensure convergence to the minimum, but can lead to slow termination.When using lasso penalties, experiment with various values of
TruncationPeriod
. For example, setTruncationPeriod
to1
,10
, and then100
.For efficiency,
fitclinear
does not standardize predictor data. To standardizeX
, enterX = bsxfun(@rdivide,bsxfun(@minus,X,mean(X,2)),std(X,0,2));
The code requires that you orient the predictors and observations as the rows and columns of
X
, respectively. Also, for memoryusage economy, the code replaces the original predictor data the standardized data.
After training a model, you can generate C/C++ code that predicts labels for new data. Generating C/C++ code requires MATLAB Coder™. For details, see Introduction to Code Generation.
Algorithms
If you specify
ValidationData
, then, during objectivefunction optimization:fitclinear
estimates the validation loss ofValidationData
periodically using the current model, and tracks the minimal estimate.When
fitclinear
estimates a validation loss, it compares the estimate to the minimal estimate.When subsequent, validation loss estimates exceed the minimal estimate five times,
fitclinear
terminates optimization.
If you specify
ValidationData
and to implement a crossvalidation routine (CrossVal
,CVPartition
,Holdout
, orKFold
), then:fitclinear
randomly partitionsX
andY
(orTbl
) according to the crossvalidation routine that you choose.fitclinear
trains the model using the trainingdata partition. During objectivefunction optimization,fitclinear
usesValidationData
as another possible way to terminate optimization (for details, see the previous bullet).Once
fitclinear
satisfies a stopping criterion, it constructs a trained model based on the optimized linear coefficients and intercept.If you implement kfold crossvalidation, and
fitclinear
has not exhausted all trainingset folds, thenfitclinear
returns to Step 2 to train using the next trainingset fold.Otherwise,
fitclinear
terminates training, and then returns the crossvalidated model.
You can determine the quality of the crossvalidated model. For example:
To determine the validation loss using the holdout or outoffold data from step 1, pass the crossvalidated model to
kfoldLoss
.To predict observations on the holdout or outoffold data from step 1, pass the crossvalidated model to
kfoldPredict
.
If you specify the
Cost
,Prior
, andWeights
namevalue arguments, the output model object stores the specified values in theCost
,Prior
, andW
properties, respectively. TheCost
property stores the userspecified cost matrix (C) as is. ThePrior
andW
properties store the prior probabilities and observation weights, respectively, after normalization. For model training, the software updates the prior probabilities and observation weights to incorporate the penalties described in the cost matrix. For details, see Misclassification Cost Matrix, Prior Probabilities, and Observation Weights.
References
[1] Hsieh, C. J., K. W. Chang, C. J. Lin, S. S. Keerthi, and S. Sundararajan. “A Dual Coordinate Descent Method for LargeScale Linear SVM.” Proceedings of the 25th International Conference on Machine Learning, ICML ’08, 2001, pp. 408–415.
[2] Langford, J., L. Li, and T. Zhang. “Sparse Online Learning Via Truncated Gradient.” J. Mach. Learn. Res., Vol. 10, 2009, pp. 777–801.
[3] Nocedal, J. and S. J. Wright. Numerical Optimization, 2nd ed., New York: Springer, 2006.
[4] ShalevShwartz, S., Y. Singer, and N. Srebro. “Pegasos: Primal Estimated SubGradient Solver for SVM.” Proceedings of the 24th International Conference on Machine Learning, ICML ’07, 2007, pp. 807–814.
[5] Wright, S. J., R. D. Nowak, and M. A. T. Figueiredo. “Sparse Reconstruction by Separable Approximation.” Trans. Sig. Proc., Vol. 57, No 7, 2009, pp. 2479–2493.
[6] Xiao, Lin. “Dual Averaging Methods for Regularized Stochastic Learning and Online Optimization.” J. Mach. Learn. Res., Vol. 11, 2010, pp. 2543–2596.
[7] Xu, Wei. “Towards Optimal One Pass Large Scale Learning with Averaged Stochastic Gradient Descent.” CoRR, abs/1107.2490, 2011.
Extended Capabilities
Tall Arrays
Calculate with arrays that have more rows than fit in memory.
Usage notes and limitations:
fitclinear
does not support talltable
data.Some namevalue pair arguments have different defaults compared to the default values for the inmemory
fitclinear
function. Supported namevalue pair arguments, and any differences, are:'ObservationsIn'
— Supports only'rows'
.'Lambda'
— Can be'auto'
(default) or a scalar.'Learner'
'Regularization'
— Supports only'ridge'
.'Solver'
— Supports only'lbfgs'
.'FitBias'
— Supports onlytrue
.'Verbose'
— Default value is1
.'Beta'
'Bias'
'ClassNames'
'Cost'
'Prior'
'Weights'
— Value must be a tall array.'HessianHistorySize'
'BetaTolerance'
— Default value is relaxed to1e–3
.'GradientTolerance'
— Default value is relaxed to1e–3
.'IterationLimit'
— Default value is relaxed to20
.'OptimizeHyperparameters'
— Value of'Regularization'
parameter must be'ridge'
.'HyperparameterOptimizationOptions'
— For crossvalidation, tall optimization supports only'Holdout'
validation. By default, the software selects and reserves 20% of the data as holdout validation data, and trains the model using the rest of the data. You can specify a different value for the holdout fraction by using this argument. For example, specify'HyperparameterOptimizationOptions',struct('Holdout',0.3)
to reserve 30% of the data as validation data.
For tall arrays,
fitclinear
implements LBFGS by distributing the calculation of the loss and gradient among different parts of the tall array at each iteration. Other solvers are not available for tall arrays.When initial values for
Beta
andBias
are not given,fitclinear
refines the initial estimates of the parameters by fitting the model locally to parts of the data and combining the coefficients by averaging.
For more information, see Tall Arrays.
Automatic Parallel Support
Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.
To perform parallel hyperparameter optimization, use the
'HyperparameterOptimizationOptions', struct('UseParallel',true)
namevalue argument in the call to the fitclinear
function.
For more information on parallel hyperparameter optimization, see Parallel Bayesian Optimization.
For general information about parallel computing, see Run MATLAB Functions with Automatic Parallel Support (Parallel Computing Toolbox).
Version History
Introduced in R2016aR2022a: Regularization method determines the solver used during hyperparameter optimization
Behavior changed in R2022a
Starting in R2022a, when you specify to optimize hyperparameters and do not
specify a Solver
value, fitclinear
uses
either a Limitedmemory BFGS (LBFGS) solver or a Sparse Reconstruction by Separable
Approximation (SpaRSA) solver, depending on the regularization type selected during
each iteration of the hyperparameter optimization.
When
Regularization
is'ridge'
, the function sets theSolver
value to'lbfgs'
by default.When
Regularization
is'lasso'
, the function sets theSolver
value to'sparsa'
by default.
In previous releases, the default solver selection during hyperparameter
optimization depended on various factors, including the regularization type, learner
type, and number of predictors. For more information, see Solver
.
See Also
fitcsvm
 fitckernel
 fitcecoc
 fitglm
 lassoglm
 testcholdout
 fitrlinear
 templateLinear
 predict
 kfoldPredict
 kfoldLoss
 ClassificationLinear
 ClassificationPartitionedLinear
Abrir ejemplo
Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?
Comando de MATLAB
Ha hecho clic en un enlace que corresponde a este comando de MATLAB:
Ejecute el comando introduciéndolo en la ventana de comandos de MATLAB. Los navegadores web no admiten comandos de 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)