multiclass model for support vector machines (svms) and other classifiers

description

classificationecoc is an error-correcting output codes (ecoc) classifier for multiclass learning, where the classifier consists of multiple binary learners such as support vector machines (svms). trained classificationecoc classifiers store training data, parameter values, prior probabilities, and coding matrices. use these classifiers to perform tasks such as predicting labels or posterior probabilities for new data (see predict).

creation

create a classificationecoc object by using fitcecoc.

if you specify linear or kernel binary learners without specifying cross-validation options, then fitcecoc returns a compactclassificationecoc object instead.

properties

after you create a classificationecoc model object, you can use dot notation to access its properties. for an example, see train multiclass model using svm learners.

ecoc properties

`binarylearners` — trained binary learners
cell vector of model objects

trained binary learners, specified as a cell vector of model objects. the number of binary learners depends on the number of classes in y and the coding design.

the software trains binarylearner{j} according to the binary problem specified by codingmatrix(:,j). for example, for multiclass learning using svm learners, each element of binarylearners is a compactclassificationsvm classifier.

data types: cell

`binaryloss` — binary learner loss function
`'binodeviance'` | `'exponential'` | `'hamming'` | `'hinge'` | `'linear'` | `'logit'` | `'quadratic'`

binary learner loss function, specified as a character vector representing the loss function name.

this table identifies the default binaryloss value, which depends on the score ranges returned by the binary learners.

assumption	default value
all binary learners are any of the following: classification decision trees discriminant analysis models k-nearest neighbor models linear or kernel classification models of logistic regression learners naive bayes models	`'quadratic'`
all binary learners are svms or linear or kernel classification models of svm learners.	`'hinge'`
all binary learners are ensembles trained by `adaboostm1` or `gentleboost`.	`'exponential'`
all binary learners are ensembles trained by `logitboost`.	`'binodeviance'`
you specify to predict class posterior probabilities by setting `'fitposterior',true` in `fitcecoc`.	`'quadratic'`
binary learners are heterogeneous and use different loss functions.	`'hamming'`

to check the default value, use dot notation to display the binaryloss property of the trained model at the command line.

to potentially increase accuracy, specify a binary loss function other than the default during a prediction or loss computation by using the binaryloss name-value argument of predict or . for more information, see binary loss.

data types: char

`binaryy` — binary learner class labels
numeric matrix

binary learner class labels, specified as a numeric matrix. binaryy is a numobservations-by-l matrix, where l is the number of binary learners (length(mdl.binarylearners)).

elements of binaryy are –1, 0, or 1, and the value corresponds to a dichotomous class assignment. this table describes how learner j assigns observation k to a dichotomous class corresponding to the value of binaryy(k,j).

value	dichotomous class assignment
`–1`	learner `j` assigns observation `k` to a negative class.
`0`	before training, learner `j` removes observation `k` from the data set.
`1`	learner `j` assigns observation `k` to a positive class.

data types: double

`binedges` — bin edges for numeric predictors
cell array of numeric vectors | `[]`

this property is read-only.

bin edges for numeric predictors, specified as a cell array of p numeric vectors, where p is the number of predictors. each vector includes the bin edges for a numeric predictor. the element in the cell array for a categorical predictor is empty because the software does not bin categorical predictors.

the software bins numeric predictors only if you specify the 'numbins' name-value argument as a positive integer scalar when training a model with tree learners. the binedges property is empty if the 'numbins' value is empty (default).

you can reproduce the binned predictor data xbinned by using the binedges property of the trained model mdl.

x = mdl.x; % predictor data
xbinned = zeros(size(x));
edges = mdl.binedges;
% find indices of binned predictors.
idxnumeric = find(~cellfun(@isempty,edges));
if iscolumn(idxnumeric)
    idxnumeric = idxnumeric';
end
for j = idxnumeric 
    x = x(:,j);
    % convert x to array if x is a table.
    if istable(x) 
        x = table2array(x);
    end
    % group x into bins by using the  function.
    xbinned = discretize(x,[-inf; edges{j}; inf]); 
    xbinned(:,j) = xbinned;
end

xbinned contains the bin indices, ranging from 1 to the number of bins, for numeric predictors. xbinned values are 0 for categorical predictors. if x contains nans, then the corresponding xbinned values are nans.

data types: cell

`codingmatrix` — class assignment codes
numeric matrix

class assignment codes for the binary learners, specified as a numeric matrix. codingmatrix is a k-by-l matrix, where k is the number of classes and l is the number of binary learners.

the elements of codingmatrix are –1, 0, and 1, and the values correspond to dichotomous class assignments. this table describes how learner j assigns observations in class i to a dichotomous class corresponding to the value of codingmatrix(i,j).

value	dichotomous class assignment
`–1`	learner `j` assigns observations in class `i` to a negative class.
`0`	before training, learner `j` removes observations in class `i` from the data set.
`1`	learner `j` assigns observations in class `i` to a positive class.

data types: double | single | int8 | int16 | int32 | int64

`codingname` — coding design name
character vector

coding design name, specified as a character vector. for more details, see coding design.

data types: char

`learnerweights` — binary learner weights
numeric row vector

binary learner weights, specified as a numeric row vector. the length of learnerweights is equal to the number of binary learners (length(mdl.binarylearners)).

learnerweights(j) is the sum of the observation weights that binary learner j uses to train its classifier.

the software uses learnerweights to fit posterior probabilities by minimizing the kullback-leibler divergence. the software ignores learnerweights when it uses the quadratic programming method of estimating posterior probabilities.

data types: double | single

other classification properties

`categoricalpredictors` — categorical predictor indices
vector of positive integers | `[]`

categorical predictor indices, specified as a vector of positive integers. categoricalpredictors contains index values indicating that the corresponding predictors are categorical. the index values are between 1 and p, where p is the number of predictors used to train the model. if none of the predictors are categorical, then this property is empty ([]).

data types: single | double

`classnames` — unique class labels
categorical array | character array | logical vector | numeric vector | cell array of character vectors

unique class labels used in training, specified as a categorical or character array, logical or numeric vector, or cell array of character vectors. classnames has the same data type as the class labels y. (the software treats string arrays as cell arrays of character vectors.) classnames also determines the class order.

`cost` — misclassification costs
square numeric matrix

this property is read-only.

misclassification costs, specified as a square numeric matrix. cost has k rows and columns, where k is the number of classes.

cost(i,j) is the cost of classifying a point into class j if its true class is i. the order of the rows and columns of cost corresponds to the order of the classes in classnames.

data types: double

`expandedpredictornames` — expanded predictor names
cell array of character vectors

expanded predictor names, specified as a cell array of character vectors.

if the model uses encoding for categorical variables, then expandedpredictornames includes the names that describe the expanded variables. otherwise, expandedpredictornames is the same as predictornames.

data types: cell

`modelparameters` — parameter values
object

parameter values, such as the name-value pair argument values, used to train the ecoc classifier, specified as an object. modelparameters does not contain estimated parameters.

access properties of modelparameters using dot notation. for example, list the templates containing parameters of the binary learners by using mdl.modelparameters.binarylearner.

`numobservations` — number of observations
positive numeric scalar

number of observations in the training data, specified as a positive numeric scalar.

data types: double

`predictornames` — predictor names
cell array of character vectors

predictor names in order of their appearance in the predictor data x, specified as a cell array of character vectors. the length of predictornames is equal to the number of columns in x.

data types: cell

`prior` — prior class probabilities
numeric vector

this property is read-only.

prior class probabilities, specified as a numeric vector. prior has as many elements as the number of classes in classnames, and the order of the elements corresponds to the order of the classes in classnames.

fitcecoc incorporates misclassification costs differently among different types of binary learners.

data types: double

`responsename` — response variable name
character vector

response variable name, specified as a character vector.

data types: char

`rowsused` — rows used in fitting
`[]` (default) | logical vector

rows of the original training data used in fitting the classificationecoc model, specified as a logical vector. this property is empty if all rows are used.

data types: logical

`scoretransform` — score transformation function to apply to predicted scores
`'none'`

this property is read-only.

score transformation function to apply to the predicted scores, specified as 'none'. an ecoc model does not support score transformation.

`w` — observation weights
numeric vector

observation weights used to train the ecoc classifier, specified as a numeric vector. w has numobservations elements.

the software normalizes the weights used for training so that sum(w,'omitnan') is 1.

data types: single | double

`x` — unstandardized predictor data
numeric matrix | table

unstandardized predictor data used to train the ecoc classifier, specified as a numeric matrix or table.

each row of x corresponds to one observation, and each column corresponds to one variable.

data types: single | double | table

`y` — observed class labels
categorical array | character array | logical vector | numeric vector | cell array of character vectors

observed class labels used to train the ecoc classifier, specified as a categorical or character array, logical or numeric vector, or cell array of character vectors. y has numobservations elements and has the same data type as the input argument y of fitcecoc. (the software treats string arrays as cell arrays of character vectors.)

each row of y represents the observed classification of the corresponding row of x.

hyperparameter optimization properties

`hyperparameteroptimizationresults` — cross-validation optimization of hyperparameters
`bayesianoptimization` object | table

this property is read-only.

cross-validation optimization of hyperparameters, specified as a bayesianoptimization object or a table of hyperparameters and associated values. this property is nonempty if the 'optimizehyperparameters' name-value pair argument is nonempty when you create the model. the value of hyperparameteroptimizationresults depends on the setting of the optimizer field in the hyperparameteroptimizationoptions structure when you create the model.

value of `optimizer` field	value 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)

object functions

	reduce size of multiclass error-correcting output codes (ecoc) model
	compare accuracies of two classification models using new data
	cross-validate multiclass error-correcting output codes (ecoc) model
	discard support vectors of linear svm binary learners in ecoc model
	classification edge for multiclass error-correcting output codes (ecoc) model
	gather properties of statistics and machine learning toolbox object from gpu
	convert multiclass error-correcting output codes (ecoc) model to incremental learner
	classification loss for multiclass error-correcting output codes (ecoc) model
	classification margins for multiclass error-correcting output codes (ecoc) model
`partialdependence`	compute partial dependence
`plotpartialdependence`	create partial dependence plot (pdp) and individual conditional expectation (ice) plots
`predict`	classify observations using multiclass error-correcting output codes (ecoc) model
	resubstitution classification edge for multiclass error-correcting output codes (ecoc) model
`lime`	local interpretable model-agnostic explanations (lime)
	resubstitution classification loss for multiclass error-correcting output codes (ecoc) model
	resubstitution classification margins for multiclass error-correcting output codes (ecoc) model
	classify observations in multiclass error-correcting output codes (ecoc) model
`shapley`	shapley values
	compare accuracies of two classification models by repeated cross-validation

examples

train multiclass model using svm learners

train a multiclass error-correcting output codes (ecoc) model using support vector machine (svm) binary learners.

load fisher's iris data set. specify the predictor data x and the response data y.

load fisheriris
x = meas;
y = species;

train a multiclass ecoc model using the default options.

mdl = fitcecoc(x,y)

mdl = 
  classificationecoc
             responsename: 'y'
    categoricalpredictors: []
               classnames: {'setosa'  'versicolor'  'virginica'}
           scoretransform: 'none'
           binarylearners: {3x1 cell}
               codingname: 'onevsone'
  properties, methods

mdl is a classificationecoc model. by default, fitcecoc uses svm binary learners and a one-versus-one coding design. you can access mdl properties using dot notation.

display the class names and the coding design matrix.

mdl.classnames

ans = 3x1 cell
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

codingmat = mdl.codingmatrix

codingmat = 3×3
     1     1     0
    -1     0     1
     0    -1    -1

a one-versus-one coding design for three classes yields three binary learners. the columns of codingmat correspond to the learners, and the rows correspond to the classes. the class order is the same as the order in mdl.classnames. for example, codingmat(:,1) is [1; –1; 0] and indicates that the software trains the first svm binary learner using all observations classified as 'setosa' and 'versicolor'. because 'setosa' corresponds to 1, it is the positive class; 'versicolor' corresponds to –1, so it is the negative class.

you can access each binary learner using cell indexing and dot notation.

mdl.binarylearners{1}   % the first binary learner

ans = 
  compactclassificationsvm
             responsename: 'y'
    categoricalpredictors: []
               classnames: [-1 1]
           scoretransform: 'none'
                     beta: [4x1 double]
                     bias: 1.4505
         kernelparameters: [1x1 struct]
  properties, methods

compute the resubstitution classification error.

error = resubloss(mdl)

error = 0.0067

the classification error on the training data is small, but the classifier might be an overfitted model. you can cross-validate the classifier using crossval and compute the cross-validation classification error instead.

inspect binary learner properties of ecoc classifier

train an ecoc classifier using svm binary learners. then, access properties of the binary learners, such as estimated parameters, by using dot notation.

load fisher's iris data set. specify the petal dimensions as the predictors and the species names as the response.

load fisheriris
x = meas(:,3:4);
y = species;

train an ecoc classifier using svm binary learners and the default coding design (one-versus-one). standardize the predictors and save the support vectors.

t = templatesvm('standardize',true,'savesupportvectors',true);
predictornames = {'petallength','petalwidth'};
responsename = 'irisspecies';
classnames = {'setosa','versicolor','virginica'}; % specify class order
mdl = fitcecoc(x,y,'learners',t,'responsename',responsename,...
    'predictornames',predictornames,'classnames',classnames)

mdl = 
  classificationecoc
           predictornames: {'petallength'  'petalwidth'}
             responsename: 'irisspecies'
    categoricalpredictors: []
               classnames: {'setosa'  'versicolor'  'virginica'}
           scoretransform: 'none'
           binarylearners: {3x1 cell}
               codingname: 'onevsone'
  properties, methods

t is a template object that contains options for svm classification. the function fitcecoc uses default values for the empty ([]) properties. mdl is a classificationecoc classifier. you can access properties of mdl using dot notation.

display the class names and the coding design matrix.

mdl.classnames

ans = 3x1 cell
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

mdl.codingmatrix

ans = 3×3
     1     1     0
    -1     0     1
     0    -1    -1

the columns correspond to svm binary learners, and the rows correspond to the distinct classes. the row order is the same as the order in the classnames property of mdl. for each column:

1 indicates that fitcecoc trains the svm using observations in the corresponding class as members of the positive group.
–1 indicates that fitcecoc trains the svm using observations in the corresponding class as members of the negative group.
0 indicates that the svm does not use observations in the corresponding class.

in the first svm, for example, fitcecoc assigns all observations to 'setosa' or 'versicolor', but not 'virginica'.

access properties of the svms using cell subscripting and dot notation. store the standardized support vectors of each svm. unstandardize the support vectors.

l = size(mdl.codingmatrix,2); % number of svms
sv = cell(l,1); % preallocate for support vector indices
for j = 1:l
    svm = mdl.binarylearners{j};
    sv{j} = svm.supportvectors;
    sv{j} = sv{j}.*svm.sigma   svm.mu;
end

sv is a cell array of matrices containing the unstandardized support vectors for the svms.

plot the data, and identify the support vectors.

figure
gscatter(x(:,1),x(:,2),y);
hold on
markers = {'ko','ro','bo'}; % should be of length l
for j = 1:l
    svs = sv{j};
    plot(svs(:,1),svs(:,2),markers{j},...
        'markersize',10   (j - 1)*3);
end
title('fisher''s iris -- ecoc support vectors')
xlabel(predictornames{1})
ylabel(predictornames{2})
legend([classnames,{'support vectors - svm 1',...
    'support vectors - svm 2','support vectors - svm 3'}],...
    'location','best')
hold off

figure contains an axes object. the axes object with title fisher's iris -- ecoc support vectors, xlabel petallength, ylabel petalwidth contains 6 objects of type line. one or more of the lines displays its values using only markers these objects represent setosa, versicolor, virginica, support vectors - svm 1, support vectors - svm 2, support vectors - svm 3.

you can pass mdl to these functions:

predict, to classify new observations
resubloss, to estimate the classification error on the training data
crossval, to perform 10-fold cross-validation

cross-validate ecoc classifier

cross-validate an ecoc classifier with svm binary learners, and estimate the generalized classification error.

load fisher's iris data set. specify the predictor data x and the response data y.

load fisheriris
x = meas;
y = species;
rng(1); % for reproducibility

create an svm template, and standardize the predictors.

t = templatesvm('standardize',true)

t = 
fit template for classification svm.
                     alpha: [0x1 double]
             boxconstraint: []
                 cachesize: []
             cachingmethod: ''
                clipalphas: []
    deltagradienttolerance: []
                   epsilon: []
              gaptolerance: []
              kkttolerance: []
            iterationlimit: []
            kernelfunction: ''
               kernelscale: []
              kerneloffset: []
     kernelpolynomialorder: []
                  numprint: []
                        nu: []
           outlierfraction: []
          removeduplicates: []
           shrinkageperiod: []
                    solver: ''
           standardizedata: 1
        savesupportvectors: []
            verbositylevel: []
                   version: 2
                    method: 'svm'
                      type: 'classification'

t is an svm template. most of the template object properties are empty. when training the ecoc classifier, the software sets the applicable properties to their default values.

train the ecoc classifier, and specify the class order.

mdl = fitcecoc(x,y,'learners',t,...
    'classnames',{'setosa','versicolor','virginica'});

mdl is a classificationecoc classifier. you can access its properties using dot notation.

cross-validate mdl using 10-fold cross-validation.

cvmdl = crossval(mdl);

cvmdl is a classificationpartitionedecoc cross-validated ecoc classifier.

estimate the generalized classification error.

generror = kfoldloss(cvmdl)

generror = 0.0400

the generalized classification error is 4%, which indicates that the ecoc classifier generalizes fairly well.

more about

error-correcting output codes model

an error-correcting output codes (ecoc) model reduces the problem of classification with three or more classes to a set of binary classification problems.

ecoc classification requires a coding design, which determines the classes that the binary learners train on, and a decoding scheme, which determines how the results (predictions) of the binary classifiers are aggregated.

assume the following:

the classification problem has three classes.
the coding design is one-versus-one. for three classes, this coding design is

$\begin{matrix} learner 1 & learner 2 & learner 3 \\ class 1 & 1 & 1 & 0 \\ class 2 & - 1 & 0 & 1 \\ class 3 & 0 & - 1 & - 1 \end{matrix}$
you can specify a different coding design by using the coding name-value argument when you create a classification model.
the model determines the predicted class by using the loss-weighted decoding scheme with the binary loss function g. the software also supports the loss-based decoding scheme. you can specify the decoding scheme and binary loss function by using the decoding and binaryloss name-value arguments, respectively, when you call object functions, such as predict, loss, margin, edge, and so on.

the ecoc algorithm follows these steps.

learner 1 trains on observations in class 1 or class 2, and treats class 1 as the positive class and class 2 as the negative class. the other learners are trained similarly.
let m be the coding design matrix with elements m_kl, and s_l be the predicted classification score for the positive class of learner l. the algorithm assigns a new observation to the class ( $\hat{k}$ ) that minimizes the aggregation of the losses for the b binary learners.

$\hat{k} = \underset{k}{argmin} \frac{\sum_{l = 1}^{b} | m_{k l} | g (m_{k l}, s_{l})}{\sum_{l = 1}^{b} | m_{k l} |} .$

ecoc models can improve classification accuracy, compared to other multiclass models [1].

coding design

the coding design is a matrix whose elements direct which classes are trained by each binary learner, that is, how the multiclass problem is reduced to a series of binary problems.

each row of the coding design corresponds to a distinct class, and each column corresponds to a binary learner. in a ternary coding design, for a particular column (or binary learner):

a row containing 1 directs the binary learner to group all observations in the corresponding class into a positive class.
a row containing –1 directs the binary learner to group all observations in the corresponding class into a negative class.
a row containing 0 directs the binary learner to ignore all observations in the corresponding class.

coding design matrices with large, minimal, pairwise row distances based on the hamming measure are optimal. for details on the pairwise row distance, see random coding design matrices and [2].

this table describes popular coding designs.

coding design	description	number of learners	minimal pairwise row distance
one-versus-all (ova)	for each binary learner, one class is positive and the rest are negative. this design exhausts all combinations of positive class assignments.	k	2
one-versus-one (ovo)	for each binary learner, one class is positive, one class is negative, and the rest are ignored. this design exhausts all combinations of class pair assignments.	k(k – 1)/2	1
binary complete	this design partitions the classes into all binary combinations, and does not ignore any classes. that is, all class assignments are `–1` and `1` with at least one positive class and one negative class in the assignment for each binary learner.	2^{k – 1} – 1	2^{k – 2}
ternary complete	this design partitions the classes into all ternary combinations. that is, all class assignments are `0`, `–1`, and `1` with at least one positive class and one negative class in the assignment for each binary learner.	(3^k – 2^{k 1} 1)/2	3^{k – 2}
ordinal	for the first binary learner, the first class is negative and the rest are positive. for the second binary learner, the first two classes are negative and the rest are positive, and so on.	k – 1	1
dense random	for each binary learner, the software randomly assigns classes into positive or negative classes, with at least one of each type. for more details, see random coding design matrices.	random, but approximately 10 log₂k	variable
sparse random	for each binary learner, the software randomly assigns classes as positive or negative with probability 0.25 for each, and ignores classes with probability 0.5. for more details, see random coding design matrices.	random, but approximately 15 log₂k	variable

this plot compares the number of binary learners for the coding designs with an increasing number of classes (k).

algorithms

random coding design matrices

for a given number of classes k, the software generates random coding design matrices as follows.

the software generates one of these matrices:
1. dense random — the software assigns 1 or –1 with equal probability to each element of the k-by-l_d coding design matrix, where $l_{d} \approx ⌈ 10 \log_{2} k ⌉$ .
2. sparse random — the software assigns 1 to each element of the k-by-l_s coding design matrix with probability 0.25, –1 with probability 0.25, and 0 with probability 0.5, where $l_{s} \approx ⌈ 15 \log_{2} k ⌉$ .
if a column does not contain at least one 1 and one –1, then the software removes that column.
for distinct columns u and v, if u = v or u = –v, then the software removes v from the coding design matrix.

the software randomly generates 10,000 matrices by default, and retains the matrix with the largest, minimal, pairwise row distance based on the hamming measure ([2]) given by

$δ (k_{1}, k_{2}) = 0.5 \sum_{l = 1}^{l} | m_{k_{1} l} | | m_{k_{2} l} | | m_{k_{1} l} - m_{k_{2} l} |,$

where m_{k_jl} is an element of coding design matrix j.

support vector storage

by default and for efficiency, fitcecoc empties the alpha, supportvectorlabels, and supportvectors properties for all linear svm binary learners. fitcecoc lists beta, rather than alpha, in the model display.

to store alpha, supportvectorlabels, and supportvectors, pass a linear svm template that specifies storing support vectors to fitcecoc. for example, enter:

t = templatesvm('savesupportvectors',true)
mdl = fitcecoc(x,y,'learners',t);

you can remove the support vectors and related values by passing the resulting classificationecoc model to discardsupportvectors.

alternative functionality

you can use these alternative algorithms to train a multiclass model:

classification ensembles—see fitcensemble and
classification trees—see fitctree and
discriminant analysis classifiers—see fitcdiscr and
k-nearest neighbor classifiers—see fitcknn and classificationknn
naive bayes classifiers—see fitcnb and

references

[1] fürnkranz, johannes. “round robin classification.” j. mach. learn. res., vol. 2, 2002, pp. 721–747.

[2] escalera, s., o. pujol, and p. radeva. “separability of ternary codes for sparse designs of error-correcting output codes.” pattern recog. lett., vol. 30, issue 3, 2009, pp. 285–297.

extended capabilities

c/c code generation
generate c and c code using matlab® coder™.

usage notes and limitations:

the predict and update functions support code generation.
when you train an ecoc model by using fitcecoc, the following restrictions apply.
- all binary learners must be svm classifiers or linear classification models. for the learners name-value argument, you can specify:
  - 'svm' or 'linear'
  - an svm template object or a cell array of such objects (see templatesvm)
  - a linear classification model template object or a cell array of such objects (see templatelinear)
- code generation limitations for the binary learners used in the ecoc classifier also apply to the ecoc classifier. for linear classification models, you can specify only one regularization strength—'auto' or a nonnegative scalar for the lambda name-value argument.
- for code generation with a coder configurer, the following additional restrictions apply.
  - if you use a cell array of svm template objects, the value of standardize for svm learners must be consistent. for example, if you specify 'standardize',true for one svm learner, you must specify the same value for all svm learners.
  - if you use a cell array of svm template objects, and you use one svm learner with a linear kernel ('kernelfunction','linear') and another with a different type of kernel function, then you must specify 'savesupportvectors',true for the learner with a linear kernel.
  - categorical predictors (logical, categorical, char, string, or cell) are not supported. you cannot use the categoricalpredictors name-value argument. to include categorical predictors in a model, preprocess them by using before fitting the model.
  - class labels with the categorical data type are not supported. both the class label value in the training data (tbl or y) and the value of the classnames name-value argument cannot be an array with the categorical data type.
  - for more details, see . for information on name-value arguments that you cannot modify when you retrain a model, see .

for more information, see introduction to code generation.

gpu arrays
accelerate code by running on a graphics processing unit (gpu) using parallel computing toolbox™.

usage notes and limitations:

the following object functions fully support gpu arrays:
the following object functions offer limited support for gpu arrays:
the object functions execute on a gpu if either of the following apply:
- the model was fitted with gpu arrays.
- the predictor data that you pass to the object function is a gpu array.

for more information, see run matlab functions on a gpu (parallel computing toolbox).

version history

introduced in r2014b

multiclass model for support vector machines (svms) and other classifiers -凯发k8网页登录

description

creation

properties

ecoc properties

binarylearners — trained binary learners cell vector of model objects

binaryloss — binary learner loss function 'binodeviance' | 'exponential' | 'hamming' | 'hinge' | 'linear' | 'logit' | 'quadratic'

binaryy — binary learner class labels numeric matrix

binedges — bin edges for numeric predictors cell array of numeric vectors | []

codingmatrix — class assignment codes numeric matrix

codingname — coding design name character vector

learnerweights — binary learner weights numeric row vector

other classification properties

categoricalpredictors — categorical predictor indices vector of positive integers | []

classnames — unique class labels categorical array | character array | logical vector | numeric vector | cell array of character vectors

cost — misclassification costs square numeric matrix

expandedpredictornames — expanded predictor names cell array of character vectors

modelparameters — parameter values object

numobservations — number of observations positive numeric scalar

predictornames — predictor names cell array of character vectors

prior — prior class probabilities numeric vector

responsename — response variable name character vector

rowsused — rows used in fitting [] (default) | logical vector

scoretransform — score transformation function to apply to predicted scores 'none'

w — observation weights numeric vector

x — unstandardized predictor data numeric matrix | table

y — observed class labels categorical array | character array | logical vector | numeric vector | cell array of character vectors

hyperparameter optimization properties

hyperparameteroptimizationresults — cross-validation optimization of hyperparameters bayesianoptimization object | table

object functions

examples

train multiclass model using svm learners

inspect binary learner properties of ecoc classifier

cross-validate ecoc classifier

more about

error-correcting output codes model

coding design

algorithms

random coding design matrices

support vector storage

alternative functionality

references

extended capabilities

c/c code generation generate c and c code using matlab® coder™.

gpu arrays accelerate code by running on a graphics processing unit (gpu) using parallel computing toolbox™.

version history

see also

wechat

`binarylearners` — trained binary learners
cell vector of model objects

`binaryloss` — binary learner loss function
`'binodeviance'` | `'exponential'` | `'hamming'` | `'hinge'` | `'linear'` | `'logit'` | `'quadratic'`

`binaryy` — binary learner class labels
numeric matrix

`binedges` — bin edges for numeric predictors
cell array of numeric vectors | `[]`

`codingmatrix` — class assignment codes
numeric matrix

`codingname` — coding design name
character vector

`learnerweights` — binary learner weights
numeric row vector

`categoricalpredictors` — categorical predictor indices
vector of positive integers | `[]`

`classnames` — unique class labels
categorical array | character array | logical vector | numeric vector | cell array of character vectors

`cost` — misclassification costs
square numeric matrix

`expandedpredictornames` — expanded predictor names
cell array of character vectors

`modelparameters` — parameter values
object

`numobservations` — number of observations
positive numeric scalar

`predictornames` — predictor names
cell array of character vectors

`prior` — prior class probabilities
numeric vector

`responsename` — response variable name
character vector

`rowsused` — rows used in fitting
`[]` (default) | logical vector

`scoretransform` — score transformation function to apply to predicted scores
`'none'`

`w` — observation weights
numeric vector

`x` — unstandardized predictor data
numeric matrix | table

`y` — observed class labels
categorical array | character array | logical vector | numeric vector | cell array of character vectors

`hyperparameteroptimizationresults` — cross-validation optimization of hyperparameters
`bayesianoptimization` object | table

c/c code generation
generate c and c code using matlab® coder™.

gpu arrays
accelerate code by running on a graphics processing unit (gpu) using parallel computing toolbox™.