fitcsvm

Clasificador de máquina vectorial de soporte de tren (SVM) para clasificación de una clase y binaria

Sintaxis

Mdl = fitcsvm(Tbl,ResponseVarName)

Mdl = fitcsvm(Tbl,formula)

Mdl = fitcsvm(Tbl,Y)

Mdl = fitcsvm(X,Y)

Mdl = fitcsvm(___,Name,Value)

Descripción

trenes o valida cruzadamente un modelo de máquina vectorial de soporte (SVM) para la clasificación de una clase y dos clases (binarias) en un conjunto de datos predictor de baja dimensión o de dimensión moderada. admite la asignación de datos predictores mediante funciones del kernel y admite la optimización mínima secuencial (SMO), el algoritmo iterativo de datos únicos (ISDA) o 1 minimización de margen flexible a través de la programación cuadrática para la minimización de la función objetiva.fitcsvmfitcsvmL

Para entrenar un modelo SVM lineal para la clasificación binaria en un conjunto de datos de alta dimensión, es decir, un conjunto de datos que incluye muchas variables predictoras, utilice en su lugar.fitclinear

Para el aprendizaje multiclase con modelos SVM binarios combinados, utilice códigos de salida de corrección de errores (ECOC). Para obtener más información, consulte .fitcecoc

Para entrenar un modelo de regresión de SVM, consulte conjuntos de datos predictores de baja dimensión y de dimensiones moderadas, o conjuntos de datos de alta dimensión.fitrsvmfitrlinear

Mdl = fitcsvm(Tbl,ResponseVarName) devuelve un tren entrenado utilizando los datos de ejemplo contenidos en la tabla. es el nombre de la variable en que contiene las etiquetas de clase para la clasificación de una clase o de dos clases.clasificador de máquina vectorial de soporte (SVM)MdlTblResponseVarNameTbl

Mdl = fitcsvm(Tbl,formula) devuelve un clasificador SVM entrenado utilizando los datos de ejemplo contenidos en la tabla. es un modelo explicativo de la respuesta y un subconjunto de las variables predictoras utilizadas para encajar .TblFórmulaTblMdl

Mdl = fitcsvm(Tbl,Y) devuelve un clasificador SVM entrenado utilizando las variables predictoras de la tabla y las etiquetas de clase en vector .TblY

Mdl = fitcsvm(X,Y) devuelve un clasificador SVM entrenado utilizando los predictores de la matriz y las etiquetas de clase en vector para la clasificación de una clase o dos clases.XY

Mdl = fitcsvm(___,Name,Value) especifica las opciones mediante uno o varios argumentos de par nombre-valor además de los argumentos de entrada en sintaxis anteriores. Por ejemplo, puede especificar el tipo de validación cruzada, el coste de la clasificación incorrecta y el tipo de función de transformación de puntuación.

Ejemplos

Clasificador de SVM de tren

Cargue el conjunto de datos de iris de Fisher. Retire las longitudes y anchuras del sépalo y todos los iris de setosa observados.

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

Entrene un clasificador SVM utilizando el conjunto de datos procesado.

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  

es un clasificador entrenado.SVMModelClassificationSVM Mostrar las propiedades de .SVMModel Por ejemplo, para determinar el orden de clases, utilice la notación de puntos.

classOrder = SVMModel.ClassNames

classOrder = 2x1 cell array
    {'versicolor'}
    {'virginica' }

La primera clase ( ) es la clase negativa, y la segunda ( ) es la clase positiva.'versicolor''virginica' Puede cambiar el orden de clases durante el entrenamiento mediante el argumento de par nombre-valor.'ClassNames'

Trazar un diagrama de dispersión de los datos y rodear los vectores de soporte.

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

Los vectores de soporte son observaciones que se producen en o más allá de sus límites de clase estimados.

Puede ajustar los límites (y, por lo tanto, el número de vectores de soporte) estableciendo una restricción de cuadro durante el entrenamiento mediante el argumento de par nombre-valor.'BoxConstraint'

Clasificador SVM de tren y validación cruzada

Cargue el conjunto de datos.ionosphere

load ionosphere rng(1); % For reproducibility

Entrene a un clasificador SVM utilizando el kernel de base radial. Deje que el software encuentre un valor de escala para la función del kernel. Estandarizar los predictores.

SVMModel = fitcsvm(X,Y,'Standardize',true,'KernelFunction','RBF',...     'KernelScale','auto');

es un clasificador entrenado.SVMModelClassificationSVM

Valide el clasificador SVM. De forma predeterminada, el software utiliza 10 veces la validación cruzada.

CVSVMModel = crossval(SVMModel);

es un clasificador validado cruzadamente.CVSVMModelClassificationPartitionedModel

Calcule la tasa de clasificación errónea fuera de muestra.

classLoss = kfoldLoss(CVSVMModel)

classLoss = 0.0484 

La tasa de generalización es de aproximadamente el 5%.

Detectar valores atípicos mediante SVM y aprendizaje de una clase

Modifique el conjunto de datos de iris de Fisher asignando todos los iris a la misma clase. Detecte valores atípicos en el conjunto de datos modificado y confirme la proporción esperada de las observaciones que son valores atípicos.

Cargue el conjunto de datos de iris de Fisher. Retire las longitudes y anchuras de los pétalos. Tratar todos los iris como provenientes de la misma clase.

load fisheriris X = meas(:,1:2); y = ones(size(X,1),1);

Entrene un clasificador SVM utilizando el conjunto de datos modificado. Supongamos que el 5% de las observaciones son valores atípicos. Estandarizar los predictores.

rng(1); SVMModel = fitcsvm(X,y,'KernelScale','auto','Standardize',true,...     'OutlierFraction',0.05);

es un clasificador entrenado.SVMModelClassificationSVM De forma predeterminada, el software utiliza el kernel gaussiano para el aprendizaje de una clase.

Trazar las observaciones y el límite de decisión. Marque los vectores de soporte y los valores atípicos potenciales.

svInd = SVMModel.IsSupportVector; h = 0.02; % Mesh grid step size [X1,X2] = meshgrid(min(X(:,1)):h:max(X(:,1)),...     min(X(:,2)):h:max(X(:,2))); [~,score] = predict(SVMModel,[X1(:),X2(:)]); scoreGrid = reshape(score,size(X1,1),size(X2,2));  figure plot(X(:,1),X(:,2),'k.') hold on plot(X(svInd,1),X(svInd,2),'ro','MarkerSize',10) contour(X1,X2,scoreGrid) colorbar; title('{\bf Iris Outlier Detection via One-Class SVM}') xlabel('Sepal Length (cm)') ylabel('Sepal Width (cm)') legend('Observation','Support Vector') hold off

El límite que separa los valores atípicos del resto de los datos se produce donde se encuentra el valor de curva de nivel.0

Compruebe que la fracción de observaciones con puntuaciones negativas en los datos validados cruzados es cercana al 5%.

CVSVMModel = crossval(SVMModel); [~,scorePred] = kfoldPredict(CVSVMModel); outlierRate = mean(scorePred<0)

outlierRate = 0.0467 

Buscar límites de clase múltiples usando SVM binario

Cree un gráfico de dispersión del conjunto de datos.fisheriris Trate las coordenadas de una cuadrícula dentro del trazado como nuevas observaciones de la distribución del conjunto de datos y busque límites de clase asignando las coordenadas a una de las tres clases del conjunto de datos.

Cargue el conjunto de datos de iris de Fisher. Utilice las longitudes y anchuras de los pétalos como predictores.

load fisheriris X = meas(:,3:4); Y = species;

Examine un gráfico de dispersión de los datos.

figure gscatter(X(:,1),X(:,2),Y); h = gca; lims = [h.XLim h.YLim]; % Extract the x and y axis limits title('{\bf Scatter Diagram of Iris Measurements}'); xlabel('Petal Length (cm)'); ylabel('Petal Width (cm)'); legend('Location','Northwest');

Los datos contienen tres clases, una de las cuales es linealmente separable de las demás.

Para cada clase:

1. Cree un vector lógico ( ) que indique si una observación es miembro de la clase.indx

2. Entrene un clasificador SVM utilizando los datos del predictor y .indx

3. Almacene el clasificador en una celda de una matriz de celdas.

Defina el orden de clases.

SVMModels = cell(3,1); classes = unique(Y); rng(1); % For reproducibility  for j = 1:numel(classes)     indx = strcmp(Y,classes(j)); % Create binary classes for each classifier     SVMModels{j} = fitcsvm(X,indx,'ClassNames',[false true],'Standardize',true,...         'KernelFunction','rbf','BoxConstraint',1); end

es una matriz de celdas 3 por 1, con cada celda que contiene un clasificador.SVMModelsClassificationSVM Para cada celda, la clase positiva es setosa, versicolor y virginica, respectivamente.

Defina una cuadrícula fina dentro de la gráfica y trate las coordenadas como nuevas observaciones de la distribución de los datos de entrenamiento. Calcule la puntuación de las nuevas observaciones utilizando cada clasificador.

d = 0.02; [x1Grid,x2Grid] = meshgrid(min(X(:,1)):d:max(X(:,1)),...     min(X(:,2)):d:max(X(:,2))); xGrid = [x1Grid(:),x2Grid(:)]; N = size(xGrid,1); Scores = zeros(N,numel(classes));  for j = 1:numel(classes)     [~,score] = predict(SVMModels{j},xGrid);     Scores(:,j) = score(:,2); % Second column contains positive-class scores end

Cada fila de contiene tres puntuaciones.Scores El índice del elemento con la puntuación más grande es el índice de la clase a la que probablemente pertenece la nueva observación de clase.

Asocie cada nueva observación con el clasificador que le da la puntuación máxima.

[~,maxScore] = max(Scores,[],2);

Color en las regiones de la gráfica en función de la clase a la que pertenece la nueva observación correspondiente.

figure h(1:3) = gscatter(xGrid(:,1),xGrid(:,2),maxScore,...     [0.1 0.5 0.5; 0.5 0.1 0.5; 0.5 0.5 0.1]); hold on h(4:6) = gscatter(X(:,1),X(:,2),Y); title('{\bf Iris Classification Regions}'); xlabel('Petal Length (cm)'); ylabel('Petal Width (cm)'); legend(h,{'setosa region','versicolor region','virginica region',...     'observed setosa','observed versicolor','observed virginica'},...     'Location','Northwest'); axis tight hold off

Optimizar clasificador SVM

Optimice los hiperparámetros automáticamente utilizando .fitcsvm

Cargue el conjunto de datos.ionosphere

load ionosphere

Busque hiperparámetros que minimicen la pérdida de validación cruzada cinco veces mediante la optimización automática de hiperparámetros. Para reproducibilidad, establezca la semilla aleatoria y utilice la función de adquisición.'expected-improvement-plus'

rng default Mdl = fitcsvm(X,Y,'OptimizeHyperparameters','auto',...     'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName',...     'expected-improvement-plus'))

|=====================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstrain-|  KernelScale | |      | result |             | runtime     | (observed)  | (estim.)    | t            |              | |=====================================================================================================| |    1 | Best   |     0.21652 |      18.493 |     0.21652 |     0.21652 |       64.836 |    0.0015729 | |    2 | Accept |     0.35897 |     0.16509 |     0.21652 |     0.22539 |     0.036335 |       5.5755 | |    3 | Best   |     0.13105 |       7.131 |     0.13105 |     0.14152 |    0.0022147 |    0.0023957 | |    4 | Accept |     0.35897 |     0.10991 |     0.13105 |     0.13108 |       5.1259 |        98.62 | |    5 | Accept |      0.1339 |      14.513 |     0.13105 |     0.13111 |    0.0011599 |    0.0010098 | |    6 | Accept |     0.13105 |      3.3991 |     0.13105 |     0.13106 |    0.0010151 |    0.0045756 | |    7 | Best   |     0.12821 |      9.0972 |     0.12821 |     0.12819 |    0.0010563 |    0.0022307 | |    8 | Accept |      0.1339 |      11.601 |     0.12821 |     0.13013 |    0.0010113 |    0.0026572 | |    9 | Accept |     0.12821 |      6.4781 |     0.12821 |     0.12976 |    0.0010934 |    0.0022461 | |   10 | Accept |     0.12821 |      3.8203 |     0.12821 |     0.12933 |    0.0010315 |    0.0023551 | |   11 | Accept |      0.1396 |       17.31 |     0.12821 |     0.12954 |       994.04 |      0.20756 | |   12 | Accept |     0.13105 |      16.182 |     0.12821 |     0.12945 |       20.145 |     0.044584 | |   13 | Accept |     0.21368 |      18.317 |     0.12821 |     0.12787 |       903.79 |     0.056122 | |   14 | Accept |      0.1339 |     0.26202 |     0.12821 |     0.12939 |     0.018688 |     0.038639 | |   15 | Accept |     0.12821 |      2.8504 |     0.12821 |      0.1295 |       5.6464 |      0.15938 | |   16 | Accept |     0.13675 |      9.4282 |     0.12821 |     0.12798 |       0.5485 |     0.020716 | |   17 | Accept |     0.12821 |      6.5178 |     0.12821 |     0.12955 |       1.2899 |     0.063233 | |   18 | Accept |      0.1339 |      9.3664 |     0.12821 |     0.12957 |       869.51 |      0.94889 | |   19 | Accept |     0.13675 |       9.368 |     0.12821 |     0.12957 |       112.89 |      0.31231 | |   20 | Accept |     0.13105 |     0.12209 |     0.12821 |     0.12958 |    0.0010803 |      0.03695 | |=====================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstrain-|  KernelScale | |      | result |             | runtime     | (observed)  | (estim.)    | t            |              | |=====================================================================================================| |   21 | Accept |     0.13675 |      9.5117 |     0.12821 |      0.1299 |       7.7299 |     0.076169 | |   22 | Best   |     0.12536 |     0.17058 |     0.12536 |     0.13007 |    0.0010485 |     0.013248 | |   23 | Accept |     0.20228 |      18.202 |     0.12536 |     0.12548 |     0.060212 |    0.0010323 | |   24 | Accept |      0.1339 |     0.24592 |     0.12536 |     0.12556 |      0.30698 |      0.16097 | |   25 | Accept |      0.1339 |      15.142 |     0.12536 |     0.12923 |       963.05 |       0.5183 | |   26 | Accept |     0.13675 |     0.27628 |     0.12536 |     0.12888 |    0.0039748 |     0.015475 | |   27 | Accept |      0.1339 |      1.5718 |     0.12536 |     0.12889 |      0.33582 |     0.066787 | |   28 | Accept |      0.1339 |      15.411 |     0.12536 |     0.12884 |       4.2069 |     0.032774 | |   29 | Best   |     0.12536 |     0.13208 |     0.12536 |     0.12658 |    0.0010233 |     0.017839 | |   30 | Accept |     0.12536 |     0.13041 |     0.12536 |     0.12579 |    0.0010316 |     0.019592 |  __________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 249.4758 seconds. Total objective function evaluation time: 225.3244  Best observed feasible point:     BoxConstraint    KernelScale     _____________    ___________        0.0010233       0.017839    Observed objective function value = 0.12536 Estimated objective function value = 0.12579 Function evaluation time = 0.13208  Best estimated feasible point (according to models):     BoxConstraint    KernelScale     _____________    ___________        0.0010233       0.017839    Estimated objective function value = 0.12579 Estimated function evaluation time = 0.1535 

Mdl =    ClassificationSVM                          ResponseName: 'Y'                 CategoricalPredictors: []                            ClassNames: {'b'  'g'}                        ScoreTransform: 'none'                       NumObservations: 351     HyperparameterOptimizationResults: [1×1 BayesianOptimization]                                 Alpha: [91×1 double]                                  Bias: -5.6976                      KernelParameters: [1×1 struct]                        BoxConstraints: [351×1 double]                       ConvergenceInfo: [1×1 struct]                       IsSupportVector: [351×1 logical]                                Solver: 'SMO'     Properties, Methods  

Argumentos de entrada

Tbl — Datos de muestra

Mesa

Datos de ejemplo utilizados para entrenar el modelo, especificados como una tabla. Cada fila de corresponde a una observación y cada columna corresponde a una variable predictora.Tbl Opcionalmente, puede contener una columna adicional para la variable de respuesta.Tbl No se permiten variables de varias columnas y matrices de celdas distintas de las matrices de celdas de vectores de caracteres.

Si contiene la variable de respuesta y desea utilizar todas las variables restantes como predictores, especifique la variable de respuesta mediante .TblTblResponseVarName

Si contiene la variable de respuesta y desea utilizar solo un subconjunto de las variables restantes como predictores, especifique una fórmula mediante .TblTblFórmula

Si no contiene la variable de respuesta, especifique una variable de respuesta mediante .TblY La longitud de la variable de respuesta y el número de filas deben ser iguales.Tbl

Tipos de datos: table

ResponseVarName — Nombre de la variable de respuesta

nombre de la variable enTbl

Nombre de la variable de respuesta, especificado como el nombre de una variable en .Tbl

Debe especificar como vector de caracteres o escalar de cadena.ResponseVarName Por ejemplo, si la variable de respuesta se almacena como , especifice como .YTbl.Y'Y' De lo contrario, el software trata todas las columnas de , incluidos , como predictores al entrenar el modelo.TblY

La variable de respuesta debe ser una matriz categórica, de carácter o de cadena, un vector lógico o numérico o una matriz de celdas de vectores de caracteres. Si es una matriz de caracteres, cada elemento de la variable de respuesta debe corresponder a una fila de la matriz.Y

Se recomienda especificar el orden de las clases mediante el argumento de par nombre-valor.ClassNames

Tipos de datos: char | string

formula — Modelo explicativo de variable de respuesta y subconjunto de variables predictoras

vector de caracteres | cuerda escalar

Modelo explicativo de la variable de respuesta y un subconjunto de las variables predictoras, especificadas como vector de caracteres o escalar de cadena en el formulario.'Y~X1+X2+X3' En este formulario, representa la variable de respuesta y , , y representa las variables predictoras.YX1X2X3

Para especificar un subconjunto de variables como predictores para entrenar el modelo, utilice una fórmula.Tbl Si especifica una fórmula, el software no utiliza ninguna variable que no aparezca en .TblFórmula

Los nombres de variable de la fórmula deben ser ambos nombres de variable en ( ) como identificadores válidos.TblTbl.Properties.VariableNamesMATLAB^®

Puede verificar los nombres de las variables mediante la función.Tblisvarname El código siguiente devuelve logical ( ) para cada variable que tiene un nombre de variable válido.1true Si los nombres de variable en no son válidos, a continuación, convertirlos mediante la función.

cellfun(@isvarname,Tbl.Properties.VariableNames)

Tblmatlab.lang.makeValidName

Tbl.Properties.VariableNames = matlab.lang.makeValidName(Tbl.Properties.VariableNames);

Tipos de datos: char | string

Y — Etiquetas de clase

matriz categórica | matriz de caracteres | matriz de cadenas | vector lógico | vector numérico | matriz celular de vectores de caracteres

Etiquetas de clase a las que se entrena el modelo SVM, especificadas como una matriz categórica, de carácter o de cadena, un vector lógico o numérico o una matriz de celdas de vectores de caracteres.

• debe contener como máximo dos clases distintas.Y Para el aprendizaje multiclase, consulte .fitcecoc

• Si es una matriz de caracteres, cada elemento de las etiquetas de clase debe corresponder a una fila de la matriz.Y

• La longitud y el número de filas en o deben ser iguales.YTblX

• Se recomienda especificar el orden de clases mediante el argumento de par nombre-valor.ClassNames

Tipos de datos: categorical | char | string | logical | single | double | cell

X — Datos del predictor

matriz de valores numéricos

Datos del predictor para los que se entrena el clasificador SVM, especificados como una matriz de valores numéricos.

Cada fila de corresponde a una observación (también conocida como instancia o ejemplo) y cada columna corresponde a un predictor (también conocido como entidad).X

La longitud y el número de filas deben ser iguales.YX

Para especificar los nombres de los predictores en el orden de su aparición en , utilice el argumento de par nombre-valor.X'PredictorNames'

Tipos de datos: double | single

Argumentos de par nombre-valor

Especifique pares opcionales separados por comas de argumentos. es el nombre del argumento y es el valor correspondiente. deben aparecer entre comillas.Name,ValueNameValueName Puede especificar varios argumentos de par de nombre y valor en cualquier orden como .Name1,Value1,...,NameN,ValueN

Ejemplo: realiza 10 veces la validación cruzada, aplica el doble de la penalización a falsos positivos en comparación con los falsos negativos y transforma las puntuaciones mediante la función de signo.fitcsvm(X,Y,'KFold',10,'Cost',[0 2;1 0],'ScoreTransform','sign')

Opciones de SVM

'BoxConstraint' — Restricción de caja

1 (predeterminado) | escalar positivo

, especificado como el par separado por comas que consta de un escalar positivo.Restricción de caja'BoxConstraint'

Para el aprendizaje de una clase, el software siempre establece la restricción de caja en .1

Para obtener más detalles sobre las relaciones y el comportamiento algorítmico de , , , , y , consulte .BoxConstraintCostPriorStandardizeWeightsAlgoritmos

Ejemplo: 'BoxConstraint',100

Tipos de datos: double | single

'KernelFunction' — Función del núcleo

'linear' | 'gaussian' | 'rbf' | 'polynomial' | nombre de la función

Función Kernel utilizada para calcular los elementos del archivo , especificado como el par separado por comas que consta de y un nombre de función del kernel.Matriz de Gram'KernelFunction' Supongamos que (GX_j,X_k) es el elemento ( , ) de la matriz Gram, dondejk X_j Y X_k son vectores dimensionales que representan observaciones y en .pjkX En esta tabla se describen los nombres de las funciones del kernel compatibles y sus formas funcionales.

Nombre de la función del núcleo	Descripción	Fórmula
O'gaussian''rbf'	Kernel Gaussian o Radial Basis Function (RBF), por defecto para el aprendizaje de una clase	$$G\left(x_j,x_k\right)=\exp \left(-{\Vert x_j-x_k\Vert }^2\right)$$
'linear'	Núcleo lineal, predeterminado para el aprendizaje de dos clases	$$G(x_j,x_k)=x_j\prime x_k$$
'polynomial'	Kernel polinómito. Uso 'PolynomialOrder',q para especificar un núcleo polinómio de orden q.	$$G(x_j,x_k)={(1+x_j\prime x_k)}^q$$

Puede configurar su propia función de kernel, por ejemplo, , estableciendo .kernel'KernelFunction','kernel' El valor debe tener este formulario. Dónde:kernel

function G = kernel(U,V)

• es una matriz por.Ump Las columnas corresponden a variables predictoras y las filas corresponden a observaciones.

• es una matriz por.Vnp Las columnas corresponden a variables predictoras y las filas corresponden a observaciones.

• es un -by- de las filas de y .GmnMatriz de GramUV

debe estar en el camino.kernel.mMATLAB

Es una buena práctica evitar el uso de nombres genéricos para las funciones del kernel. Por ejemplo, llame a una función de kernel sigmoid en lugar de .'mysigmoid''sigmoid'

Ejemplo: 'KernelFunction','gaussian'

Tipos de datos: char | string

'KernelScale' — Parámetro de escala del núcleo

1 (predeterminado) | 'auto' | escalar positivo

Parámetro de escala del núcleo, especificado como el par separado por comas que consta de o un escalar positivo.'KernelScale''auto' El software divide todos los elementos de la matriz predictora por el valor de .XKernelScale A continuación, el software aplica la norma de kernel adecuada para calcular la matriz Gram.

• Si especifica , el software selecciona un factor de escala adecuado mediante un procedimiento heurístico.'auto' Este procedimiento heurístico utiliza submuestreo, por lo que las estimaciones pueden variar de una llamada a otra. Por lo tanto, para reproducir los resultados, establezca un número aleatorio de semilla según el entrenamiento.rng

• Si especifica y su propia función de kernel, por ejemplo, , el software produce un error.KernelScale'KernelFunction','kernel' Debe aplicar el escalado dentro de .kernel

Ejemplo: 'KernelScale','auto'

Tipos de datos: double | single | char | string

'PolynomialOrder' — Orden de la función del núcleo polinómiqueo

3 (predeterminado) | entero positivo

Orden de la función del núcleo polinómiqueo, especificado como el par separado por comas que consta de y un entero positivo.'PolynomialOrder'

Si establece y no lo es, el software produce un error.'PolynomialOrder'KernelFunction'polynomial'

Ejemplo: 'PolynomialOrder',2

Tipos de datos: double | single

'KernelOffset' — Parámetro de desplazamiento del núcleo

escalar no negativo

Parámetro de desplazamiento del núcleo, especificado como el par separado por comas que consta de un escalar no negativo.'KernelOffset'

El software se añade a cada elemento de la matriz Gram.KernelOffset

Los valores predeterminados son:

• si el solucionador es SMO (es decir, se establece)0'Solver','SMO'

• si el solucionador es ISDA (es decir, se establece)0.1'Solver','ISDA'

Ejemplo: 'KernelOffset',0

Tipos de datos: double | single

'Standardize' — Bandera para estandarizar los datos del predictor

false (predeterminado) | true

Marcar para estandarizar los datos del predictor, especificados como el par separado por comas que consta de y ( ) o .'Standardize'true1false(0)

Si establece:'Standardize',true

• El software centra y escala cada variable predictora ( o ) por la media de columna ponderada correspondiente y la desviación estándar.XTbl Para obtener más información sobre la estandarización ponderada, consulte . no estandariza los datos contenidos en las columnas de variables ficticias generadas para los predictores categóricos.AlgoritmosMATLAB

• El software entrena el clasificador utilizando los predictores estandarizados, pero almacena los predictores no estandarizados como una matriz o tabla en la propiedad clasificadora.X

Ejemplo: 'Standardize',true

Tipos de datos: logical

'Solver' — Rutina de optimización

'ISDA' | 'L1QP' | 'SMO'

Rutina de optimización, especificada como el par separado por comas que consta de y un valor en esta tabla.'Solver'

Valor	Descripción
'ISDA'	Algoritmo iterativo de datos únicos (véase )[30]
'L1QP'	Se utiliza para implementar 1 minimización de margen suave mediante programación cuadrática.quadprog (Optimization Toolbox)L Esta opción requiere una licencia.Optimization Toolbox™ Para obtener más información, consulte .Definición de programación cuadrática (Optimization Toolbox)
'SMO'	Optimización mínima secuencial (consulte )[17]

El valor predeterminado es para el aprendizaje de dos clases o si establece en un valor positivo y, de lo contrario.'ISDA''OutlierFraction''SMO'

Ejemplo: 'Solver','ISDA'

'Alpha' — Estimaciones iniciales de coeficientes alfa

vector numérico de valores no negativos

Estimaciones iniciales de coeficientes alfa, especificadas como el par separado por comas que consta de y un vector numérico de valores no negativos.'Alpha' La longitud de debe ser igual al número de filas en .AlphaX

• Cada elemento de corresponde a una observación en .'Alpha'X

• no puede contener ninguna s.'Alpha'NaN

• Si especifica y cualquiera de los argumentos de par nombre-valor de validación cruzada ( , , , , o ), el software devuelve un error.'Alpha''CrossVal''CVPartition''Holdout''KFold''Leaveout'

Si contiene los valores que faltan, quite todas las filas de , , y que correspondan a los valores que faltan.YYX'Alpha' Es decir, escriba: Then pass , , y como respuesta, predictores y estimaciones alfa iniciales, respectivamente.

idx = ~isundefined(categorical(Y)); Y = Y(idx,:); X = X(idx,:); alpha = alpha(idx);

YXalpha

Los valores predeterminados son:

• para el aprendizaje de una clase0.5*ones(size(X,1),1)

• para el aprendizaje de dos claseszeros(size(X,1),1)

Ejemplo: 'Alpha',0.1*ones(size(X,1),1)

Tipos de datos: double | single

'CacheSize' — Tamaño de caché

1000 (predeterminado) | 'maximal' | escalar positivo

Tamaño de caché, especificado como el par separado por comas que consta de o un escalar positivo.'CacheSize''maximal'

Si es , entonces el software reserva suficiente memoria para contener todo el -by- .CacheSize'maximal'nnMatriz de Gram

Si es un escalar positivo, el software reserva megabytes de memoria para entrenar el modelo.CacheSizeCacheSize

Ejemplo: 'CacheSize','maximal'

Tipos de datos: double | single | char | string

'ClipAlphas' — Coeficientes alfa de marca a clip

true (predeterminado) | false

Marcar para recortar coeficientes alfa, especificados como el par separado por comas que consta de y o .'ClipAlphas'truefalse

Supongamos que el coeficiente alfa para la observación esj Α_j y la restricción de observación de la caja esj C_j, 1,..., , dónde está el tamaño de la muestra de entrenamiento.jnn

Valor	Descripción
true	En cada iteración, si Αj está cerca de 0 o cerca Cj, a continuación, estableceMATLAB Αj 0 o a CjRespectivamente.
false	no cambia los coeficientes alfa durante la optimización.MATLAB

almacena los valores finales de en la propiedad del objeto de modelo SVM entrenado.MATLABαAlpha

puede afectar a la convergencia SMO e ISDA.ClipAlphas

Ejemplo: 'ClipAlphas',false

Tipos de datos: logical

'Nu' — parámetro para el aprendizaje de una claseν

0.5 (predeterminado) | escalar positivo

parámetro para , especificado como el par separado por comas que consta de y un escalar positivo. debe ser mayor que y a lo sumo .νAprendizaje de una clase'Nu'Nu01

Establecer para controlar el equilibrio entre asegurarse de que la mayoría de los ejemplos de entrenamiento están en la clase positiva y minimizar los pesos en la función de puntuación.Nu

Ejemplo: 'Nu',0.25

Tipos de datos: double | single

'NumPrint' — Número de iteraciones entre la salida de mensajes de diagnóstico de optimización

1000 (predeterminado) | entero no negativo

Número de iteraciones entre la salida del mensaje de diagnóstico de optimización, especificado como el par separado por comas que consta de un entero no negativo.'NumPrint'

Si especifica y , el software muestra todos los mensajes de diagnóstico de optimización de SMO e ISDA cada iteración en la ventana de comandos.'Verbose',1'NumPrint',numprintnumprint

Ejemplo: 'NumPrint',500

Tipos de datos: double | single

'OutlierFraction' — Proporción esperada de valores atípicos en los datos de formación

0 (predeterminado) | escalar numérico en el intervalo [0,1)

Proporción esperada de valores atípicos en los datos de entrenamiento, especificada como el par separado por comas que consta de y un escalar numérico en el intervalo [0,1).'OutlierFraction'

Supongamos que establece , donde es un valor mayor que 0.'OutlierFraction',outlierfractionoutlierfraction

• Para el aprendizaje de dos clases, el software implementa .aprendizaje robusto En otras palabras, el software intenta eliminar el 100 * % de las observaciones cuando converge el algoritmo de optimización.outlierfraction Las observaciones eliminadas corresponden a gradientes de gran magnitud.

• Para el aprendizaje de una clase, el software encuentra un término de sesgo adecuado tal que de las observaciones en el conjunto de entrenamiento tienen puntuaciones negativas.outlierfraction

Ejemplo: 'OutlierFraction',0.01

Tipos de datos: double | single

'RemoveDuplicates' — Bandera para reemplazar observaciones duplicadas por observaciones individuales

false (predeterminado) | true

Marcador para reemplazar observaciones duplicadas por observaciones individuales en los datos de entrenamiento, especificadas como el par separado por comas que consta de y o .'RemoveDuplicates'truefalse

Si es , entoncesRemoveDuplicatestrue fitcsvm reemplaza las observaciones duplicadas en los datos de entrenamiento por una sola observación del mismo valor. El peso de la observación única es igual a la suma de los pesos de los duplicados eliminados correspondientes (véase ).Weights

Sugerencia

Si el conjunto de datos contiene muchas observaciones duplicadas, especificar puede reducir considerablemente el tiempo de convergencia.'RemoveDuplicates',true

Tipos de datos: logical

'Verbose' — Nivel de verbosidad

0 (predeterminado) | 1 | 2

Nivel de detalle, especificado como el par separado por comas que consta de y , , o .'Verbose'012 El valor de controla la cantidad de información de optimización que el software muestra en la ventana de comandos y guarda la información como una estructura en .VerboseMdl.ConvergenceInfo.History

En esta tabla se resumen las opciones de nivel de detalle disponibles.

Valor	Descripción
0	El software no muestra ni guarda la información de convergencia.
1	El software muestra mensajes de diagnóstico y guarda los criterios de convergencia cada iteración, donde está el valor del argumento de par nombre-valor.numprintnumprint'NumPrint'
2	El software muestra mensajes de diagnóstico y guarda los criterios de convergencia en cada iteración.

Ejemplo: 'Verbose',1

Tipos de datos: double | single

Otras opciones de clasificación

'CategoricalPredictors' — Lista de predictores categóricos

vector de enteros positivos | vector lógico | matriz de caracteres | matriz de cadenas | matriz celular de vectores de caracteres | 'all'

Lista de predictores categóricos, especificada como el par separado por comas que consta de y uno de los valores de esta tabla.'CategoricalPredictors'

Valor	Descripción
Vector de enteros positivos	Cada entrada del vector es un valor de índice correspondiente a la columna de los datos predictores ( o ) que contiene una variable categórica.XTbl
Vector lógico	Una entrada significa que la columna correspondiente de datos predictores ( o ) es una variable categórica.trueXTbl
Matriz de caracteres	Cada fila de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas de .PredictorNames Rellena los nombres con espacios en blanco adicionales para que cada fila de la matriz de caracteres tenga la misma longitud.
Matriz de cadenas o matriz de celdas de vectores de caracteres	Cada elemento de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas de .PredictorNames
'todos'	Todos los predictores son categóricos.

De forma predeterminada, si los datos del predictor están en una tabla ( ),Tbl fitcsvm supone que una variable es categórica si es un vector lógico, vector categórico, matriz de caracteres, matriz de cadenas o matriz de celdas de vectores de caracteres. Si los datos del predictor son una matriz ( ),X fitcsvm asume que todos los predictores son continuos. Para identificar cualquier otro predictor como predictores categóricos, escépéscalos mediante el argumento de par nombre-valor.'CategoricalPredictors'

Para los predictores categóricos identificados, fitcsvm crea variables ficticias utilizando dos esquemas diferentes, dependiendo de si una variable categórica está desordenada u ordenada. Para obtener más información, consulte .Automatic Creation of Dummy Variables

Ejemplo: 'CategoricalPredictors','all'

Tipos de datos: single | double | logical | char | string | cell

'ClassNames' — Nombres de las clases a utilizar para la formación

matriz categórica | matriz de caracteres | matriz de cadenas | vector lógico | vector numérico | matriz celular de vectores de caracteres

Nombres de clases que se usan para el entrenamiento, especificados como el par separado por comas que consta de y una matriz categórica, de carácter o de cadena, un vector lógico o numérico, o una matriz de celdas de vectores de caracteres. debe tener el mismo tipo de datos que .'ClassNames'ClassNamesY

Si es una matriz de caracteres, cada elemento debe corresponder a uno de la matriz.ClassNamesFila

Utilícelo para:ClassNames

• Ordene las clases durante el entrenamiento.

• Especifique el orden de cualquier dimensión de argumento de entrada o salida que corresponda al orden de clases. Por ejemplo, se utiliza para especificar el orden de las dimensiones o el orden de columna de las puntuaciones de clasificación devueltas por .ClassNamesCostpredict

• Seleccione un subconjunto de clases para el entrenamiento. Por ejemplo, supongamos que el conjunto de todos los nombres de clase distintos en es .Y{'a','b','c'} Para entrenar el modelo mediante observaciones de clases y solo, especifique .'a''c''ClassNames',{'a','c'}

El valor predeterminado para es el conjunto de todos los nombres de clase distintos en .ClassNamesY

Ejemplo: 'ClassNames',{'b','g'}

Tipos de datos: categorical | char | string | logical | single | double | cell

'Cost' — Coste de clasificación errónea

matriz cuadrada | matriz de estructura

Coste de clasificación incorrecta especificado como el par separado por comas que consta de una matriz cuadrada o matriz de estructura.'Cost'

• Si especifica la matriz cuadrada y la clase verdadera de una observación es , entonces es el costo de clasificar un punto en clase .CostiCost(i,j)j Es decir, las filas corresponden a las clases y columnas verdaderas corresponden a clases predichas. Para especificar el orden de clases para las filas y columnas correspondientes de , especifique también el argumento de par nombre-valor.CostClassNames

• Si especifica la estructura , debe tener dos campos:S

  • , que contiene los nombres de clase como una variable del mismo tipo de datos queS.ClassNamesY

  • , que contiene la matriz de costes con filas y columnas ordenadas como enS.ClassificationCostsS.ClassNames

Para el aprendizaje de dos clases, si especifica una matriz de costes, el software actualiza las probabilidades anteriores incorporando las penalizaciones descritas en la matriz de costes. Por consiguiente, la matriz de costes se restablece al valor predeterminado. Para obtener más detalles sobre las relaciones y el comportamiento algorítmico de , , , , y , consulte .BoxConstraintCostPriorStandardizeWeightsAlgoritmos

Los valores predeterminados son:

• para el aprendizaje de una claseCost = 0

• si y si para el aprendizaje de dos clasesCost(i,j) = 1i ~= jCost(i,j) = 0i = j

Ejemplo: 'Cost',[0,1;2,0]

Tipos de datos: double | single | struct

'PredictorNames' — Nombres de variables predictoras

matriz de cadenas de nombres únicos | matriz de células de vectores de caracteres únicos

Nombres de variables predictoras, especificados como el par separado por comas que consta de y una matriz de cadenas de nombres únicos o matriz de celdas de vectores de caracteres únicos.'PredictorNames' La funcionalidad de depende de la forma en que proporcione los datos de entrenamiento.'PredictorNames'

• Si proporciona y , entonces puede utilizar para dar las variables predictoras en los nombres.XY'PredictorNames'X

  • El orden de los nombres en debe corresponder al orden de columna de .PredictorNamesX Es decir, es el nombre de , es el nombre de , y así sucesivamente.PredictorNames{1}X(:,1)PredictorNames{2}X(:,2) Además, y debe ser igual.size(X,2)numel(PredictorNames)

  • De forma predeterminada, es .PredictorNames{'x1','x2',...}

• Si proporciona , entonces puede utilizar para elegir qué variables predictoras utilizar en el entrenamiento.Tbl'PredictorNames' Es decir fitcsvm utiliza sólo las variables predictoras en y la variable de respuesta en el entrenamiento.PredictorNames

  • debe ser un subconjunto de y no puede incluir el nombre de la variable de respuesta.PredictorNamesTbl.Properties.VariableNames

  • De forma predeterminada, contiene los nombres de todas las variables predictoras.PredictorNames

  • Es una buena práctica especificar los predictores para el entrenamiento usando uno o solo.'PredictorNames'Fórmula

Ejemplo: 'PredictorNames',{'SepalLength','SepalWidth','PetalLength','PetalWidth'}

Tipos de datos: string | cell

'Prior' — Probabilidades anteriores

'empirical' (predeterminado) | 'uniform' | vector numérico | matriz de estructura

Probabilidades anteriores para cada clase, especificadas como el par separado por comas que consta de y un valor en esta tabla.'Prior'

Valor	Descripción
'empirical'	Las probabilidades anteriores de la clase son las frecuencias relativas de la clase en .Y
'uniform'	Todas las probabilidades anteriores de clase son iguales a 1/ , donde está el número de clases.KK
vector numérico	Cada elemento del vector es una probabilidad previa de clase. Ordene los elementos según o especifique el orden utilizando el argumento de par nombre-valor.Mdl.ClassNamesClassNames El software normaliza los elementos a sumar a .1
Estructura	Una estructura con dos campos:S contiene los nombres de clase como una variable del mismo tipo que .S.ClassNamesY contiene un vector de las probabilidades anteriores correspondientes.S.ClassProbs El software normaliza los elementos del vector a sumar a .1

Para el aprendizaje de dos clases, si especifica una matriz de costes, el software actualiza las probabilidades anteriores incorporando las penalizaciones descritas en la matriz de costes. Para obtener más detalles sobre las relaciones y el comportamiento algorítmico de , , , , y , consulte .BoxConstraintCostPriorStandardizeWeightsAlgoritmos

Ejemplo: struct('ClassNames',{{'setosa','versicolor','virginica'}},'ClassProbs',1:3)

Tipos de datos: char | string | double | single | struct

'ResponseName' — Nombre de la variable de respuesta

'Y' (predeterminado) | vector de caracteres | cuerda escalar

Nombre de la variable de respuesta, especificado como el par separado por comas que consta de un vector de caracteres o un escalar de cadena.'ResponseName'

• Si proporciona , puede usar para especificar un nombre para la variable de respuesta.Y'ResponseName'

• Si suministra o , entonces no puede utilizar .ResponseVarNameFórmula'ResponseName'

Ejemplo: 'ResponseName','response'

Tipos de datos: char | string

'ScoreTransform' — Transformación de puntuación

'none' (predeterminado) | 'doublelogit' | 'invlogit' | 'ismax' | 'logit' | manija de la función | ...

Transformación de puntuación, especificada como el par separado por comas que consta de un vector de caracteres, un escalar de cadena o un identificador de función.'ScoreTransform'

En esta tabla se resumen los vectores de caracteres disponibles y los escalares de cadena.

Valor	Descripción
'doublelogit'	1/(1 +e–2x)
'invlogit'	log( / (1 – ))xx
'ismax'	Establece la puntuación de la clase con la puntuación más alta en , y establece las puntuaciones de todas las demás clases en10
'logit'	1/(1 +e–x)
O'none''identity'	(sin transformación)x
'sign'	–1 para <0 0 para 0 0 para 0 1 para > 0x x x
'symmetric'	2 – 1x
'symmetricismax'	Establece la puntuación de la clase con la puntuación más alta en , y establece las puntuaciones de todas las demás clases en1–1
'symmetriclogit'	2/(1 +e–x) – 1

Para una función o una función que defina, utilice su identificador de función para la transformación de puntuación.MATLAB El identificador de función debe aceptar una matriz (las puntuaciones originales) y devolver una matriz del mismo tamaño (las puntuaciones transformadas).

Ejemplo: 'ScoreTransform','logit'

Tipos de datos: char | string | function_handle

'Weights' — Pesos de observación

vector numérico | nombre de la variable enTbl

Pesos de observación, especificados como el par separado por comas que consta de un vector numérico de valores positivos o el nombre de una variable en .'Weights'Tbl El software sopesa las observaciones en cada fila de o con el valor correspondiente en .XTblWeights El tamaño de debe ser igual al número de filas en o .WeightsXTbl

Si especifica los datos de entrada como una tabla , puede ser el nombre de una variable que contenga un vector numérico.TblWeightsTbl En este caso, debe especificar como vector de caracteres o escalar de cadena.Weights Por ejemplo, si el vector de ponderaciones se almacena como , especifice como .WTbl.W'W' De lo contrario, el software trata todas las columnas de , incluidos , como predictores o la variable de respuesta al entrenar el modelo.TblW

De forma predeterminada, esWeights ones(n,1)Dónde n es el número de observaciones en o .XTbl

El software se normaliza para sumar hasta el valor de la probabilidad anterior en la clase respectiva.Weights Para obtener más detalles sobre las relaciones y el comportamiento algorítmico de , , , , y , consulte .BoxConstraintCostPriorStandardizeWeightsAlgoritmos

Tipos de datos: double | single | char | string

Nota

No puede utilizar ningún argumento de par nombre-valor de validación cruzada junto con el argumento de par nombre-valor.'OptimizeHyperparameters' Puede modificar la validación cruzada solo mediante el argumento de par nombre-valor.'OptimizeHyperparameters''HyperparameterOptimizationOptions'

Opciones de validación cruzada

'CrossVal' — Bandera para entrenar clasificador oriundo

'off' (predeterminado) | 'on'

Marcar para entrenar un clasificador validado cruzado, especificado como el par separado por comas que consta de y o .'Crossval''on''off'

Si especifica , el software entrena un clasificador validado cruzadamente con 10 pliegues.'on'

Puede invalidar esta configuración de validación cruzada mediante el argumento de par , , o nombre-valor.CVPartitionHoldoutKFoldLeaveout Solo puede usar un argumento de par nombre-valor de validación cruzada a la vez para crear un modelo validado entre sí.

Alternativamente, valide más adelante pasando a .Mdlcrossval

Ejemplo: 'Crossval','on'

'CVPartition' — Partición de validación cruzada

[] (predeterminado) | objeto de particióncvpartition

Partición de validación cruzada, especificada como el par separado por comas que consta de y un objeto de partición creado por .'CVPartition'cvpartitioncvpartition El objeto de partición especifica el tipo de validación cruzada y la indexación de los conjuntos de entrenamiento y validación.

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Ejemplo: Supongamos que crea una partición aleatoria para la validación cruzada de 5 veces en 500 observaciones mediante .cvp = cvpartition(500,'KFold',5) A continuación, puede especificar el modelo validado entre cruces mediante .'CVPartition',cvp

'Holdout' — Fracción de datos para la validación de retención

valor escalar en el rango (0,1)

Fracción de los datos utilizados para la validación de retención, especificada como el par separado por comas que consta de y un valor escalar en el intervalo (0,1).'Holdout' Si usted especifica, después el software completa estos pasos:'Holdout',p

1. Seleccione y reserve aleatoriamente % de los datos como datos de validación y entrene el modelo con el resto de los datos.p*100

2. Almacene el modelo compacto y entrenado en la propiedad del modelo validado de forma cruzada.Trained

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'Holdout',0.1

Tipos de datos: double | single

'KFold' — Número de pliegues

10 (predeterminado) | valor entero positivo mayor que 1

Número de pliegues que se van a utilizar en un modelo validado por cruz, especificado como el par separado por comas que consta de y un valor entero positivo mayor que 1.'KFold' Si usted especifica, después el software completa estos pasos:'KFold',k

1. Particione aleatoriamente los datos en conjuntos.k

2. Para cada conjunto, reserve el conjunto como datos de validación y entrene el modelo con el otro k – 1 Establece.

3. Almacene los modelos compactos y entrenados en las celdas de un vector de celda -by-1 en la propiedad del modelo validado cruzadamente.kkTrained

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'KFold',5

Tipos de datos: single | double

'Leaveout' — Dejar un indicador de validación cruzada

'off' (predeterminado) | 'on'

Deje el indicador de validación cruzada uno-out, especificado como el par separado por comas que consta de y o .'Leaveout''on''off' Si especifica , entonces, para cada una de las observaciones (donde está el número de observaciones excluyendo las observaciones faltantes, especificadas en la propiedad del modelo), el software completa estos pasos:'Leaveout','on'nnNumObservations

1. Reserve la observación como datos de validación y entrene el modelo utilizando las otras observaciones – 1.n

2. Almacene los modelos compactos y entrenados en las celdas de un vector de celda -by-1 en la propiedad del modelo validado cruzadamente.nnTrained

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'Leaveout','on'

Opciones de control de convergencia

'DeltaGradientTolerance' — Tolerancia a la diferencia de gradiente

escalar no negativo

Tolerancia para la diferencia de degradado entre los infractores superior e inferior obtenidos por La optimización mínima secuencial (SMO) o el algoritmo iterativo de datos únicos (ISDA), especificado como el par separado por comas que consta de un escalar no negativo.'DeltaGradientTolerance'

Si es , entonces el software no utiliza la tolerancia para la diferencia de gradiente para comprobar la convergencia de optimización.DeltaGradientTolerance0

Los valores predeterminados son:

• si el solucionador es SMO (por ejemplo, se establece )1e-3'Solver','SMO'

• si el solucionador es ISDA (por ejemplo, se establece)0'Solver','ISDA'

Ejemplo: 'DeltaGradientTolerance',1e-2

Tipos de datos: double | single

'GapTolerance' — Tolerancia a la brecha de viabilidad

0 (predeterminado) | escalar no negativo

Tolerancia de separación de viabilidad obtenida por SMO o ISDA, especificada como el par separado por comas que consta de un escalar no negativo.'GapTolerance'

Si es , entonces el software no utiliza la tolerancia de separación de viabilidad para comprobar la convergencia de optimización.GapTolerance0

Ejemplo: 'GapTolerance',1e-2

Tipos de datos: double | single

'IterationLimit' — Número máximo de iteraciones de optimización numérica

1e6 (predeterminado) | entero positivo

Número máximo de iteraciones de optimización numérica, especificado como el par separado por comas que consta de y un entero positivo.'IterationLimit'

El software devuelve un modelo entrenado independientemente de si la rutina de optimización converge correctamente. contiene información de convergencia.Mdl.ConvergenceInfo

Ejemplo: 'IterationLimit',1e8

Tipos de datos: double | single

'KKTTolerance' — Karush-Kuhn-Tucker complementariedades tolerancia de violación

escalar no negativo

tolerancia a la infracción, especificada como el par separado por comas que consta de un escalar no negativo.Condiciones de complementariedad de Karush-Kuhn-Tucker (KKT)'KKTTolerance'

Si es , entonces el software no utiliza la tolerancia de violación de las condiciones de complementariedad KKT para comprobar la convergencia de optimización.KKTTolerance0

Los valores predeterminados son:

• si el solucionador es SMO (por ejemplo, se establece )0'Solver','SMO'

• si el solucionador es ISDA (por ejemplo, se establece)1e-3'Solver','ISDA'

Ejemplo: 'KKTTolerance',1e-2

Tipos de datos: double | single

'ShrinkagePeriod' — Número de iteraciones entre reducciones del conjunto activo

0 (predeterminado) | entero no negativo

Número de iteraciones entre las reducciones del conjunto activo, especificado como el par separado por comas que consta de un entero no negativo.'ShrinkagePeriod'

Si establece , el software no reduce el conjunto activo.'ShrinkagePeriod',0

Ejemplo: 'ShrinkagePeriod',1000

Tipos de datos: double | single

Opciones de optimización de hiperparámetros

'OptimizeHyperparameters' — Parámetros para optimizar

'none' (predeterminado) | 'auto' | 'all' | matriz de cadenas o matriz de celdas de nombres de parámetros elegibles | vector de objetosoptimizableVariable

Parámetros para optimizar, especificados como el par separado por comas que consta de y uno de estos valores:'OptimizeHyperparameters'

• — No optimizar.'none'

• — Utilice .'auto'{'BoxConstraint','KernelScale'}

• — Optimizar todos los parámetros elegibles.'all'

• Matriz de cadenas o matriz de celdas de nombres de parámetros elegibles.

• Vector de objetos, normalmente la salida de .optimizableVariablehyperparameters

La optimización intenta minimizar la pérdida de validación cruzada (error) para variar los parámetros.fitcsvm Para obtener información sobre la pérdida de validación cruzada, consulte .Classification Loss Para controlar el tipo de validación cruzada y otros aspectos de la optimización, utilice el argumento de par nombre-valor.HyperparameterOptimizationOptions

Nota

los valores reemplazan los valores que establezca utilizando otros argumentos de par nombre-valor.'OptimizeHyperparameters' Por ejemplo, establecer para hacer que se apliquen los valores.'OptimizeHyperparameters''auto''auto'

Los parámetros elegibles para son:fitcsvm

• — búsquedas entre valores positivos, por defecto escalado de registro en el rango .BoxConstraintfitcsvm[1e-3,1e3]

• — búsquedas entre valores positivos, por defecto escalado de registro en el rango .KernelScalefitcsvm[1e-3,1e3]

• — búsquedas entre , , y .KernelFunctionfitcsvm'gaussian''linear''polynomial'

• — búsquedas entre enteros en el rango .PolynomialOrderfitcsvm[2,4]

• — búsquedas entre y .Standardizefitcsvm'true''false'

Establezca parámetros no predeterminados pasando un vector de objetos que tengan valores no predeterminados.optimizableVariable Por ejemplo:

load fisheriris params = hyperparameters('fitcsvm',meas,species); params(1).Range = [1e-4,1e6];

Pase como el valor de .paramsOptimizeHyperparameters

De forma predeterminada, la visualización iterativa aparece en la línea de comandoy los trazados aparecen según el número de hiperparámetros de la optimización. Para la optimización y las gráficas, la función objetivo es log(1 + cross-validation loss) para la regresión y la tasa de clasificación errónea para la clasificación. Para controlar la visualización iterativa, establezca el campo del argumento de par nombre-valor.Verbose'HyperparameterOptimizationOptions' Para controlar los trazados, establezca el campo del argumento de par nombre-valor.ShowPlots'HyperparameterOptimizationOptions'

Para obtener un ejemplo, consulte .Optimizar clasificador SVM

Ejemplo: 'auto'

'HyperparameterOptimizationOptions' — Opciones para la optimización

Estructura

Opciones para la optimización, especificadas como el par separado por comas que consta de y una estructura.'HyperparameterOptimizationOptions' Este argumento modifica el efecto del argumento de par nombre-valor.OptimizeHyperparameters Todos los campos de la estructura son opcionales.

Nombre del campo	Valores	Predeterminado
Optimizer	— Utilice la optimización bayesiana.'bayesopt' Internamente, esta configuración llama a .bayesopt — Utilice la búsqueda de cuadrícula con valores por dimensión.'gridsearch'NumGridDivisions — Buscar al azar entre puntos.'randomsearch'MaxObjectiveEvaluations búsquedas en un orden aleatorio, utilizando muestreo uniforme sin reemplazo de la cuadrícula.'gridsearch' Después de la optimización, puede obtener una tabla en orden de cuadrícula mediante el comando .sortrows(Mdl.HyperparameterOptimizationResults)	'bayesopt'
AcquisitionFunctionName	'expected-improvement-per-second-plus' 'expected-improvement' 'expected-improvement-plus' 'expected-improvement-per-second' 'lower-confidence-bound' 'probability-of-improvement' Las funciones de adquisición cuyos nombres incluyen no producen resultados reproducibles porque la optimización depende del tiempo de ejecución de la función objetivo.per-second Las funciones de adquisición cuyos nombres incluyen modifican su comportamiento cuando están sobreexplotando un área.plus Para obtener más información, consulte .Acquisition Function Types	'expected-improvement-per-second-plus'
MaxObjectiveEvaluations	Número máximo de evaluaciones de funciones objetivas.	para o , y toda la cuadrícula para30'bayesopt''randomsearch''gridsearch'
MaxTime	Límite de tiempo, especificado como un real positivo. El límite de tiempo es en segundos, medido por y .tictoc El tiempo de ejecución puede superar porque no interrumpe las evaluaciones de funciones.MaxTimeMaxTime	Inf
NumGridDivisions	Para , el número de valores en cada dimensión.'gridsearch' El valor puede ser un vector de enteros positivos que dan el número de valores para cada dimensión o un escalar que se aplica a todas las dimensiones. Este campo se omite para las variables categóricas.	10
ShowPlots	Valor lógico que indica si se deben mostrar trazados. Si , este campo traza el mejor valor de función objetivo con respecto al número de iteración.true Si hay uno o dos parámetros de optimización, y si es , también se traza un modelo de la función objetivo con los parámetros.Optimizer'bayesopt'ShowPlots	true
SaveIntermediateResults	Valor lógico que indica si se deben guardar los resultados cuando es .Optimizer'bayesopt' Si , este campo sobrescribe una variable de área de trabajo denominada en cada iteración.true'BayesoptResults' La variable es un objeto.BayesianOptimization	false
Verbose	Visualice en la línea de comandos. — Sin visualización iterativa0 — Visualización iterativa1 — Pantalla iterativa con información adicional2 Para obtener más información, consulte el argumento de par nombre-valor.bayesoptVerbose	1
UseParallel	Valor lógico que indica si se debe ejecutar la optimización bayesiana en paralelo, lo que requiere .Parallel Computing Toolbox™ Debido a la no reproducibilidad de la sincronización paralela, la optimización bayesiana paralela no produce necesariamente resultados reproducibles. Para obtener más información, consulte .Parallel Bayesian Optimization	false
Repartition	Valor lógico que indica si se debe volver a particionar la validación cruzada en cada iteración. Si , el optimizador utiliza una sola partición para la optimización.false por lo general da los resultados más robustos porque esta configuración tiene en cuenta el ruido de partición.true Sin embargo, para obtener buenos resultados, se requiere al menos el doble de evaluaciones de funciones.true	false
No utilice más de uno de los tres nombres de campo siguientes.
CVPartition	Un objeto, tal como lo creó .cvpartitioncvpartition	si no especifica ningún campo de validación cruzada'Kfold',5
Holdout	Un escalar en el rango que representa la fracción de retención.(0,1)
Kfold	Un entero mayor que 1.

Ejemplo: 'HyperparameterOptimizationOptions',struct('MaxObjectiveEvaluations',60)

Tipos de datos: struct

Argumentos de salida

Mdl — Modelo de clasificación SVM entrenado

objeto modeloClassificationSVM | objeto de modelo validado cruzadamenteClassificationPartitionedModel

Modelo de clasificación SVM entrenado, devuelto como un objeto de modelo o un objeto de modelo validado entre cruzadas.ClassificationSVMClassificationPartitionedModel

Si establece cualquiera de los argumentos de par nombre-valor , , , , o , a continuación, es un clasificador validado entre sí.KFoldHoldoutLeaveoutCrossValCVPartitionMdlClassificationPartitionedModel De lo contrario, es un clasificador.MdlClassificationSVM

Para hacer referencia a las propiedades de , utilice la notación de puntos.Mdl Por ejemplo, escriba en la ventana de comandos para mostrar los multiplicadores Lagrange entrenados.Mdl.Alpha

Limitaciones

• capacita clasificadores SVM para aplicaciones de aprendizaje de una o dos clases.fitcsvm Para entrenar clasificadores SVM utilizando datos con más de dos clases, utilice .fitcecoc

• admite conjuntos de datos de baja dimensión y de dimensión moderada.fitcsvm Para conjuntos de datos de alta dimensión, utilice en su lugar.fitclinear

Más acerca de

Restricción de caja

Una restricción de caja es un parámetro que controla la penalización máxima impuesta a las observaciones que infringen márgenes, lo que ayuda a evitar el sobreajuste (regularización).

Si aumenta la restricción de cuadro, el clasificador SVM asigna menos vectores de soporte. Sin embargo, aumentar la restricción de la caja puede conducir a tiempos de entrenamiento más largos.

Gram Matrix

La matriz Gram de un conjunto de vectores ?nx₁,..,X_n; X_j ? R^pEs una matriz -por- con elemento ( , ) definida como (nnjkGX_j,X_k) = < (ϕX_j),ϕ(X_k)>, un producto interno de los predictores transformados utilizando la función kernel .ϕ

Para SVM no lineal, el algoritmo forma una matriz Gram utilizando las filas de los datos del predictor.X La formalización dual sustituye al producto interno de las observaciones con los elementos correspondientes de la matriz Gram resultante (llamada el "truco del núcleo").X Por lo tanto, SVM no lineal opera en el espacio predictor transformado para encontrar un hiperplano de separación.

Condiciones de complementariedad de Karush-Kuhn-Tucker (KKT)

Las condiciones de complementariedad de KKT son restricciones de optimización necesarias para soluciones de programación no lineales óptimas.

En SVM, las condiciones de complementariedad de KKT son

$$\{\begin{array}{l}{\alpha }_j\left[y_{j}f\left(x_j\right)-1+{\xi }_j\right]=0\\ {\xi }_j\left(C-{\alpha }_j\right)=0\end{array}$$

para todos los sn.o 1,..., , dondejn $$f\left(x_j\right)=\varphi \left(x_j\right)\prime \beta +b,$$ es una función del núcleo (ver ), yϕMatriz de Gram Ξ_j es una variable holgada. Si las clases son perfectamente separables, entonces Ξ_j 0 para todos los 1,..., .jn

Aprendizaje de una clase

El aprendizaje de una clase, o SVM no supervisado, tiene como objetivo separar los datos del origen en el espacio predictor de alta dimensión (no el espacio predictor original) y es un algoritmo utilizado para la detección de valores atípicos.

El algoritmo se asemeja al de .SVM para clasificación binaria El objetivo es minimizar la doble expresión

$$0.5{\displaystyle \sum _{jk}{\alpha }_j}{\alpha }_{k}G(x_j,x_k)$$

con respecto a $${\alpha }_1,\mathrm{...},{\alpha }_n$$, sujeto a

$${\displaystyle \sum {\alpha }_j}=n\nu$$

Y $$0\le {\alpha }_j\le 1$$ para todos los ,..., .jn El valor de (GX_j,X_k) está en el elemento ( , ) del archivo .jkMatriz de Gram

Un pequeño valor de conduce a menos vectores de soporte y, por lo tanto, a un límite de decisión suave y crudo.ν Un gran valor de conduce a más vectores de soporte y, por lo tanto, a un límite de decisión curvo y flexible.ν El valor óptimo de debe ser lo suficientemente grande como para capturar la complejidad de los datos y lo suficientemente pequeño como para evitar el sobreentrenamiento.ν Además, 0 < a 1.ν

Para obtener más información, consulte .[5]

Vector de soporte

Los vectores de apoyo son observaciones correspondientes a estimaciones estrictamente positivas deα₁,...,Α_n.

Se prefieren los clasificadores SVM que producen menos vectores de soporte para un conjunto de entrenamiento determinado.

Máquinas vectoriales de soporte para la clasificación binaria

El algoritmo de clasificación binaria SVM busca un hiperplano óptimo que separe los datos en dos clases. Para las clases separables, el hiperplano óptimo maximiza un (espacio que no contiene ninguna observación) que se rodea, lo que crea límites para las clases positivas y negativas.Margen Para las clases inseparables, el objetivo es el mismo, pero el algoritmo impone una penalización sobre la longitud del margen para cada observación que está en el lado equivocado de su límite de clase.

La función de puntuación SVM lineal es

$$f(x)=x\prime \beta +b,$$

Dónde:

• es una observación (correspondiente a una fila de ).xX

• El vector contiene los coeficientes que definen un vector ortogonal al hiperplano (correspondiente a ).βMdl.Beta Para los datos separables, la longitud óptima del margen es $$2/\Vert \beta \Vert .$$

• es el término de sesgo (correspondiente a ).bMdl.Bias

La raíz de ( ) para coeficientes particulares define un hiperplano.fx Para un hiperplano determinado, ( ) es la distancia desde el punto hasta el hiperplano.fzz

El algoritmo busca la longitud máxima del margen, manteniendo las observaciones en las clases positivas ( s 1) y negativas ( s –1) separadas.yy

• Para las clases separables, el objetivo es minimizar $$\Vert \beta \Vert$$ con respecto a la y sujeta sβb y y_jf(X_j) 1, para todos los ,.., .jn Esta es la formalización para las clases separables.Primordial

• Para las clases inseparables, el algoritmo utiliza variables holgantes (Ξ_j) penalizar la función objetiva de las observaciones que cruzan el límite del margen para su clase. Ξ_j 0 para las observaciones que no crucen el límite del margen para su clase, de lo contrario Ξ_j 0.

  El objetivo es minimizar $$0.5{\Vert \beta \Vert }^2+C{\displaystyle \sum {\xi }_j}$$ con respecto a la , , yβb Ξ_j sujeto a $$y_{j}f(x_j)\ge 1-{\xi }_j$$ Y $${\xi }_j\ge 0$$ para todos los ,.., , y para un escalar positivo.jnrestricción de cajaC Esta es la formalización primaria para las clases inseparables.

El algoritmo utiliza el método de multiplicadores Lagrange para optimizar el objetivo, que introduce coeficientesnα₁,...,Α_n (correspondiente a ).Mdl.Alpha Las formalizaciones duales para SVM lineal son las siguientes:

• Para clases separables, minimice

  $$0.5{\displaystyle \sum _{j=1}^n{\displaystyle \sum }_{k=1}^n}{\alpha }_j{\alpha }_k{y}_j{y}_k{x}_j\prime x_k-{\displaystyle \sum }_{j=1}^n{\alpha }_j$$

  con respecto aα₁,...,Α_n, sujeto a $${\displaystyle \sum {\alpha }_j}{y}_j=0$$, Α_j 0 para todos los ,..., , 1 y .jnCondiciones de complementariedad de Karush-Kuhn-Tucker (KKT)

• Para las clases inseparables, el objetivo es el mismo que para las clases separables, excepto por la condición adicional $$0\le {\alpha }_j\le C$$ para todos los números 1,.., .jn

La función de puntuación resultante es

$$\widehat{f}(x)={\displaystyle \sum _{j=1}^n{\widehat{\alpha }}_j}{y}_{j}x\prime x_j+\widehat{b}.$$

$$\widehat{b}$$ es la estimación del sesgo y $${\widehat{\alpha }}_j$$ es la estimación del vectorj $$\widehat{\alpha }$$, 1,..., .jn Escrito de esta manera, la función de puntuación está libre de la estimación de como resultado de la formalización primaria.β

El algoritmo SVM clasifica una nueva observación utilizandoz $$\text{sign}\left(\widehat{f}\left(z\right)\right).$$

En algunos casos, un límite no lineal separa las clases. trabaja en un espacio predictor transformado para encontrar un hiperplano óptimo y separante.SVM no lineal

La formalización dual para SVM no lineal es

$$0.5{\displaystyle \sum _{j=1}^n{\displaystyle \sum _{k=1}^n{\alpha }_j}}{\alpha }_k{y}_j{y}_{k}G(x_j,x_k)-{\displaystyle \sum _{j=1}^n{\alpha }_j}$$

con respecto aα₁,...,Α_n, sujeto a $${\displaystyle \sum {\alpha }_j}{y}_j=0$$, $$0\le {\alpha }_j\le C$$ para todos los ,.., , y las condiciones de complementariedad del KKT. (jnGX_k,X_j) son elementos del archivo .Matriz de Gram La función de puntuación resultante es

$$\widehat{f}(x)={\displaystyle \sum _{j=1}^n{\widehat{\alpha }}_j}{y}_{j}G(x,x_j)+\widehat{b}.$$

Para obtener más información, consulte , , y .Comprender las máquinas vectoriales de soporte[1][3]

Sugerencias

• A menos que el conjunto de datos sea grande, intente siempre estandarizar los predictores (consulte ).Standardize La estandarización hace que los predictores sean insensibles a las escalas en las que se miden.

• Se recomienda validar cruzadamente mediante el argumento de par nombre-valor.KFold Los resultados de validación cruzada determinan qué tan bien se generaliza el clasificador SVM.

• Para el aprendizaje de una clase:

  • La configuración predeterminada para el argumento de par nombre-valor puede dar lugar a largos tiempos de entrenamiento.Alpha Para acelerar el entrenamiento, establezca un vector compuesto principalmente de s.Alpha0

  • Establezca el argumento de par nombre-valor en un valor más cercano para producir menos vectores de soporte y, por lo tanto, un límite de decisión más suave pero crudo.Nu0

• Sparsity en vectores de soporte es una propiedad deseable de un clasificador SVM. Para reducir el número de vectores de soporte, establezca en un valor grande.BoxConstraint Esta acción aumenta el tiempo de entrenamiento.

• Para un tiempo de entrenamiento óptimo, establezca el límite de memoria que permita su ordenador.CacheSize

• Si espera muchos menos vectores de soporte que las observaciones en el conjunto de entrenamiento, puede acelerar significativamente la convergencia reduciendo el conjunto activo mediante el argumento de par nombre-valor .'ShrinkagePeriod' Es una buena práctica especificar .'ShrinkagePeriod',1000

• Las observaciones duplicadas que están lejos del límite de la decisión no afectan a la convergencia. Sin embargo, sólo unas pocas observaciones duplicadas que se producen cerca del límite de la decisión pueden ralentizar considerablemente la convergencia. Para acelerar la convergencia, especifique si:'RemoveDuplicates',true

  • El conjunto de datos contiene muchas observaciones duplicadas.

  • Sospecha que algunas observaciones duplicadas caen cerca del límite de la decisión.

  Para mantener el conjunto de datos original durante el entrenamiento, fitcsvm deben almacenar temporalmente conjuntos de datos independientes: el original y otro sin las observaciones duplicadas. Por lo tanto, si especifica para conjuntos de datos que contienen pocos duplicados,true fitcsvm consume cerca del doble de memoria de los datos originales.

• Después de entrenar un modelo, puede generar código C/C++ que predice las etiquetas para los nuevos datos. La generación de código C/C++ requiere MATLAB Coder™. Para obtener más información, consulte .Introduction to Code Generation

Algoritmos

• Para la formulación matemática del algoritmo de clasificación binaria SVM, véase y .Máquinas vectoriales de soporte para la clasificación binariaComprender las máquinas vectoriales de soporte

• , , vector de caracteres vacíos ( ), cadena vacía ( ) y los valores indican que faltan valores. elimina filas enteras de datos correspondientes a una respuesta que falta.NaN<undefined>''""<missing>fitcsvm Al calcular pesos totales (consulte las siguientes viñetas), ignora cualquier peso correspondiente a una observación con al menos un predictor que falta.fitcsvm Esta acción puede conducir a probabilidades previaes desequilibradas en problemas de clase equilibrada. Por consiguiente, es posible que las restricciones del cuadro de observación no sea igual a .BoxConstraint

• elimina las observaciones que tienen cero peso o probabilidad previa.fitcsvm

• Para el aprendizaje de dos clases, si especifica la matriz de costos $$\mathcal{C}$$ (véase ), a continuación, el software actualiza las probabilidades previas de la clase (véase ) paraCostpPrior P_c mediante la incorporación de las sanciones descritas en $$\mathcal{C}$$.

  Específicamente, completa estos pasos:fitcsvm

  1. Calcular $$p_c^{\ast }=p\prime \mathcal{C}.$$

  2. Normalizar P_c^* para que las probabilidades anteriores actualizadas sume a 1.

     $$p_c=\frac{1}{{\displaystyle \sum _{j=1}^K{p}_{c,j}^{\ast }}}{p}_c^{\ast }.$$

     es el número de clases.K

  3. Restablezca la matriz de costes al valor predeterminado

     $$\mathcal{C}=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right].$$

  4. Elimine las observaciones de los datos de entrenamiento correspondientes a clases con probabilidad previa cero.

• Para el aprendizaje de dos clases, normaliza todos los pesos de observación (véase ) para sumar a 1.fitcsvmWeights A continuación, la función vuelve a normalizar las ponderaciones normalizadas para resumir la probabilidad anterior actualizada de la clase a la que pertenece la observación. Es decir, el peso total de la observación en clase esjk

  $$w_j^{\ast }=\frac{w_j}{{\displaystyle \sum _{\forall j\in \text{Class }k}{w}_j}}{p}_{c,k}.$$

  W_j es el peso normalizado para la observación;jp_c,k es la probabilidad previa actualizada de la clase (ver viñeta anterior).k

• Para el aprendizaje de dos clases, asigna una restricción de cuadro a cada observación en los datos de entrenamiento.fitcsvm La fórmula para la restricción de observación del cuadro esj

  $$C_j=n{C}_0{w}_j^{\ast }.$$

  es el tamaño de la muestra de entrenamiento,nC₀ es la restricción de cuadro inicial (consulte el argumento de par nombre-valor), y'BoxConstraint' $$w_j^{\ast }$$ es el peso total de la observación (ver viñeta anterior).j

• Si establece y el argumento de par , , o nombre-valor, estandariza los predictores utilizando sus medias ponderadas correspondientes y desviaciones estándar ponderadas.'Standardize',true'Cost''Prior''Weights'fitcsvm Es decir, estandariza el predictor (fitcsvmjX_j) utilizando

  $$x_j^{\ast }=\frac{x_j-{\mu }_j^{\ast }}{{\sigma }_j^{\ast }}.$$

  $${\mu }_j^{\ast }=\frac{1}{{\displaystyle \sum _k{w}_k^{\ast }}}{\displaystyle \sum _k{w}_k^{\ast }{x}_{jk}}.$$

  X_jk es la observación (fila) del predictor (columna).kj

  $${\left({\sigma }_j^{\ast }\right)}^2=\frac{v_1}{v_1^2-v_2}{\displaystyle \sum _k{w}_k^{\ast }{\left(x_{jk}-{\mu }_j^{\ast }\right)}^2}.$$

  $$v_1={\displaystyle \sum _j{w}_j^{\ast }}.$$

  $$v_2={\displaystyle \sum _j{\left(w_j^{\ast }\right)}^2}.$$

• Supongamos que es la proporción de valores atípicos que espera en los datos de entrenamiento y que establece .p'OutlierFraction',p

  • Para el aprendizaje de una clase, el software entrena el término de sesgo de tal manera que el 100 % de las observaciones en los datos de entrenamiento tienen puntuaciones negativas.p

  • El software implementa para el aprendizaje de dos clases.aprendizaje robusto En otras palabras, el software intenta eliminar el 100 % de las observaciones cuando converge el algoritmo de optimización.p Las observaciones eliminadas corresponden a gradientes de gran magnitud.

• Si los datos del predictor contienen variables categóricas, el software generalmente utiliza una codificación ficticia completa para estas variables. El software crea una variable ficticia para cada nivel de cada variable categórica.

  • La propiedad almacena un elemento para cada uno de los nombres de variable predictor originales.PredictorNames Por ejemplo, supongamos que hay tres predictores, uno de los cuales es una variable categórica con tres niveles. Luego es una matriz de celdas 1 por 3 de vectores de caracteres que contiene los nombres originales de las variables predictoras.PredictorNames

  • La propiedad almacena un elemento para cada una de las variables predictoras, incluidas las variables ficticias.ExpandedPredictorNames Por ejemplo, supongamos que hay tres predictores, uno de los cuales es una variable categórica con tres niveles. Luego es una matriz de celdas de 1 por 5 vectores de caracteres que contiene los nombres de las variables predictoras y las nuevas variables ficticias.ExpandedPredictorNames

  • Del mismo modo, la propiedad almacena un coeficiente beta para cada predictor, incluidas las variables ficticias.Beta

  • La propiedad almacena los valores predictores para los vectores de soporte, incluidas las variables ficticias.SupportVectors Por ejemplo, supongamos que hay vectores de soporte y tres predictores, uno de los cuales es una variable categórica con tres niveles.m Entonces es una matriz -by-5.SupportVectorsn

  • La propiedad almacena los datos de entrenamiento como entrada original y no incluye las variables ficticias.X Cuando la entrada es una tabla, contiene solo las columnas utilizadas como predictores.X

• Para los predictores especificados en una tabla, si alguna de las variables contiene categorías ordenadas (ordinales), el software utiliza la codificación ordinal para estas variables.

  • Para una variable con niveles ordenados, el software creak k – 1 variables ficticias. La variable ficticia esj –1 para niveles hasta , yj +1 para niveles j + 1 a través de.k

  • Los nombres de las variables ficticias almacenadas en la propiedad indican el primer nivel con el valorExpandedPredictorNames +1. Las tiendas de software k – 1 nombres predictores adicionales para las variables ficticias, incluidos los nombres de los niveles 2, 3, ..., .k

• Todos los solucionadores implementan 1 minimización de margen flexible.L

• Para el aprendizaje de una clase, el software estima los multiplicadores Lagrange,α₁,...,Α_n, de forma que

  $${\displaystyle \sum _{j=1}^n{\alpha }_j}=n\nu .$$

Referencias

[1] 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.

[2] Fan, R.-E., P.-H. Chen, and C.-J. Lin. “Working set selection using second order information for training support vector machines.” Journal of Machine Learning Research, Vol. 6, 2005, pp. 1889–1918.

[3] Hastie, T., R. Tibshirani, and J. Friedman. The Elements of Statistical Learning, Second Edition. NY: Springer, 2008.

[4] Kecman V., T. -M. Huang, and M. Vogt. “Iterative Single Data Algorithm for Training Kernel Machines from Huge Data Sets: Theory and Performance.” Support Vector Machines: Theory and Applications. Edited by Lipo Wang, 255–274. Berlin: Springer-Verlag, 2005.

[5] 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.

[6] 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.

Capacidades ampliadas

Soporte paralelo automático

Acelere código mediante la ejecución automática de cálculo paralelo mediante Parallel Computing Toolbox™.

Para ejecutar en paralelo, establezca la opción en .'UseParallel'true

Para realizar la optimización de hiperparámetros paralelos, utilice el argumento de par nombre-valor en la llamada a esta función.'HyperparameterOptions', struct('UseParallel',true)

Para obtener más información sobre la optimización de hiperparámetros paralelos, consulte .Parallel Bayesian Optimization

Para obtener más información general sobre la informática paralela, consulte .Run MATLAB Functions with Automatic Parallel Support (Parallel Computing Toolbox)

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

Notas de uso y limitaciones:

• La opción no debe especificar un kernel personalizado.'KernelFunction'

• La opción se puede establecer en sólo .'Solver''SMO'

• La opción no es compatible.'OutlierFraction'

• La opción debe especificar un punto de partida factible.'Alpha'

• La opción no es compatible.'OptimizeHyperparameters'

• No se admite la clasificación de una clase. Las etiquetas deben contener dos clases diferentes.

Para obtener más información, consulte .Run MATLAB Functions on a GPU (Parallel Computing Toolbox)

Consulte también

ClassificationPartitionedModel | ClassificationSVM | CompactClassificationSVM | fitcecoc | fitclinear | fitSVMPosterior | predict | rng | quadprog (Optimization Toolbox)

Temas

• Train SVM Classifiers Using a Gaussian Kernel
• Train SVM Classifier Using Custom Kernel
• Optimize a Cross-Validated SVM Classifier Using bayesopt
• Optimize an SVM Classifier Fit Using Bayesian Optimization
• Comprender las máquinas vectoriales de soporte

Introducido en R2014a

×

Abrir ejemplo

Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?

No, sobrescribir la versión modificada Sí