support vector machine (svm) for one-凯发k8网页登录

support vector machine (svm) for one-class and binary classification

description

classificationsvm is a support vector machine (svm) classifier for one-class and two-class learning. trained classificationsvm classifiers store training data, parameter values, prior probabilities, support vectors, and algorithmic implementation information. use these classifiers to perform tasks such as fitting a score-to-posterior-probability transformation function (see ) and predicting labels for new data (see predict).

creation

create a classificationsvm object by using fitcsvm.

properties

svm properties

`alpha` — trained classifier coefficients
numeric vector

this property is read-only.

trained classifier coefficients, specified as an s-by-1 numeric vector. s is the number of support vectors in the trained classifier, sum(mdl.issupportvector).

alpha contains the trained classifier coefficients from the dual problem, that is, the estimated lagrange multipliers. if you remove duplicates by using the removeduplicates name-value pair argument of fitcsvm, then for a given set of duplicate observations that are support vectors, alpha contains one coefficient corresponding to the entire set. that is, matlab^® attributes a nonzero coefficient to one observation from the set of duplicates and a coefficient of 0 to all other duplicate observations in the set.

data types: single | double

`beta` — linear predictor coefficients
numeric vector

this property is read-only.

linear predictor coefficients, specified as a numeric vector. the length of beta is equal to the number of predictors used to train the model.

matlab expands categorical variables in the predictor data using full dummy encoding. that is, matlab creates one dummy variable for each level of each categorical variable. beta stores one value for each predictor variable, including the dummy variables. for example, if there are three predictors, one of which is a categorical variable with three levels, then beta is a numeric vector containing five values.

if kernelparameters.function is 'linear', then the classification score for the observation x is

$f (x) = (x / s)' β b .$

mdl stores β, b, and s in the properties beta, bias, and kernelparameters.scale, respectively.

to estimate classification scores manually, you must first apply any transformations to the predictor data that were applied during training. specifically, if you specify 'standardize',true when using fitcsvm, then you must standardize the predictor data manually by using the mean mdl.mu and standard deviation mdl.sigma, and then divide the result by the kernel scale in mdl.kernelparameters.scale.

all svm functions, such as and predict, apply any required transformation before estimation.

if kernelparameters.function is not 'linear', then beta is empty ([]).

data types: single | double

`bias` — bias term
scalar

this property is read-only.

bias term, specified as a scalar.

data types: single | double

`boxconstraints` — box constraints
numeric vector

this property is read-only.

box constraints, specified as a numeric vector of n-by-1 box constraints. n is the number of observations in the training data (see the numobservations property).

if you remove duplicates by using the removeduplicates name-value pair argument of fitcsvm, then for a given set of duplicate observations, matlab sums the box constraints and then attributes the sum to one observation. matlab attributes the box constraints of 0 to all other observations in the set.

data types: single | double

`cacheinfo` — caching information
structure array

this property is read-only.

caching information, specified as a structure array. the caching information contains the fields described in this table.

field	description
size	the cache size (in mb) that the software reserves to train the svm classifier. for details, see `'cachesize'`.
algorithm	the caching algorithm that the software uses during optimization. currently, the only available caching algorithm is `queue`. you cannot set the caching algorithm.

display the fields of cacheinfo by using dot notation. for example, mdl.cacheinfo.size displays the value of the cache size.

data types: struct

`issupportvector` — support vector indicator
logical vector

this property is read-only.

support vector indicator, specified as an n-by-1 logical vector that flags whether a corresponding observation in the predictor data matrix is a support vector. n is the number of observations in the training data (see numobservations).

if you remove duplicates by using the removeduplicates name-value pair argument of fitcsvm, then for a given set of duplicate observations that are support vectors, issupportvector flags only one observation as a support vector.

data types: logical

`kernelparameters` — kernel parameters
structure array

this property is read-only.

kernel parameters, specified as a structure array. the kernel parameters property contains the fields listed in this table.

field	description
function	kernel function used to compute the elements of the gram matrix. for details, see `'kernelfunction'`.
scale	kernel scale parameter used to scale all elements of the predictor data on which the model is trained. for details, see `'kernelscale'`.

to display the values of kernelparameters, use dot notation. for example, mdl.kernelparameters.scale displays the kernel scale parameter value.

the software accepts kernelparameters as inputs and does not modify them.

data types: struct

`nu` — one-class learning parameter
positive scalar

this property is read-only.

one-class learning parameter ν, specified as a positive scalar.

data types: single | double

`outlierfraction` — proportion of outliers
numeric scalar

this property is read-only.

proportion of outliers in the training data, specified as a numeric scalar.

data types: double

`solver` — optimization routine
`'isda'` | `'l1qp'` | `'smo'`

this property is read-only.

optimization routine used to train the svm classifier, specified as 'isda', 'l1qp', or 'smo'. for more details, see 'solver'.

`supportvectorlabels` — support vector class labels
s-by-1 numeric vector

this property is read-only.

support vector class labels, specified as an s-by-1 numeric vector. s is the number of support vectors in the trained classifier, sum(mdl.issupportvector).

a value of 1 in supportvectorlabels indicates that the corresponding support vector is in the positive class (classnames{2}). a value of –1 indicates that the corresponding support vector is in the negative class (classnames{1}).

if you remove duplicates by using the removeduplicates name-value pair argument of fitcsvm, then for a given set of duplicate observations that are support vectors, supportvectorlabels contains one unique support vector label.

data types: single | double

`supportvectors` — support vectors
s-by-p numeric matrix

this property is read-only.

support vectors in the trained classifier, specified as an s-by-p numeric matrix. s is the number of support vectors in the trained classifier, sum(mdl.issupportvector), and p is the number of predictor variables in the predictor data.

supportvectors contains rows of the predictor data x that matlab considers to be support vectors. if you specify 'standardize',true when training the svm classifier using fitcsvm, then supportvectors contains the standardized rows of x.

data types: single | double

other classification properties

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

this property is read-only.

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: double

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

this property is read-only.

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 cost
numeric square matrix

this property is read-only.

misclassification cost, specified as a numeric square matrix.

for two-class learning, the cost property stores the misclassification cost matrix specified by the cost name-value argument of the fitting function. the rows correspond to the true class and the columns correspond to the predicted class. that is, 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.
for one-class learning, cost = 0.

data types: double

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

this property is read-only.

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

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

data types: cell

`gradient` — training data gradient values
numeric vector

this property is read-only.

training data gradient values, specified as a numeric vector. the length of gradient is equal to the number of observations (numobservations).

data types: single | double

`modelparameters` — parameters used to train model
object

this property is read-only.

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

access the properties of modelparameters by using dot notation. for example, access the initial values for estimating alpha by using mdl.modelparameters.alpha.

`mu` — predictor means
numeric vector | `[]`

this property is read-only.

predictor means, specified as a numeric vector. if you specify 'standardize',1 or 'standardize',true when you train an svm classifier using fitcsvm, the length of mu is equal to the number of predictors.

matlab expands categorical variables in the predictor data using dummy variables. mu stores one value for each predictor variable, including the dummy variables. however, matlab does not standardize the columns that contain categorical variables.

if you set 'standardize',false when you train the svm classifier using fitcsvm, then mu is an empty vector ([]).

data types: single | double

`numobservations` — number of observations
numeric scalar

this property is read-only.

number of observations in the training data stored in x and y, specified as a numeric scalar.

data types: double

`predictornames` — predictor variable names
cell array of character vectors

this property is read-only.

predictor variable names, specified as a cell array of character vectors. the order of the elements in predictornames corresponds to the order in which the predictor names appear in the training data.

data types: cell

`prior` — prior probabilities
numeric vector

this property is read-only.

prior probabilities for each class, specified as a numeric vector.

for two-class learning, if you specify a cost matrix, then the software updates the prior probabilities by incorporating the penalties described in the cost matrix.

for two-class learning, the software normalizes the prior probabilities specified by the prior name-value argument of the fitting function so that the probabilities sum to 1. the prior property stores the normalized prior probabilities. the order of the elements of prior corresponds to the elements of mdl.classnames.
for one-class learning, prior = 1.

data types: single | double

`responsename` — response variable name
character vector

this property is read-only.

response variable name, specified as a character vector.

data types: char

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

this property is read-only.

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

data types: logical

`scoretransform` — score transformation
character vector | function handle

score transformation, specified as a character vector or function handle. scoretransform represents a built-in transformation function or a function handle for transforming predicted classification scores.

to change the score transformation function to function, for example, use dot notation.

for a built-in function, enter a character vector.

mdl.scoretransform = 'function';

this table describes the available built-in functions.

value	description
`'doublelogit'`	1/(1 e^–2x)
`'invlogit'`	log(x / (1 – x))
`'ismax'`	sets the score for the class with the largest score to 1, and sets the scores for all other classes to 0
`'logit'`	1/(1 e^–x)
`'none'` or `'identity'`	x (no transformation)
`'sign'`	–1 for x < 0 0 for x = 0 1 for x > 0
`'symmetric'`	2x – 1
`'symmetricismax'`	sets the score for the class with the largest score to 1, and sets the scores for all other classes to –1
`'symmetriclogit'`	2/(1 e^–x) – 1

for a matlab function or a function that you define, enter its function handle.
```
mdl.scoretransform = @function;
```
function must accept a matrix (the original scores) and return a matrix of the same size (the transformed scores).

data types: char | function_handle

`sigma` — predictor standard deviations
`[]` (default) | numeric vector

this property is read-only.

predictor standard deviations, specified as a numeric vector.

if you specify 'standardize',true when you train the svm classifier using fitcsvm, the length of sigma is equal to the number of predictor variables.

matlab expands categorical variables in the predictor data using dummy variables. sigma stores one value for each predictor variable, including the dummy variables. however, matlab does not standardize the columns that contain categorical variables.

if you set 'standardize',false when you train the svm classifier using fitcsvm, then sigma is an empty vector ([]).

data types: single | double

`w` — observation weights
numeric vector

this property is read-only.

observation weights used to train the svm classifier, specified as an n-by-1 numeric vector. n is the number of observations (see numobservations).

fitcsvm normalizes the observation weights specified in the 'weights' name-value pair argument so that the elements of w within a particular class sum up to the prior probability of that class.

data types: single | double

`x` — unstandardized predictors
numeric matrix | table

this property is read-only.

unstandardized predictors used to train the svm classifier, specified as a numeric matrix or table.

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

matlab excludes observations containing at least one missing value, and removes corresponding elements from y.

data types: single | double

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

this property is read-only.

class labels used to train the svm classifier, specified as a categorical or character array, logical or numeric vector, or cell array of character vectors. y is the same data type as the input argument y of fitcsvm. (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.

matlab excludes elements containing missing values, and removes corresponding observations from x.

convergence control properties

`convergenceinfo` — convergence information
structure array

this property is read-only.

convergence information, specified as a structure array.

field	description
`converged`	logical flag indicating whether the algorithm converged (`1` indicates convergence).
`reasonforconvergence`	character vector indicating the criterion the software uses to detect convergence.
`gap`	scalar feasibility gap between the dual and primal objective functions.
`gaptolerance`	scalar feasibility gap tolerance. set this tolerance, for example to `1e-2`, by using the name-value pair argument `'gaptolerance',1e-2` of `fitcsvm`.
`deltagradient`	scalar-attained gradient difference between upper and lower violators
`deltagradienttolerance`	scalar tolerance for the gradient difference between upper and lower violators. set this tolerance, for example to `1e-2`, by using the name-value pair argument `'deltagradienttolerance',1e-2` of `fitcsvm`.
`largestkktviolation`	maximal scalar karush-kuhn-tucker (kkt) violation value.
`kkttolerance`	scalar tolerance for the largest kkt violation. set this tolerance, for example, to `1e-3`, by using the name-value pair argument `'kkttolerance',1e-3` of `fitcsvm`.
`history`	structure array containing convergence information at set optimization iterations. the fields are: `numiterations`: numeric vector of iteration indices for which the software records convergence information `gap`: numeric vector of `gap` values at the iterations `deltagradient`: numeric vector of `deltagradient` values at the iterations `largestkktviolation`: numeric vector of `largestkktviolation` values at the iterations `numsupportvectors`: numeric vector indicating the number of support vectors at the iterations `objective`: numeric vector of `objective` values at the iterations
`objective`	scalar value of the dual objective function.

data types: struct

`numiterations` — number of iterations
positive integer

this property is read-only.

number of iterations required by the optimization routine to attain convergence, specified as a positive integer.

to set the limit on the number of iterations to 1000, for example, specify 'iterationlimit',1000 when you train the svm classifier using fitcsvm.

data types: double

`shrinkageperiod` — number of iterations between reductions of active set
nonnegative integer

this property is read-only.

number of iterations between reductions of the active set, specified as a nonnegative integer.

to set the shrinkage period to 1000, for example, specify 'shrinkageperiod',1000 when you train the svm classifier using fitcsvm.

data types: single | double

hyperparameter optimization properties

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

this property is read-only.

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

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 machine learning model
	compare accuracies of two classification models using new data
	cross-validate machine learning model
	discard support vectors for linear support vector machine (svm) classifier
	find classification edge for support vector machine (svm) classifier
	fit posterior probabilities for support vector machine (svm) classifier
	gather properties of statistics and machine learning toolbox object from gpu
	convert binary classification support vector machine (svm) model to incremental learner
`lime`	local interpretable model-agnostic explanations (lime)
	find classification error for support vector machine (svm) classifier
	find classification margins for support vector machine (svm) classifier
`partialdependence`	compute partial dependence
`plotpartialdependence`	create partial dependence plot (pdp) and individual conditional expectation (ice) plots
`predict`	classify observations using support vector machine (svm) classifier
	resubstitution classification edge
	resubstitution classification loss
	resubstitution classification margin
	classify training data using trained classifier
	resume training support vector machine (svm) classifier
`shapley`	shapley values
	compare accuracies of two classification models by repeated cross-validation

examples

train svm classifier

load fisher's iris data set. remove the sepal lengths and widths and all observed setosa irises.

load fisheriris
inds = ~strcmp(species,'setosa');
x = meas(inds,3:4);
y = species(inds);

train an svm classifier using the processed data set.

svmmodel = fitcsvm(x,y)

svmmodel = 
  classificationsvm
             responsename: 'y'
    categoricalpredictors: []
               classnames: {'versicolor'  'virginica'}
           scoretransform: 'none'
          numobservations: 100
                    alpha: [24x1 double]
                     bias: -14.4149
         kernelparameters: [1x1 struct]
           boxconstraints: [100x1 double]
          convergenceinfo: [1x1 struct]
          issupportvector: [100x1 logical]
                   solver: 'smo'
  properties, methods

svmmodel is a trained classificationsvm classifier. display the properties of svmmodel. for example, to determine the class order, use dot notation.

classorder = svmmodel.classnames

classorder = 2x1 cell
    {'versicolor'}
    {'virginica' }

the first class ('versicolor') is the negative class, and the second ('virginica') is the positive class. you can change the class order during training by using the 'classnames' name-value pair argument.

plot a scatter diagram of the data and circle the support vectors.

sv = svmmodel.supportvectors;
figure
gscatter(x(:,1),x(:,2),y)
hold on
plot(sv(:,1),sv(:,2),'ko','markersize',10)
legend('versicolor','virginica','support vector')
hold off

figure contains an axes object. the axes object contains 3 objects of type line. one or more of the lines displays its values using only markers these objects represent versicolor, virginica, support vector.

the support vectors are observations that occur on or beyond their estimated class boundaries.

you can adjust the boundaries (and, therefore, the number of support vectors) by setting a box constraint during training using the 'boxconstraint' name-value pair argument.

train and cross-validate svm classifier

load the ionosphere data set.

load ionosphere

train and cross-validate an svm classifier. standardize the predictor data and specify the order of the classes.

rng(1);  % for reproducibility
cvsvmmodel = fitcsvm(x,y,'standardize',true,...
    'classnames',{'b','g'},'crossval','on')

cvsvmmodel = 
  classificationpartitionedmodel
    crossvalidatedmodel: 'svm'
         predictornames: {'x1'  'x2'  'x3'  'x4'  'x5'  'x6'  'x7'  'x8'  'x9'  'x10'  'x11'  'x12'  'x13'  'x14'  'x15'  'x16'  'x17'  'x18'  'x19'  'x20'  'x21'  'x22'  'x23'  'x24'  'x25'  'x26'  'x27'  'x28'  'x29'  'x30'  'x31'  'x32'  'x33'  'x34'}
           responsename: 'y'
        numobservations: 351
                  kfold: 10
              partition: [1x1 cvpartition]
             classnames: {'b'  'g'}
         scoretransform: 'none'
  properties, methods

cvsvmmodel is a classificationpartitionedmodel cross-validated svm classifier. by default, the software implements 10-fold cross-validation.

alternatively, you can cross-validate a trained classificationsvm classifier by passing it to crossval.

inspect one of the trained folds using dot notation.

cvsvmmodel.trained{1}

ans = 
  compactclassificationsvm
             responsename: 'y'
    categoricalpredictors: []
               classnames: {'b'  'g'}
           scoretransform: 'none'
                    alpha: [78x1 double]
                     bias: -0.2210
         kernelparameters: [1x1 struct]
                       mu: [0.8888 0 0.6320 0.0406 0.5931 0.1205 0.5361 0.1286 0.5083 0.1879 0.4779 0.1567 0.3924 0.0875 0.3360 0.0789 0.3839 9.6066e-05 0.3562 -0.0308 0.3398 -0.0073 0.3590 -0.0628 0.4064 -0.0664 0.5535 -0.0749 0.3835 -0.0295 ... ]
                    sigma: [0.3149 0 0.5033 0.4441 0.5255 0.4663 0.4987 0.5205 0.5040 0.4780 0.5649 0.4896 0.6293 0.4924 0.6606 0.4535 0.6133 0.4878 0.6250 0.5140 0.6075 0.5150 0.6068 0.5222 0.5729 0.5103 0.5061 0.5478 0.5712 0.5032 0.5639 0.5062 ... ]
           supportvectors: [78x34 double]
      supportvectorlabels: [78x1 double]
  properties, methods

each fold is a compactclassificationsvm classifier trained on 90% of the data.

estimate the generalization error.

generror = kfoldloss(cvsvmmodel)

generror = 0.1168

on average, the generalization error is approximately 12%.

more about

box constraint

a box constraint is a parameter that controls the maximum penalty imposed on margin-violating observations, which helps to prevent overfitting (regularization).

if you increase the box constraint, then the svm classifier assigns fewer support vectors. however, increasing the box constraint can lead to longer training times.

gram matrix

the gram matrix of a set of n vectors {x₁,..,x_n; x_j ∊ r^p} is an n-by-n matrix with element (j,k) defined as g(x_j,x_k) = <ϕ(x_j),ϕ(x_k)>, an inner product of the transformed predictors using the kernel function ϕ.

for nonlinear svm, the algorithm forms a gram matrix using the rows of the predictor data x. the dual formalization replaces the inner product of the observations in x with corresponding elements of the resulting gram matrix (called the “kernel trick”). consequently, nonlinear svm operates in the transformed predictor space to find a separating hyperplane.

karush-kuhn-tucker complementarity conditions

kkt complementarity conditions are optimization constraints required for optimal nonlinear programming solutions.

in svm, the kkt complementarity conditions are

${\begin{cases} α_{j} [y_{j} f (x_{j}) - 1 ξ_{j}] = 0 \\ ξ_{j} (c - α_{j}) = 0 \end{cases}$

for all j = 1,...,n, where $f (x_{j}) = ϕ (x_{j})' β b,$ ϕ is a kernel function (see gram matrix), and ξ_j is a slack variable. if the classes are perfectly separable, then ξ_j = 0 for all j = 1,...,n.

one-class learning

one-class learning, or unsupervised svm, aims to separate data from the origin in the high-dimensional predictor space (not the original predictor space), and is an algorithm used for outlier detection.

the algorithm resembles that of svm for binary classification. the objective is to minimize the dual expression

$0.5 \sum_{j k} α_{j} α_{k} g (x_{j}, x_{k})$

with respect to $α_{1}, ..., α_{n}$ , subject to

$\sum α_{j} = n ν$

and $0 \leq α_{j} \leq 1$ for all j = 1,...,n. the value of g(x_j,x_k) is in element (j,k) of the gram matrix.

a small value of ν leads to fewer support vectors and, therefore, a smooth, crude decision boundary. a large value of ν leads to more support vectors and, therefore, a curvy, flexible decision boundary. the optimal value of ν should be large enough to capture the data complexity and small enough to avoid overtraining. also, 0 < ν ≤ 1.

for more details, see [5].

support vector

support vectors are observations corresponding to strictly positive estimates of α₁,...,α_n.

svm classifiers that yield fewer support vectors for a given training set are preferred.

support vector machines for binary classification

the svm binary classification algorithm searches for an optimal hyperplane that separates the data into two classes. for separable classes, the optimal hyperplane maximizes a margin (space that does not contain any observations) surrounding itself, which creates boundaries for the positive and negative classes. for inseparable classes, the objective is the same, but the algorithm imposes a penalty on the length of the margin for every observation that is on the wrong side of its class boundary.

the linear svm score function is

$f (x) = x' β b,$

where:

x is an observation (corresponding to a row of x).
the vector β contains the coefficients that define an orthogonal vector to the hyperplane (corresponding to mdl.beta). for separable data, the optimal margin length is $2 / ‖ β ‖ .$
b is the bias term (corresponding to mdl.bias).

the root of f(x) for particular coefficients defines a hyperplane. for a particular hyperplane, f(z) is the distance from point z to the hyperplane.

the algorithm searches for the maximum margin length, while keeping observations in the positive (y = 1) and negative (y = –1) classes separate.

for separable classes, the objective is to minimize $‖ β ‖$ with respect to the β and b subject to y_jf(x_j) ≥ 1, for all j = 1,..,n. this is the primal formalization for separable classes.
for inseparable classes, the algorithm uses slack variables (ξ_j) to penalize the objective function for observations that cross the margin boundary for their class. ξ_j = 0 for observations that do not cross the margin boundary for their class, otherwise ξ_j ≥ 0.
the objective is to minimize $0.5 {‖ β ‖}^{2} c \sum ξ_{j}$ with respect to the β, b, and ξ_j subject to $y_{j} f (x_{j}) \geq 1 - ξ_{j}$ and $ξ_{j} \geq 0$ for all j = 1,..,n, and for a positive scalar box constraint c. this is the primal formalization for inseparable classes.

the algorithm uses the lagrange multipliers method to optimize the objective, which introduces n coefficients α₁,...,α_n (corresponding to mdl.alpha). the dual formalizations for linear svm are as follows:

for separable classes, minimize

$0.5 \sum_{j = 1}^{n} \sum_{k = 1}^{n} α_{j} α_{k} y_{j} y_{k} x_{j}' x_{k} - \sum_{j = 1}^{n} α_{j}$
with respect to α₁,...,α_n, subject to $\sum α_{j} y_{j} = 0$ , α_j ≥ 0 for all j = 1,...,n, and karush-kuhn-tucker (kkt) complementarity conditions.
for inseparable classes, the objective is the same as for separable classes, except for the additional condition $0 \leq α_{j} \leq c$ for all j = 1,..,n.

the resulting score function is

$\hat{f} (x) = \sum_{j = 1}^{n} {\hat{α}}_{j} y_{j} x' x_{j} \hat{b} .$

$\hat{b}$ is the estimate of the bias and ${\hat{α}}_{j}$ is the jth estimate of the vector $\hat{α}$ , j = 1,...,n. written this way, the score function is free of the estimate of β as a result of the primal formalization.

the svm algorithm classifies a new observation z using $sign (\hat{f} (z)) .$

in some cases, a nonlinear boundary separates the classes. nonlinear svm works in a transformed predictor space to find an optimal, separating hyperplane.

the dual formalization for nonlinear svm is

$0.5 \sum_{j = 1}^{n} \sum_{k = 1}^{n} α_{j} α_{k} y_{j} y_{k} g (x_{j}, x_{k}) - \sum_{j = 1}^{n} α_{j}$

with respect to α₁,...,α_n, subject to $\sum α_{j} y_{j} = 0$ , $0 \leq α_{j} \leq c$ for all j = 1,..,n, and the kkt complementarity conditions. g(x_k,x_j) are elements of the gram matrix. the resulting score function is

$\hat{f} (x) = \sum_{j = 1}^{n} {\hat{α}}_{j} y_{j} g (x, x_{j}) \hat{b} .$

for more details, see , [1], and [3].

algorithms

for the mathematical formulation of the svm binary classification algorithm, see support vector machines for binary classification and .
nan, , empty character vector (''), empty string (""), and values indicate missing values. fitcsvm removes entire rows of data corresponding to a missing response. when computing total weights (see the next bullets), fitcsvm ignores any weight corresponding to an observation with at least one missing predictor. this action can lead to unbalanced prior probabilities in balanced-class problems. consequently, observation box constraints might not equal boxconstraint.
if you specify the cost, prior, and weights name-value arguments, the output model object stores the specified values in the cost, prior, and w properties, respectively. the cost property stores the user-specified cost matrix (c) without modification. the prior and w properties store the prior probabilities and observation weights, respectively, after normalization. for model training, the software updates the prior probabilities and observation weights to incorporate the penalties described in the cost matrix. for details, see .
note that the cost and prior name-value arguments are used for two-class learning. for one-class learning, the cost and prior properties store 0 and 1, respectively.
for two-class learning, fitcsvm assigns a box constraint to each observation in the training data. the formula for the box constraint of observation j is

$c_{j} = n c_{0} w_{j}^{*},$
where c₀ is the initial box constraint (see the boxconstraint name-value argument), and w_j^* is the observation weight adjusted by cost and prior for observation j. for details about the observation weights, see .
if you specify standardize as true and set the cost, prior, or weights name-value argument, then fitcsvm standardizes the predictors using their corresponding weighted means and weighted standard deviations. that is, fitcsvm standardizes predictor j (x_j) using

$x_{j}^{*} = \frac{x_{j} - μ_{j}^{*}}{σ_{j}^{*}},$
where x_jk is observation k (row) of predictor j (column), and

$\begin{matrix} μ_{j}^{*} = \frac{1}{\sum_{k} w_{k}^{*}} \sum_{k} w_{k}^{*} x_{j k}, \\ {(σ_{j}^{*})}^{2} = \frac{v_{1}}{v_{1}^{2} - v_{2}} \sum_{k} w_{k}^{*} {(x_{j k} - μ_{j}^{*})}^{2}, \\ v_{1} = \sum_{j} w_{j}^{*}, \\ v_{2} = \sum_{j} {(w_{j}^{*})}^{2} . \end{matrix}$
assume that p is the proportion of outliers that you expect in the training data, and that you set 'outlierfraction',p.
- for one-class learning, the software trains the bias term such that 100p% of the observations in the training data have negative scores.
- the software implements robust learning for two-class learning. in other words, the software attempts to remove 100p% of the observations when the optimization algorithm converges. the removed observations correspond to gradients that are large in magnitude.
if your predictor data contains categorical variables, then the software generally uses full dummy encoding for these variables. the software creates one dummy variable for each level of each categorical variable.
- the predictornames property stores one element for each of the original predictor variable names. for example, assume that there are three predictors, one of which is a categorical variable with three levels. then predictornames is a 1-by-3 cell array of character vectors containing the original names of the predictor variables.
- the expandedpredictornames property stores one element for each of the predictor variables, including the dummy variables. for example, assume that there are three predictors, one of which is a categorical variable with three levels. then expandedpredictornames is a 1-by-5 cell array of character vectors containing the names of the predictor variables and the new dummy variables.
- similarly, the beta property stores one beta coefficient for each predictor, including the dummy variables.
- the supportvectors property stores the predictor values for the support vectors, including the dummy variables. for example, assume that there are m support vectors and three predictors, one of which is a categorical variable with three levels. then supportvectors is an n-by-5 matrix.
- the x property stores the training data as originally input and does not include the dummy variables. when the input is a table, x contains only the columns used as predictors.
for predictors specified in a table, if any of the variables contain ordered (ordinal) categories, the software uses ordinal encoding for these variables.
- for a variable with k ordered levels, the software creates k – 1 dummy variables. the jth dummy variable is –1 for levels up to j, and 1 for levels j 1 through k.
- the names of the dummy variables stored in the expandedpredictornames property indicate the first level with the value 1. the software stores k – 1 additional predictor names for the dummy variables, including the names of levels 2, 3, ..., k.
all solvers implement l1 soft-margin minimization.
for one-class learning, the software estimates the lagrange multipliers, α₁,...,α_n, such that

$\sum_{j = 1}^{n} α_{j} = n ν .$

references

[1] hastie, t., r. tibshirani, and j. friedman. the elements of statistical learning, second edition. ny: springer, 2008.

[2] scholkopf, b., j. c. platt, j. c. shawe-taylor, a. j. smola, and r. c. williamson. “estimating the support of a high-dimensional distribution.” neural comput., vol. 13, number 7, 2001, pp. 1443–1471.

[3] christianini, n., and j. c. shawe-taylor. an introduction to support vector machines and other kernel-based learning methods. cambridge, uk: cambridge university press, 2000.

[4] scholkopf, b., and a. smola. learning with kernels: support vector machines, regularization, optimization and beyond, adaptive computation and machine learning. cambridge, ma: the mit press, 2002.

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.
to integrate the prediction of an svm classification model into simulink^®, you can use the classificationsvm predict block in the statistics and machine learning toolbox™ library or a matlab function block with the predict function.
when you train an svm model by using fitcsvm, the following restrictions apply.
- the value of the 'scoretransform' name-value pair argument cannot be an anonymous function. for generating code that predicts posterior probabilities given new observations, pass a trained svm model to or . the scoretransform property of the returned model contains an anonymous function that represents the score-to-posterior-probability function and is configured for code generation.
- for fixed-point code generation, the value of the 'scoretransform' name-value pair argument cannot be 'invlogit'. also, the value of the 'kernelfunction' name-value pair argument must be 'gaussian', 'linear', or 'polynomial'.
- for fixed-point code generation and code generation with a coder configurer, the following additional restrictions apply.
  - 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 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 r2014a

r2022a: `cost` property stores the user-specified cost matrix

starting in r2022a, the cost property stores the user-specified cost matrix, so that you can compute the observed misclassification cost using the specified cost value. the software stores normalized prior probabilities (prior) and observation weights (w) that do not reflect the penalties described in the cost matrix. to compute the observed misclassification cost, specify the lossfun name-value argument as "classifcost" when you call the loss or resubloss function.

note that model training has not changed and, therefore, the decision boundaries between classes have not changed.

for training, the fitting function updates the specified prior probabilities by incorporating the penalties described in the specified cost matrix, and then normalizes the prior probabilities and observation weights. this behavior has not changed. in previous releases, the software stored the default cost matrix in the cost property and stored the prior probabilities and observation weights used for training in the prior and w properties, respectively. starting in r2022a, the software stores the user-specified cost matrix without modification, and stores normalized prior probabilities and observation weights that do not reflect the cost penalties. for more details, see .

some object functions use the cost, prior, and w properties:

the loss and resubloss functions use the cost matrix stored in the cost property if you specify the lossfun name-value argument as "classifcost" or "mincost".
the loss and edge functions use the prior probabilities stored in the prior property to normalize the observation weights of the input data.
the resubloss and resubedge functions use the observation weights stored in the w property.

if you specify a nondefault cost matrix when you train a classification model, the object functions return a different value compared to previous releases.

if you want the software to handle the cost matrix, prior probabilities, and observation weights as in previous releases, adjust the prior probabilities and observation weights for the nondefault cost matrix, as described in . then, when you train a classification model, specify the adjusted prior probabilities and observation weights by using the prior and weights name-value arguments, respectively, and use the default cost matrix.

support vector machine (svm) for one-凯发k8网页登录

description

creation

properties

svm properties

alpha — trained classifier coefficients numeric vector

beta — linear predictor coefficients numeric vector

bias — bias term scalar

boxconstraints — box constraints numeric vector

cacheinfo — caching information structure array

issupportvector — support vector indicator logical vector

kernelparameters — kernel parameters structure array

nu — one-class learning parameter positive scalar

outlierfraction — proportion of outliers numeric scalar

solver — optimization routine 'isda' | 'l1qp' | 'smo'

supportvectorlabels — support vector class labels s-by-1 numeric vector

supportvectors — support vectors s-by-p numeric matrix

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 cost numeric square matrix

expandedpredictornames — expanded predictor names cell array of character vectors

gradient — training data gradient values numeric vector

modelparameters — parameters used to train model object

mu — predictor means numeric vector | []

numobservations — number of observations numeric scalar

predictornames — predictor variable names cell array of character vectors

prior — prior probabilities numeric vector

responsename — response variable name character vector

rowsused — rows used in fitting [] | logical vector

scoretransform — score transformation character vector | function handle

sigma — predictor standard deviations [] (default) | numeric vector

w — observation weights numeric vector

x — unstandardized predictors numeric matrix | table

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

convergence control properties

convergenceinfo — convergence information structure array

numiterations — number of iterations positive integer

shrinkageperiod — number of iterations between reductions of active set nonnegative integer

hyperparameter optimization properties

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

object functions

examples

train svm classifier

train and cross-validate svm classifier

more about

box constraint

gram matrix

karush-kuhn-tucker complementarity conditions

one-class learning

support vector

support vector machines for binary classification

algorithms

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

r2022a: cost property stores the user-specified cost matrix

see also

topics

wechat

`alpha` — trained classifier coefficients
numeric vector

`beta` — linear predictor coefficients
numeric vector

`bias` — bias term
scalar

`boxconstraints` — box constraints
numeric vector

`cacheinfo` — caching information
structure array

`issupportvector` — support vector indicator
logical vector

`kernelparameters` — kernel parameters
structure array

`nu` — one-class learning parameter
positive scalar

`outlierfraction` — proportion of outliers
numeric scalar

`solver` — optimization routine
`'isda'` | `'l1qp'` | `'smo'`

`supportvectorlabels` — support vector class labels
s-by-1 numeric vector

`supportvectors` — support vectors
s-by-p numeric matrix

`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 cost
numeric square matrix

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

`gradient` — training data gradient values
numeric vector

`modelparameters` — parameters used to train model
object

`mu` — predictor means
numeric vector | `[]`

`numobservations` — number of observations
numeric scalar

`predictornames` — predictor variable names
cell array of character vectors

`prior` — prior probabilities
numeric vector

`responsename` — response variable name
character vector

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

`scoretransform` — score transformation
character vector | function handle

`sigma` — predictor standard deviations
`[]` (default) | numeric vector

`w` — observation weights
numeric vector

`x` — unstandardized predictors
numeric matrix | table

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

`convergenceinfo` — convergence information
structure array

`numiterations` — number of iterations
positive integer

`shrinkageperiod` — number of iterations between reductions of active set
nonnegative integer

`hyperparameteroptimizationresults` — description of 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™.

r2022a: `cost` property stores the user-specified cost matrix