# fitclinear

Fit linear classification model to high-dimensional data

## Syntax

``Mdl = fitclinear(X,Y)``
``Mdl = fitclinear(X,Y,Name,Value)``
``````[Mdl,FitInfo] = fitclinear(___)``````
``````[Mdl,FitInfo,HyperparameterOptimizationResults] = fitclinear(___)``````

## Description

`fitclinear` trains linear classification models for two-class (binary) learning with high-dimensional, 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 high-dimensional data set that includes many predictor variables, train a linear classification model by using `fitclinear`. For low- through medium-dimensional predictor data sets, see Alternatives for Lower-Dimensional Data.

To train a linear classification model for multiclass learning by combining SVM or logistic regression binary classifiers using error-correcting output codes, see `fitcecoc`.

example

````Mdl = fitclinear(X,Y)` returns a trained linear classification model object that contains the results of fitting a binary support vector machine to the predictors `X` and class labels `Y`.```

example

````Mdl = fitclinear(X,Y,Name,Value)` returns a trained linear classification model with additional options specified by one or more `Name,Value` pair arguments. For example, you can specify that the columns of the predictor matrix correspond to observations, implement logistic regression, or specify to cross-validate. It is good practice to cross-validate using the `Kfold` `Name,Value` pair argument. The cross-validation results determine how well the model generalizes.```

example

``````[Mdl,FitInfo] = fitclinear(___)``` also returns optimization details using any of the previous syntaxes. You cannot request `FitInfo` for cross-validated models.```
``````[Mdl,FitInfo,HyperparameterOptimizationResults] = fitclinear(___)``` also returns hyperparameter optimization details when you pass an `OptimizeHyperparameters` name-value pair.```

## Examples

collapse all

Train a binary, linear classification model using support vector machines, dual SGD, and ridge regularization.

`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.1674e-05 Learner: 'svm' Properties, Methods ```
```FitInfo = struct with fields: Lambda: 3.1674e-05 Objective: 5.3783e-04 PassLimit: 10 NumPasses: 10 BatchLimit: [] NumIterations: 238561 GradientNorm: NaN GradientTolerance: 0 RelativeChangeInBeta: 0.0562 BetaTolerance: 1.0000e-04 DeltaGradient: 1.4582 DeltaGradientTolerance: 1 TerminationCode: 0 TerminationStatus: {'Iteration limit exceeded.'} Alpha: [31572x1 double] History: [] FitTime: 0.1603 Solver: {'dual'} ```

`Mdl` is a `ClassificationLinear` model. You can pass `Mdl` and the training or new data to `loss` to inspect the in-sample 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 optimization-termination 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`.

To determine a good lasso-penalty strength for a linear classification model that uses a logistic regression learner, implement 5-fold cross-validation.

`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 logarithmically-spaced regularization strengths from $1{0}^{-6}$ through $1{0}^{-0.5}$.

`Lambda = logspace(-6,-0.5,11);`

Cross-validate 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 `1e-8`.

```X = X'; rng(10); % For reproducibility CVMdl = fitclinear(X,Ystats,'ObservationsIn','columns','KFold',5,... 'Learner','logistic','Solver','sparsa','Regularization','lasso',... 'Lambda',Lambda,'GradientTolerance',1e-8)```
```CVMdl = classreg.learning.partition.ClassificationPartitionedLinear CrossValidatedModel: 'Linear' ResponseName: 'Y' NumObservations: 31572 KFold: 5 Partition: [1×1 cvpartition] ClassNames: [0 1] ScoreTransform: 'none' Properties, Methods ```
`numCLModels = numel(CVMdl.Trained)`
```numCLModels = 5 ```

`CVMdl` is a `ClassificationPartitionedLinear` model. Because `fitclinear` implements 5-fold cross-validation, `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: [34023×11 double] Bias: [-13.2904 -13.2904 -13.2904 -13.2904 -9.9357 -7.0782 -5.4335 -4.5473 -3.4223 -3.1649 -2.9795] Lambda: [1.0000e-06 3.5481e-06 1.2589e-05 4.4668e-05 1.5849e-04 5.6234e-04 0.0020 0.0071 0.0251 0.0891 0.3162] 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 cross-validated classification error.

`ce = kfoldLoss(CVMdl);`

Because there are 11 regularization strengths, `ce` is a 1-by-11 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 cross-validated 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',1e-8); numNZCoeff = sum(Mdl.Beta~=0);```

In the same figure, plot the cross-validated, 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} nonzero-coefficient frequency') xlabel('log_{10} Lambda') title('Test-Sample 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`.

This example shows how to minimize the cross-validation error in a linear classifier using `fitclinear`. The example uses 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 `'expected-improvement-plus'` acquisition function.

```rng default Mdl = fitclinear(X,Ystats,'ObservationsIn','columns','Solver','sparsa',... 'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',... struct('AcquisitionFunctionName','expected-improvement-plus'))```
```|=====================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | Lambda | Learner | | | result | | runtime | (observed) | (estim.) | | | |=====================================================================================================| | 1 | Best | 0.041619 | 4.0257 | 0.041619 | 0.041619 | 0.077903 | logistic | ```
```| 2 | Best | 0.00072849 | 3.8245 | 0.00072849 | 0.0028767 | 2.1405e-09 | logistic | ```
```| 3 | Accept | 0.049221 | 4.6777 | 0.00072849 | 0.00075737 | 0.72101 | svm | ```
```| 4 | Accept | 0.00079184 | 4.299 | 0.00072849 | 0.00074989 | 3.4734e-07 | svm | ```
```| 5 | Accept | 0.00082351 | 3.9102 | 0.00072849 | 0.00072924 | 1.1738e-08 | logistic | ```
```| 6 | Accept | 0.00085519 | 4.2132 | 0.00072849 | 0.00072746 | 2.4529e-09 | svm | ```
```| 7 | Accept | 0.00079184 | 4.1282 | 0.00072849 | 0.00072518 | 3.1854e-08 | svm | ```
```| 8 | Accept | 0.00088686 | 4.4564 | 0.00072849 | 0.00072236 | 3.1717e-10 | svm | ```
```| 9 | Accept | 0.00076017 | 3.7918 | 0.00072849 | 0.00068304 | 3.1837e-10 | logistic | ```
```| 10 | Accept | 0.00079184 | 4.4733 | 0.00072849 | 0.00072853 | 1.1258e-07 | svm | ```
```| 11 | Accept | 0.00076017 | 3.9953 | 0.00072849 | 0.00072144 | 2.1214e-09 | logistic | ```
```| 12 | Accept | 0.00079184 | 6.7875 | 0.00072849 | 0.00075984 | 2.2819e-07 | logistic | ```
```| 13 | Accept | 0.00072849 | 4.2131 | 0.00072849 | 0.00075648 | 6.6161e-08 | logistic | ```
```| 14 | Best | 0.00069682 | 4.3785 | 0.00069682 | 0.00069781 | 7.4324e-08 | logistic | ```
```| 15 | Best | 0.00066515 | 4.3717 | 0.00066515 | 0.00068861 | 7.6994e-08 | logistic | ```
```| 16 | Accept | 0.00076017 | 3.9068 | 0.00066515 | 0.00068881 | 7.0687e-10 | logistic | ```
```| 17 | Accept | 0.00066515 | 4.5966 | 0.00066515 | 0.0006838 | 7.7159e-08 | logistic | ```
```| 18 | Accept | 0.0012353 | 4.6723 | 0.00066515 | 0.00068521 | 0.00083275 | svm | ```
```| 19 | Accept | 0.00076017 | 4.2389 | 0.00066515 | 0.00068508 | 5.0781e-05 | svm | ```
```| 20 | Accept | 0.00085519 | 3.2483 | 0.00066515 | 0.00068527 | 0.00022104 | svm | ```
```|=====================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | Lambda | Learner | | | result | | runtime | (observed) | (estim.) | | | |=====================================================================================================| | 21 | Accept | 0.00082351 | 6.7163 | 0.00066515 | 0.00068569 | 4.5396e-06 | svm | ```
```| 22 | Accept | 0.0010769 | 15.946 | 0.00066515 | 0.00070107 | 5.1931e-06 | logistic | ```
```| 23 | Accept | 0.00095021 | 17.989 | 0.00066515 | 0.00069594 | 1.3051e-06 | logistic | ```
```| 24 | Accept | 0.00085519 | 5.5831 | 0.00066515 | 0.00069625 | 1.6481e-05 | svm | ```
```| 25 | Accept | 0.00085519 | 4.5366 | 0.00066515 | 0.00069643 | 1.157e-06 | svm | ```
```| 26 | Accept | 0.00079184 | 3.6968 | 0.00066515 | 0.00069667 | 1.0016e-08 | svm | ```
```| 27 | Accept | 0.00072849 | 3.9655 | 0.00066515 | 0.00069848 | 4.2234e-08 | logistic | ```
```| 28 | Accept | 0.049221 | 0.49611 | 0.00066515 | 0.00069842 | 3.1608 | logistic | ```
```| 29 | Accept | 0.00085519 | 4.3911 | 0.00066515 | 0.00069855 | 8.5626e-10 | svm | ```
```| 30 | Accept | 0.00076017 | 3.8952 | 0.00066515 | 0.00069837 | 3.1946e-10 | logistic | ```

```__________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 173.5287 seconds. Total objective function evaluation time: 153.4246 Best observed feasible point: Lambda Learner __________ ________ 7.6994e-08 logistic Observed objective function value = 0.00066515 Estimated objective function value = 0.00069859 Function evaluation time = 4.3717 Best estimated feasible point (according to models): Lambda Learner __________ ________ 7.4324e-08 logistic Estimated objective function value = 0.00069837 Estimated function evaluation time = 4.3951 ```
```Mdl = ClassificationLinear ResponseName: 'Y' ClassNames: [0 1] ScoreTransform: 'logit' Beta: [34023×1 double] Bias: -10.1723 Lambda: 7.4324e-08 Learner: 'logistic' Properties, Methods ```

## Input Arguments

collapse all

Predictor data, specified as an n-by-p 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`

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` only supports binary classification. Either `Y` must contain exactly two distinct classes, or you must specify two classes for training using the `'ClassNames'` name-value pair argument. For multiclass learning, see `fitcecoc`.

• If `Y` is a character array, then each element must correspond to one row of the array.

• The length of `Y` and the number of observations in `X` must be equal.

• It is good practice to specify the class order using the `ClassNames` name-value pair argument.

Data Types: `char` | `string` | `cell` | `categorical` | `logical` | `single` | `double`

### Note

`fitclinear` removes missing observations, that is, observations with any of these characteristics:

• `NaN`, empty character vector (`''`), empty string (`""`), `<missing>`, and `<undefined>` elements in the response (`Y` or `ValidationData``{2}`)

• At least one `NaN` value in a predictor observation (row in `X` or `ValidationData{1}`)

• `NaN` value or `0` weight (`Weights` or `ValidationData{3}`)

For memory-usage economy, it is best practice to remove observations containing missing values from your training data manually before training.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'ObservationsIn','columns','Learner','logistic','CrossVal','on'` specifies that the columns of the predictor matrix corresponds to observations, to implement logistic regression, to implement 10-fold cross-validation.

### Note

You cannot use any cross-validation name-value pair argument along with the `'OptimizeHyperparameters'` name-value pair argument. You can modify the cross-validation for `'OptimizeHyperparameters'` only by using the `'HyperparameterOptimizationOptions'` name-value pair argument.

#### Linear Classification Options

collapse all

Regularization term strength, specified as the comma-separated pair consisting of `'Lambda'` and `'auto'`, a nonnegative scalar, or a vector of nonnegative values.

• For `'auto'`, `Lambda` = 1/n.

• If you specify a cross-validation, name-value pair argument (e.g., `CrossVal`), then n is the number of in-fold observations.

• Otherwise, n is the training sample size.

• For a vector of nonnegative values, the software sequentially optimizes the objective function for each distinct value in `Lambda` in ascending order.

• If `Solver` is `'sgd'` or `'asgd'` and `Regularization` is `'lasso'`, then the software does not use the previous coefficient estimates as a warm start for the next optimization iteration. Otherwise, the software uses warm starts.

• If `Regularization` is `'lasso'`, then any coefficient estimate of 0 retains its value when the software optimizes using subsequent values in `Lambda`.

Returns coefficient estimates for all optimization iterations.

Example: `'Lambda',10.^(-(10:-2:2))`

Data Types: `char` | `string` | `double` | `single`

Linear classification model type, specified as the comma-separated 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.

ValueAlgorithmResponse RangeLoss Function
`'svm'`Support vector machiney ∊ {–1,1}; 1 for the positive class and –1 otherwiseHinge: $\ell \left[y,f\left(x\right)\right]=\mathrm{max}\left[0,1-yf\left(x\right)\right]$
`'logistic'`Logistic regressionSame 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'`

Predictor data observation dimension, specified as the comma-separated pair consisting of `'ObservationsIn'` and `'columns'` or `'rows'`.

### Note

If you orient your predictor matrix so that observations correspond to columns and specify `'ObservationsIn','columns'`, then you might experience a significant reduction in optimization-execution time.

Complexity penalty type, specified as the comma-separated 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.

ValueDescription
`'lasso'`Lasso (L1) penalty: $\lambda \sum _{j=1}^{p}|{\beta }_{j}|$
`'ridge'`Ridge (L2) penalty: $\frac{\lambda }{2}\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'`

Objective function minimization technique, specified as the comma-separated 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.

ValueDescriptionRestrictions
`'sgd'`Stochastic gradient descent (SGD) [5][3]
`'asgd'`Average stochastic gradient descent (ASGD) [8]
`'dual'`Dual SGD for SVM [2][7]`Regularization` must be `'ridge'` and `Learner` must be `'svm'`.
`'bfgs'`Broyden-Fletcher-Goldfarb-Shanno quasi-Newton algorithm (BFGS) [4]Inefficient if `X` is very high-dimensional.
`'lbfgs'`Limited-memory BFGS (LBFGS) [4]`Regularization` must be `'ridge'`.
`'sparsa'`Sparse Reconstruction by Separable Approximation (SpaRSA) [6]`Regularization` must be `'lasso'`.

If you specify:

• A ridge penalty (see `Regularization`) and `X` contains 100 or fewer predictor variables, then the default solver is `'bfgs'`.

• An SVM model (see `Learner`), a ridge penalty, and `X` 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'`.

If you specify a string array or cell array of solver names, then the software uses all solvers in the specified order for each `Lambda`.

For more details on which solver to choose, see Tips.

Example: `'Solver',{'sgd','lbfgs'}`

Initial linear coefficient estimates (β), specified as the comma-separated pair consisting of `'Beta'` and a p-dimensional numeric vector or a p-by-L numeric matrix. p is the number of predictor variables in `X` and L is the number of regularization-strength values (for more details, see `Lambda`).

• If you specify a p-dimensional vector, then the software optimizes the objective function L times using this process.

1. The software optimizes using `Beta` as the initial value and the minimum value of `Lambda` as the regularization strength.

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

3. The software implements step 2 until it exhausts all values in `Lambda`.

• If you specify a p-by-L matrix, then the software optimizes the objective function L times. At iteration `j`, the software uses `Beta(:,j)` as the initial value and, after it sorts `Lambda` in ascending order, uses `Lambda(j)` as the regularization strength.

If you set `'Solver','dual'`, then the software ignores `Beta`.

Data Types: `single` | `double`

Initial intercept estimate (b), specified as the comma-separated pair consisting of `'Bias'` and a numeric scalar or an L-dimensional numeric vector. L is the number of regularization-strength values (for more details, see `Lambda`).

• If you specify a scalar, then the software optimizes the objective function L times using this process.

1. The software optimizes using `Bias` as the initial value and the minimum value of `Lambda` as the regularization strength.

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

3. The software implements step 2 until it exhausts all values in `Lambda`.

• If you specify an L-dimensional vector, then the software optimizes the objective function L times. At iteration `j`, the software uses `Bias(j)` as the initial value and, after it sorts `Lambda` in ascending order, uses `Lambda(j)` as the regularization strength.

• By default:

• If `Learner` is `'logistic'`, then let gj be 1 if `Y(j)` is the positive class, and -1 otherwise. `Bias` is the weighted average of the g for training or, for cross-validation, in-fold observations.

• If `Learner` is `'svm'`, then `Bias` is 0.

Data Types: `single` | `double`

Linear model intercept inclusion flag, specified as the comma-separated pair consisting of `'FitBias'` and `true` or `false`.

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

Flag to fit the linear model intercept after optimization, specified as the comma-separated pair consisting of `'PostFitBias'` and `true` or `false`.

ValueDescription
`false`The software estimates the bias term b and the coefficients β during optimization.
`true`

To estimate b, the software:

1. Estimates β and b using the model

2. Estimates classification scores

3. Refits b by placing the threshold on the classification scores that attains maximum accuracy

If you specify `true`, then `FitBias` must be true.

Example: `'PostFitBias',true`

Data Types: `logical`

Verbosity level, specified as the comma-separated pair consisting of `'Verbose'` and a nonnegative integer. `Verbose` controls the amount of diagnostic information `fitclinear` displays at the command line.

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

#### SGD and ASGD Solver Options

collapse all

Mini-batch size, specified as the comma-separated 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 is `10`.

• If `X` is a sparse matrix, then the default value is `max([10,ceil(sqrt(ff))])`, where `ff = numel(X)/nnz(X)` (the fullness factor of `X`).

Example: `'BatchSize',100`

Data Types: `single` | `double`

Learning rate, specified as the comma-separated pair consisting of `'LearnRate'` and a positive scalar. `LearnRate` specifies how many steps to take per iteration. At each iteration, the gradient specifies the direction and magnitude of each step.

• If `Regularization` is `'ridge'`, then `LearnRate` specifies the initial learning rate γ0. The software 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`

Flag to decrease the learning rate when the software detects divergence (that is, over-stepping the minimum), specified as the comma-separated pair consisting of `'OptimizeLearnRate'` and `true` or `false`.

If `OptimizeLearnRate` is `'true'`, then:

1. For the few optimization iterations, the software starts optimization using `LearnRate` as the learning rate.

2. If the value of the objective function increases, then the software restarts and uses half of the current value of the learning rate.

3. The software iterates step 2 until the objective function decreases.

Example: `'OptimizeLearnRate',true`

Data Types: `logical`

Number of mini-batches between lasso truncation runs, specified as the comma-separated 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` mini-batches, the software truncates the estimated coefficient j using

`${\stackrel{^}{\beta }}_{j}^{\ast }=\left\{\begin{array}{ll}{\stackrel{^}{\beta }}_{j}-{u}_{t}\hfill & \text{if}\text{\hspace{0.17em}}{\stackrel{^}{\beta }}_{j}>{u}_{t},\hfill \\ 0\hfill & \text{if}\text{\hspace{0.17em}}|{\stackrel{^}{\beta }}_{j}|\le {u}_{t},\hfill \\ {\stackrel{^}{\beta }}_{j}+{u}_{t}\hfill & \text{if}\text{\hspace{0.17em}}{\stackrel{^}{\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, ${\stackrel{^}{\beta }}_{j}$ is the estimate of coefficient j after processing k mini-batches. ${u}_{t}=k{\gamma }_{t}\lambda .$ γt is the learning rate at iteration t. λ is the value of `Lambda`.

• For ASGD, ${\stackrel{^}{\beta }}_{j}$ is the averaged estimate coefficient j after processing k mini-batches, ${u}_{t}=k\lambda .$

If `Regularization` is `'ridge'`, then the software ignores `TruncationPeriod`.

Example: `'TruncationPeriod',100`

Data Types: `single` | `double`

#### Other Classification Options

collapse all

Names of classes to use for training, specified as the comma-separated pair consisting of `'ClassNames'` and 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 `Y`.

If `ClassNames` is a character array, then each element must correspond to one row of the array.

Use `'ClassNames'` to:

• Order 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 of `Cost` or the column order of classification scores returned by `predict`.

• 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 `Y`.

Example: `'ClassNames',{'b','g'}`

Data Types: `categorical` | `char` | `string` | `logical` | `single` | `double` | `cell`

Misclassification cost, specified as the comma-separated pair consisting of `'Cost'` and a square matrix or structure.

• If you specify the square matrix `cost` (`'Cost',cost`), then `cost(i,j)` is the cost of classifying a point into class `j` if its true class is `i`. 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 of `cost`, use the `ClassNames` name-value 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 as `Y`

• `S.ClassificationCosts`, which contains the cost matrix with rows and columns ordered as in `S.ClassNames`

The default value for `Cost` is ```ones(K) – eye(K)```, where `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 and resets the cost matrix to its default.

Example: `'Cost',[0 2; 1 0]`

Data Types: `single` | `double` | `struct`

Prior probabilities for each class, specified as the comma-separated pair consisting of `'Prior'` and `'empirical'`, `'uniform'`, a numeric vector, or a structure array.

This table summarizes the available options for setting prior probabilities.

ValueDescription
`'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 vectorEach element is a class prior probability. Order the elements according to their order in `Y`. If you specify the order using the `'ClassNames'` name-value pair argument, then order the elements accordingly.
structure array

A structure `S` with two fields:

• `S.ClassNames` contains the class names as a variable of the same type as `Y`.

• `S.ClassProbs` contains a vector of corresponding prior probabilities.

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

Score transformation, specified as the comma-separated pair consisting of `'ScoreTransform'` and a character vector, string scalar, or function handle.

This table summarizes the available character vectors and string scalars.

ValueDescription
`'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 + ex)
`'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 + ex) – 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`

Observation weights, specified as the comma-separated pair consisting of `'Weights'` and a numeric vector of positive values. `fitclinear` weighs the observations in `X` with the corresponding value in `Weights`. The size of `Weights` must equal the number of observations in `X`.

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

By default, `Weights` is `ones(n,1)`, where `n` is the number of observations in `X`.

Data Types: `double` | `single`

#### Cross-Validation Options

collapse all

Cross-validation flag, specified as the comma-separated pair consisting of `'Crossval'` and `'on'` or `'off'`.

If you specify `'on'`, then the software implements 10-fold cross-validation.

To override this cross-validation setting, use one of these name-value pair arguments: `CVPartition`, `Holdout`, or `KFold`. To create a cross-validated model, you can use one cross-validation name-value pair argument at a time only.

Example: `'Crossval','on'`

Cross-validation partition, specified as the comma-separated pair consisting of `'CVPartition'` and a `cvpartition` partition object as created by `cvpartition`. The partition object specifies the type of cross-validation, and also the indexing for training and validation sets.

To create a cross-validated model, you can use one of these four options only: `'``CVPartition``'`, `'``Holdout``'`, or `'``KFold``'`.

Fraction of data used for holdout validation, specified as the comma-separated pair consisting of `'Holdout'` and a scalar value in the range (0,1). If you specify `'Holdout',p`, then the software:

1. Randomly reserves `p*100`% of the data as validation data, and trains the model using the rest of the data

2. Stores the compact, trained model in the `Trained` property of the cross-validated model.

To create a cross-validated model, you can use one of these four options only: `'``CVPartition``'`, `'``Holdout``'`, or `'``KFold``'`.

Example: `'Holdout',0.1`

Data Types: `double` | `single`

Number of folds to use in a cross-validated classifier, specified as the comma-separated pair consisting of `'KFold'` and a positive integer value greater than 1. If you specify, e.g., `'KFold',k`, then the software:

1. Randomly partitions the data into k sets

2. For each set, reserves the set as validation data, and trains the model using the other k – 1 sets

3. Stores the `k` compact, trained models in the cells of a `k`-by-1 cell vector in the `Trained` property of the cross-validated model.

To create a cross-validated model, you can use one of these four options only: `'``CVPartition``'`, `'``Holdout``'`, or `'``KFold``'`.

Example: `'KFold',8`

Data Types: `single` | `double`

#### SGD and ASGD Convergence Controls

collapse all

Maximal number of batches to process, specified as the comma-separated pair consisting of `'BatchLimit'` and a positive integer. When the software processes `BatchLimit` batches, it terminates optimization.

• By default:

• The software passes through the data `PassLimit` times.

• If you specify multiple solvers, and use (A)SGD to get an initial approximation for the next solver, then the default value is `ceil(1e6/BatchSize)`. `BatchSize` is the value of the `'``BatchSize``'` name-value pair argument.

• If you specify `'BatchLimit'` and `'``PassLimit``'`, then the software chooses the argument that results in processing the fewest observations.

• If you specify `'BatchLimit'` but not `'PassLimit'`, then the software processes enough batches to complete up to one entire pass through the data.

Example: `'BatchLimit',100`

Data Types: `single` | `double`

Relative tolerance on the linear coefficients and the bias term (intercept), specified as the comma-separated 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 ${‖\frac{{B}_{t}-{B}_{t-1}}{{B}_{t}}‖}_{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',1e-6`

Data Types: `single` | `double`

Number of batches to process before next convergence check, specified as the comma-separated 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`

Maximal number of passes through the data, specified as the comma-separated 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``'` and `'PassLimit'`, then `fitclinear` chooses the argument that results in processing the fewest observations.

Example: `'PassLimit',5`

Data Types: `single` | `double`

Data for optimization convergence detection, specified as the comma-separated pair consisting of `'ValidationData'` and a cell array.

During optimization, the software periodically estimates the loss of `ValidationData`. If the validation-data loss increases, then the software terminates optimization. For more details, see Algorithms. To optimize hyperparameters using cross-validation, see cross-validation options such as `CrossVal`.

• `ValidationData(1)` must contain an m-by-p or p-by-m full or sparse matrix of predictor data that has the same orientation as `X`. The predictor variables in the training data `X` and `ValidationData{1}` must correspond. The number of observations in both sets can vary.

• `ValidationData{2}` and `Y` must be the same data type. The set of all distinct labels of `ValidationData{2}` must be a subset of all distinct labels of `Y`.

• Optionally, `ValidationData(3)` can contain an m-dimensional numeric vector of observation weights. The software normalizes the weights with the validation data so that they sum to 1.

If you specify `ValidationData`, then, to display 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 validation-data loss.

#### Dual SGD Convergence Controls

collapse all

Relative tolerance on the linear coefficients and the bias term (intercept), specified as the comma-separated 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 ${‖\frac{{B}_{t}-{B}_{t-1}}{{B}_{t}}‖}_{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',1e-6`

Data Types: `single` | `double`

Gradient-difference tolerance between upper and lower pool Karush-Kuhn-Tucker (KKT) complementarity conditions violators, specified as the comma-separated 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 in `Solver`.

Example: `'DeltaGapTolerance',1e-2`

Data Types: `double` | `single`

Number of passes through entire data set to process before next convergence check, specified as the comma-separated pair consisting of `'NumCheckConvergence'` and a positive integer.

Example: `'NumCheckConvergence',100`

Data Types: `single` | `double`

Maximal number of passes through the data, specified as the comma-separated 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`

Data for optimization convergence detection, specified as the comma-separated pair consisting of `'ValidationData'` and a cell array.

During optimization, the software periodically estimates the loss of `ValidationData`. If the validation-data loss increases, then the software terminates optimization. For more details, see Algorithms. To optimize hyperparameters using cross-validation, see cross-validation options such as `CrossVal`.

• `ValidationData(1)` must contain an m-by-p or p-by-m full or sparse matrix of predictor data that has the same orientation as `X`. The predictor variables in the training data `X` and `ValidationData{1}` must correspond. The number of observations in both sets can vary.

• `ValidationData{2}` and `Y` must be the same data type. The set of all distinct labels of `ValidationData{2}` must be a subset of all distinct labels of `Y`.

• Optionally, `ValidationData(3)` can contain an m-dimensional numeric vector of observation weights. The software normalizes the weights with the validation data so that they sum to 1.

If you specify `ValidationData`, then, to display 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 validation-data loss.

#### BFGS, LBFGS, and SpaRSA Convergence Controls

collapse all

Relative tolerance on the linear coefficients and the bias term (intercept), specified as the comma-separated 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 ${‖\frac{{B}_{t}-{B}_{t-1}}{{B}_{t}}‖}_{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',1e-6`

Data Types: `single` | `double`

Absolute gradient tolerance, specified as the comma-separated pair consisting of `'GradientTolerance'` and a nonnegative scalar.

Let $\nabla {ℒ}_{t}$ be the gradient vector of the objective function with respect to the coefficients and bias term at optimization iteration t. If ${‖\nabla {ℒ}_{t}‖}_{\infty }=\mathrm{max}|\nabla {ℒ}_{t}|<\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',1e-5`

Data Types: `single` | `double`

Size of history buffer for Hessian approximation, specified as the comma-separated 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`

Maximal number of optimization iterations, specified as the comma-separated 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`

Data for optimization convergence detection, specified as the comma-separated pair consisting of `'ValidationData'` and a cell array.

During optimization, the software periodically estimates the loss of `ValidationData`. If the validation-data loss increases, then the software terminates optimization. For more details, see Algorithms. To optimize hyperparameters using cross-validation, see cross-validation options such as `CrossVal`.

• `ValidationData(1)` must contain an m-by-p or p-by-m full or sparse matrix of predictor data that has the same orientation as `X`. The predictor variables in the training data `X` and `ValidationData{1}` must correspond. The number of observations in both sets can vary.

• `ValidationData{2}` and `Y` must be the same data type. The set of all distinct labels of `ValidationData{2}` must be a subset of all distinct labels of `Y`.

• Optionally, `ValidationData(3)` can contain an m-dimensional numeric vector of observation weights. The software normalizes the weights with the validation data so that they sum to 1.

If you specify `ValidationData`, then, to display 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 validation-data loss.

#### Hyperparameter Optimization

collapse all

Parameters to optimize, specified as the comma-separated 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 of `hyperparameters`.

The optimization attempts to minimize the cross-validation loss (error) for `fitclinear` by varying the parameters. For information about cross-validation loss (albeit in a different context), see Classification Loss. To control the cross-validation type and other aspects of the optimization, use the `HyperparameterOptimizationOptions` name-value pair.

### Note

`'OptimizeHyperparameters'` values override any values you set using other name-value pair arguments. For example, setting `'OptimizeHyperparameters'` to `'auto'` causes the `'auto'` values to apply.

The eligible parameters for `fitclinear` are:

• `Lambda``fitclinear` searches among positive values, by default log-scaled in the range `[1e-5/NumObservations,1e5/NumObservations]`.

• `Learner``fitclinear` searches among `'svm'` and `'logistic'`.

• `Regularization``fitclinear` searches among `'ridge'` and `'lasso'`.

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 = [1e-4,1e6];```

Pass `params` as the value of `OptimizeHyperparameters`.

By default, 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 log(1 + cross-validation loss) for regression and the misclassification rate for classification. To control the iterative display, set the `Verbose` field of the `'HyperparameterOptimizationOptions'` name-value pair argument. To control the plots, set the `ShowPlots` field of the `'HyperparameterOptimizationOptions'` name-value pair argument.

For an example, see Optimize Linear Classifier.

Example: `'OptimizeHyperparameters','auto'`

Options for optimization, specified as the comma-separated pair consisting of `'HyperparameterOptimizationOptions'` and a structure. This argument modifies the effect of the `OptimizeHyperparameters` name-value pair argument. All fields in the structure are optional.

Field NameValuesDefault
`Optimizer`
• `'bayesopt'` — Use Bayesian optimization. Internally, this setting calls `bayesopt`.

• `'gridsearch'` — Use grid search with `NumGridDivisions` values per dimension.

• `'randomsearch'` — Search at random among `MaxObjectiveEvaluations` points.

`'gridsearch'` searches in a random order, using uniform sampling without replacement from the grid. After optimization, you can get a table in grid order by using the command `sortrows(Mdl.HyperparameterOptimizationResults)`.

`'bayesopt'`
`AcquisitionFunctionName`

• `'expected-improvement-per-second-plus'`

• `'expected-improvement'`

• `'expected-improvement-plus'`

• `'expected-improvement-per-second'`

• `'lower-confidence-bound'`

• `'probability-of-improvement'`

Acquisition functions whose names include `per-second` do not yield reproducible results because the optimization depends on the runtime of the objective function. Acquisition functions whose names include `plus` modify their behavior when they are overexploiting an area. For more details, see Acquisition Function Types.

`'expected-improvement-per-second-plus'`
`MaxObjectiveEvaluations`Maximum number of objective function evaluations.`30` for `'bayesopt'` or `'randomsearch'`, and the entire grid for `'gridsearch'`
`MaxTime`

Time limit, specified as a positive real. The time limit is in seconds, as measured by `tic` and `toc`. Run time can exceed `MaxTime` because `MaxTime` does not interrupt function evaluations.

`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 objective function value against the iteration number. If there are one or two optimization parameters, and if `Optimizer` is `'bayesopt'`, 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 to the command line.

• `0` — No iterative display

• `1` — Iterative display

• `2` — Iterative display with extra information

For details, see the `bayesopt` `Verbose` name-value pair argument.

`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 cross-validation at every iteration. If `false`, the optimizer uses a single partition for the optimization.

`true` usually gives the most robust results because this setting takes partitioning noise into account. However, for good results, `true` requires at least twice as many function evaluations.

`false`
Use no more than one of the following three field names.
`CVPartition`A `cvpartition` object, as created by `cvpartition`.`'Kfold',5` if you do not specify any cross-validation 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

collapse all

Trained linear classification model, returned as a `ClassificationLinear` model object or `ClassificationPartitionedLinear` cross-validated model object.

If you set any of the name-value pair arguments `KFold`, `Holdout`, `CrossVal`, or `CVPartition`, then `Mdl` is a `ClassificationPartitionedLinear` cross-validated 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).

Optimization details, returned as a structure array.

Fields specify final values or name-value 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.

FieldDescription
`TerminationStatus`
• Reason for optimization termination

• Corresponds to a value in `TerminationCode`

`FitTime`Elapsed, wall-clock time in seconds
`History`

A structure array of optimization information for each iteration. The field `Solver` stores solver types using integer coding.

IntegerSolver
1SGD
2ASGD
3Dual SGD for SVM
4LBFGS
5BFGS
6SpaRSA

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.

Cross-validation 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'` name-value pair argument:

Value of `Optimizer` FieldValue of `HyperparameterOptimizationResults`
`'bayesopt'` (default)Object of class `BayesianOptimization`
`'gridsearch'` or `'randomsearch'`Table of hyperparameters used, observed objective function values (cross-validation loss), and rank of observations from lowest (best) to highest (worst)

collapse all

### 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 Lower-Dimensional Data

High-dimensional linear classification and regression models minimize objective functions relatively quickly, but at the cost of some accuracy, the numeric-only predictor variables restriction, and the model must be linear with respect to the parameters. If your predictor data set is low- through medium-dimensional, 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 low-dimensional data set, use this table.

Model to FitFunctionNotable Algorithmic Differences
SVM
• Computes the Gram matrix of the predictor variables, which is convenient for nonlinear kernel transformations.

• Solves dual problem using SMO, ISDA, or L1 minimization via quadratic programming using `quadprog`.

Linear regression
• `lasso` implements cyclic coordinate descent.

Logistic regression
• `fitglm` implements iteratively reweighted least squares.

• `lassoglm` implements cyclic coordinate descent.

## 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 optimization-execution time.

• For better optimization accuracy if `X` is high-dimensional and `Regularization` is `'ridge'`, set any of these combinations for `Solver`:

• `'sgd'`

• `'asgd'`

• `'dual'` if `Learner` is `'svm'`

• `{'sgd','lbfgs'}`

• `{'asgd','lbfgs'}`

• `{'dual','lbfgs'}` if `Learner` is `'svm'`

Other combinations can result in poor optimization accuracy.

• For better optimization accuracy if `X` is moderate- through low-dimensional and `Regularization` is `'ridge'`, set `Solver` to `'bfgs'`.

• If `Regularization` is `'lasso'`, set any of these combinations for `Solver`:

• `'sgd'`

• `'asgd'`

• `'sparsa'`

• `{'sgd','sparsa'}`

• `{'asgd','sparsa'}`

• 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 `X` 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, then `fitclinear` achieves the minimum in many iterations, but computes the gradient per iteration quickly.

• If `BatchSize` is too large, then `fitclinear` 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, over-stepping 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, set `TruncationPeriod` to `1`, `10`, and then `100`.

• For efficiency, `fitclinear` does not standardize predictor data. To standardize `X`, enter

`X = 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 memory-usage 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 objective-function optimization:

• `fitclinear` estimates the validation loss of `ValidationData` 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 cross-validation routine (`CrossVal`, `CVPartition`, `Holdout`, or `KFold`), then:

1. `fitclinear` randomly partitions `X` and `Y` according to the cross-validation routine that you choose.

2. `fitclinear` trains the model using the training-data partition. During objective-function optimization, `fitclinear` uses `ValidationData` as another possible way to terminate optimization (for details, see the previous bullet).

3. Once `fitclinear` satisfies a stopping criterion, it constructs a trained model based on the optimized linear coefficients and intercept.

1. If you implement k-fold cross-validation, and `fitclinear` has not exhausted all training-set folds, then `fitclinear` returns to Step 2 to train using the next training-set fold.

2. Otherwise, `fitclinear` terminates training, and then returns the cross-validated model.

4. You can determine the quality of the cross-validated model. For example:

• To determine the validation loss using the holdout or out-of-fold data from step 1, pass the cross-validated model to `kfoldLoss`.

• To predict observations on the holdout or out-of-fold data from step 1, pass the cross-validated model to `kfoldPredict`.

## References

[1] Hsieh, C. J., K. W. Chang, C. J. Lin, S. S. Keerthi, and S. Sundararajan. “A Dual Coordinate Descent Method for Large-Scale 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] Shalev-Shwartz, S., Y. Singer, and N. Srebro. “Pegasos: Primal Estimated Sub-Gradient 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.