An incremental learning model object completely specifies how functions implement incremental fitting and model performance evaluation. To configure (or prepare) an incremental learning model, create one by calling the object directly, or by converting a traditionally trained model to one of the objects. The following table lists the available objects, conversion functions, and supported learners for the corresponding machine learning objective.
Objective  Creation Approach  Function  Supported Learners 

Binary classification  Call object  incrementalClassificationLinear  Linear SVM Logistic regression 
Convert model 
 
Mutliclass classification  Call object  incrementalClassificationNaiveBayes  Naive Bayes classification with normally distributed predictor variables, conditioned on the class 
Convert model 
 
Regression  Call object  incrementalRegressionLinear  Linear SVM regression Least squares 
Convert model 

The creation approach you choose depends on the information you have and your preferences.
Call object: Create an incremental model to your specifications by calling the object directly. This approach is flexible, enabling you to specify most options to suit your preferences, and the resulting model provides reasonable default values. However:
For linear classification or regression models, an estimation period might be required for your specifications.
For naive Bayes classification models, you must specify the maximum number of classes or all class names expected in the data during incremental learning.
For more details, see Call Object Directly.
Convert model: Convert a traditionally trained model to an incremental learner to initialize a model for incremental learning. incrementalLearner
passes information that the traditionally trained model learned from the data. For linear models, passed information includes including optimized coefficient estimates, data characteristics, and applicable hyperparameter values. For naive Bayes classification models, passed information includes data characteristics, such as all expected class names and fitted moments of the conditional predictor distributions. However, to convert a traditionally trained model, you must have a set of labeled data to which you can fit a model.
When you use incrementalLearner
, you can specify all performance evaluation options and only training, model, and data options that are unknown during conversion. For more details, see Convert Traditionally Trained Model.
Regardless of the incremental model creation approach you use, consider these configurations:
Model performance evaluation settings, such as the performance metrics to measure
For linear models:
Model type, such as SVM
Coefficient initial values
Objective function solver, such as standard stochastic gradient descent (SGD)
Solver hyperparameter values, such as the learning rate of SGD solvers
Unlike when working with other machine learning model objects, you can create an incremental learning model by calling the corresponding object directly, without any knowledge about the data. For linear models, the only information required to create a model directly is the machine learning problem, either classification or regression, whereas naive Bayes classification models require the maximum number of classes expected in the data or all class names. For example, the following code creates a default incremental model for linear regression and a naive Bayes classification model for a data stream containing 5 classes.
MdlLR = incrementalRegressionLinear();
MdlNB = incrementalClassificationNaiveBayes('MaxNumClasses',5)
If you have information about the data to specify, or you want to configure model options or performance evaluation settings, use namevalue arguments when you call the object. (All model properties are readonly; you cannot adjust them using dot notation.) For example, the following pseudocode creates an incremental logistic regression model for binary classification, initializes the linear model coefficients Beta
and bias Bias
(obtained from prior knowledge of the problem), and sets the performance metrics warmup period to 500
observations.
Mdl = incrementalClassificationLinear('Learner','logistic',... 'Beta',Beta,'Bias',Bias,'MetricsWarmupPeriod',500);
The following tables briefly describe notable options for the major aspects of incremental learning. For more details on all options, see incrementalRegressionLinear
, incrementalClassificationLinear
, or incrementalClassificationNaiveBayes
.
This table contains notable model options and data characteristics.
Model Type  Model Options and Data Properties  Description 

Linear classification or regression  'Beta'  Linear coefficients that also serve as initial values for incremental fitting 
'Bias'  Model intercept that also serve as an initial value for incremental fitting  
'Learner'  Model type, such as linear SVM or least squares  
Naive Bayes classification  'Cost'  Misclassification cost matrix 
Classification  'ClassNames'  For classification, the expected class names in the observation labels 
This table contains notable training and solver options and properties.
Model Type  Training and Solver Options and Properties  Description 

Linear classification or regression  'EstimationPeriod'  Pretraining estimation period 
'Solver'  Objective function optimization algorithm  
'Standardize'  Flag to standardize predictor data  
'Lambda'  Ridge penalty, a model hyperparameter that requires tuning for SGD optimization  
'BatchSize'  Minibatch size, an SGD hyperparameter  
'LearnRate'  Learning rate, an SGD hyperparameter  
'Mu'  Readonly property containing predictor variable means  
'Sigma'  Readonly property containing predictor variable standard deviations  
Naive Bayes classification  'DistributionParameters'  Fitted moments of each conditional predictor distribution given each class 
For linear classification and regression models:
The estimation period, specified by the number of observations in EstimationPeriod
, occurs before training begins (see Incremental Learning Periods). During the estimation period, the incremental fitting function fit
or updateMetricsAndFit
computes quantities required for training when they are unknown. For example, if you set 'Standardize',true
, incremental learning functions require predictor means and standard deviations to standardize the predictor data. Consequently, the incremental model requires a positive estimation period (the default is 1000
).
The default solver is the adaptive scaleinvariant solver 'scaleinvariant'
[2], which is hyperparameter free and insensitive to the predictor variable scales; therefore, predictor data standardization is not required. You can specify standard or average SGD instead, 'sgd'
or 'asgd'
. However, SGD is sensitive to predictor variable scales and requires hyperparameter tuning, which can be difficult or impossible to do during incremental learning. If you plan to use an SGD solver, complete these steps:
Obtain labeled data.
Traditionally train a linear classification or regression model by calling fitclinear
or fitrlinear
, respectively. Specify the SGD solver you plan to use for incremental learning, crossvalidate to determine an appropriate set of hyperparameters, and standardize the predictor data.
Train the model on the entire sample using the specified hyperparameter set.
Convert the resulting model to an incremental learner by using incrementalLearner
.
Performance evaluation properties and options enable you to configure how and when model performance is measured by the incremental learning function updateMetrics
or updateMetricsAndFit
. Regardless of the options you choose, first familiarize yourself with the incremental learning periods.
This table contains all performance evaluation options and properties.
Performance Evaluation Options and Properties  Description 

'Metrics'  List of performance metrics or loss functions to measure incrementally 
'MetricsWarmupPeiod'  Number of observations to which the incremental model must be fit before it tracks performance metrics 
'MetricsWindowSize'  Number of observations to use to compute window performance metrics 
'IsWarm'  Readonly property indicating whether the model is warm (measures performance metrics) 
'Metrics'  Readonly property containing a table of tracked cumulative and window metrics 
The metrics specified by the 'Metrics'
namevalue form a table stored in the Metrics
property of the model. For example, if you specify 'Metrics',["Metric1" "Metric2"]
when you create an incremental model Mdl
, the Metrics
property is
>> Mdl.Metrics ans = 2×2 table Cumulative Window __________ ______ Metric1 NaN NaN Metric2 NaN NaN
Specify a positive metrics warmup period when you believe the model is of low quality and needs to be trained before the function updateMetrics
or updateMetricsAndFit
tracks performance metrics in the Metrics
property. In this case, the IsWarm
property is false
, and you must pass the incoming data and model to the incremental fitting function fit
or updateMetricsAndFit
.
When the incremental fitting function processes enough data to satisfy the estimation (for linear models) and metrics warmup periods, the IsWarm
property becomes true
, and you can measure the model performance on incoming data and optionally train the model. For naive Bayes classification models, incremental fitting functions must additionally fit the model to all expected classes to become warm.
When the model is warm, updateMetrics
or updateMetricsAndFit
tracks all specified metrics cumulatively (from the start of the evaluation) and within a window of observations specified by the MetricsWindowSize
property. Cumulative metrics reflect the model performance over the entire incremental learning history; after Performance Evaluation Period 1 starts, cumulative metrics are independent of the evaluation period. Window metrics reflect the model performance only over the specified window size for each performance evaluation period.
incrementalLearner
enables you to initialize an incremental model using information learned from a traditionally trained model. The converted model can generate predictions and it is warm, which means that incremental learning functions can measure model performance metrics from the start of the data stream. In other words, estimation and performance metrics warmup periods are not required for incremental learning.
To convert a traditionally trained model to an incremental learner, pass the model and any options specified by namevalue arguments to incrementalLearner
. For example, the following pseudocode initializes an incremental classification model by using all information that a linear SVM model for binary classification has learned from a batch of data.
Mdl = fitcsvm(X,Y); IncrementalMdl = incrementalLearner(Mdl,Name,Value);
IncrementalMdl
is an incremental learner object associated with the machine learning objective.
Ease of incremental model creation and initialization is offset by decreased flexibility. The software assumes that fitted parameters, hyperparameter values, and data characteristics learned during traditional training are appropriate for incremental learning. Therefore, you cannot set corresponding learned or tuned options when you call incrementalLearner
. This table lists notable readonly properties of IncrementalMdl
that incrementalLearner
transfers from Mdl
, or that the function infers from other values.
Model Type  Property  Description 

All  NumPredictors  Number of predictor variables. For models that dummycode categorical predictor variables, NumPredictors is numel(Mdl.ExpandedPredictorNames) , and predictor variables expected during incremental learning correspond to the names. For more details, see Dummy Variables. 
Classification  ClassNames  All class labels expected during incremental learning 
Prior  Prior class distribution  
ScoreTransform  A function to apply to classification scores. For example, if you configure an SVM model to compute posterior class probabilities,  
Regression  Epsilon  For an SVM learner, half the width of the epsiloninsensitive band 
ResponseTransform  A function to apply to predicted responses  
Linear classification or regression  Beta  Linear model coefficients 
Bias  Model intercept  
Learner  Linear model type  
Mu  For an SVM model object, the predictor variable means  
Sigma  For an SVM model object, the predictor variable standard deviations  
Naive Bayes classification  DistributionNames  A NumPredictors length cell vector with 'normal' in each cell. If you convert a naive Bayes classification model containing at least one nonnormal predictor, incrementalLearner issues an error. 
DistributionParameters  Fitted moments of each conditional predictor distribution given each class 
Note
The NumTrainingObservations
property of IncrementalMdl
does not include the observations used to train Mdl
.
If you specify 'Standardize',true
when you train Mdl
, IncrementalMdl
is configured to standardize predictors during incremental learning by default.
The following conditions apply when you convert a linear classification or regression model (ClassificationLinear
and RegressionLinear
, respectively):
Incremental fitting functions support ridge (L2) regularization only.
Incremental fitting functions support the specification of only one regularization value. Therefore, if you specify a regularization path (vector of regularization values) when you call fitclinear
or fitrlinear
, choose the model associated with one penalty by passing it to selectModels
.
If you solve the objective function by using standard or average SGD ('sgd'
or 'asgd'
for the 'Solver'
namevalue argument), these conditions apply when you call incrementalLearner
:
incrementalLearner
transfers the solver used to optimize Mdl
to IncrementalMdl
.
You can specify the adaptive scaleinvariant solver 'scaleinvariant'
instead, but you cannot specify a different SGD solver.
If you do not specify the adaptive scaleinvariant solver, incrementalLearner
transfers model and solver hyperparameter values to the incremental model object, such as the learning rate LearnRate
, minibatch size BatchSize
, and ridge penalty Lambda
. You cannot modify the transferred properties.
If you require more flexibility when you create an incremental model, you can call the object directly and initialize the model by individually setting learned information using namevalue arguments. The following pseudocode show two examples:
Initialize an incremental classification model from the coefficients and class names learned by fitting a linear SVM model for binary classification to a batch of data Xc
and Yc
.
Initialize an incremental regression model from the coefficients learned by fitting a linear model to a batch of data Xr
and Yr
.
% Linear Classification Mdl = fitcsvm(Xc,Yc); IncrementalMdl = incrementalClassificationLinear('Beta',Mdl.Beta,... 'Bias',Mdl.Bias,'ClassNames',Mdl.ClassNames); % Linear Regression Mdl = fitlm(Xr,Yr); Bias = Mdl.Coefficients.Estimate(1); Beta = Mdl.Coefficients.Estimate(2:end); IncrementalMdl = incrementalRegressionLinear('Learner','leastsquares',... 'Bias',Bias,'Beta',Beta);
For naive Bayes classification models, you cannot specify the moments of the conditional probability distribution of each predictor variable DistributionParameters
; they must be fitted to data, by fit
or fitcnb