Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

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

Comprender las máquinas vectoriales de soporte

• Datos separables

• Datos no separables

• Transformación no lineal con núcleos

Datos separables

Puede utilizar una máquina de vectores de soporte (SVM) cuando los datos tienen exactamente dos clases. Una SVM clasifica los datos buscando el mejor hiperplano que separa todos los puntos de datos de una clase de los de la otra clase. El hiperplano para una SVM significa el más grande entre las dos clases.MejorMargen Margen significa el ancho máximo de la losa paralela al hiperplano que no tiene puntos de datos interiores.

Son los puntos de datos más cercanos al hiperplano de separación; estos puntos están en el límite de la losa.vectores de apoyo La figura siguiente ilustra estas definiciones, con + indicando puntos de datos de tipo 1 y, indicando puntos de datos de tipo –1.

Formulación matemática: Primal.  Esta discusión sigue a Hastie, Tibshirani, y Friedman y Christianini y Shawe-Taylor.[1][2]

Los datos para el entrenamiento son un conjunto de puntos (vectores) X_j junto con sus categorías y y_j. Para alguna dimensión, eld x_j ∊ R^d, y el y_j = ±1. La ecuación de un hiperplano es

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

Dónde β ∊ R^d y es un número real.b

El siguiente problema define el hiperplano de separación (es decir, el límite de decisión).Mejor Buscar y que se minimizan los || de tal forma que para todos los puntos de datos (βbβX_j,y y_j),

$$y_{j}f\left(x_j\right)\ge 1.$$

Los vectores de soporte son los X_j en el límite, aquellos para los que $$y_{j}f\left(x_j\right)=1.$$

Para mayor comodidad matemática, el problema se suele dar como el problema equivalente de minimizar $$\Vert \beta \Vert$$. Este es un problema de programación cuadrática. La solución óptima $$\left(\widehat{\beta },\widehat{b}\right)$$ permite la clasificación de un vector de la siguiente manera:z

$$\text{class}(z)=\text{sign}\left(z\prime \widehat{\beta }+\widehat{b}\right)=\text{sign}\left(\widehat{f}\left(z\right)\right).$$

$$\widehat{f}\left(z\right)$$ es el y representa la distancia está desde el límite de decisión.puntuación de clasificaciónz

Formulación matemática: Dual.  Es computacionalmente más simple resolver el problema de programación cuadrática dual. Para obtener el doble, tome multiplicadores Lagrange positivos Α_j multiplicado por cada restricción, y restar de la función objetivo:

$$L_P=\frac{1}{2}\beta \prime \beta -{\displaystyle \sum _j{\alpha }_j\left(y_j\left(x_j\prime \beta +b\right)-1\right)},$$

donde se busca un punto estacionario de L_P una y .βb Ajuste del gradiente de L_P a 0, se obtiene

$$\begin{array}{c}\beta ={\displaystyle \sum _j{\alpha }_j{y}_j{x}_j}\\ 0={\displaystyle \sum _j{\alpha }_j{y}_j}.\end{array}$$

(1)

Sustituir a L_P, se obtiene el doble L_D:

$$L_D={\displaystyle \sum _j{\alpha }_j}-\frac{1}{2}{\displaystyle \sum _j{\displaystyle \sum _k{\alpha }_j{\alpha }_k{y}_j{y}_k{x}_j\prime x_k}},$$

que maximizas sobre α_j ≥ 0. En general, muchos Α_j son 0 como máximo. El distinto cero Α_j en la solución al doble problema definir el hiperplano, como se ve en , lo que da como la suma deEcuación 1β Α_jy y_jX_j. Los puntos de datos X_j correspondiente a distinto de cero Α_j son el archivo .vectores de apoyo

El derivado de L_D con respecto a un distinto de cero Α_j es 0 en un óptimo. Esto da

$$y_{j}f\left(x_j\right)-1=0.$$

En particular, esto da el valor de la solución, tomando cualquiera conbj Α_j.

El dual es un problema de programación cuadrática estándar. Por ejemplo, el solucionador resuelve este tipo de problema.Optimization Toolbox™quadprog (Optimization Toolbox)

Datos no separables

Es posible que los datos no permitan un hiperplano de separación. En ese caso, SVM puede utilizar un , lo que significa un hiperplano que separa muchos, pero no todos los puntos de datos.margen suave

Hay dos formulaciones estándar de márgenes blandos. Ambos implican la adición de variables holgantes Ξ_j y un parámetro de penalización .C

• elL¹-el problema de la norma es:

  $$\underset{\beta ,b,\xi }{\min }\left(\frac{1}{2}\beta \prime \beta +C{\displaystyle \sum _j{\xi }_j}\right)$$

  tal que

  $$\begin{array}{c}{y}_{j}f\left(x_j\right)\ge 1-{\xi }_j\\ {\xi }_j\ge 0.\end{array}$$

  elL¹-norm se refiere al uso de Ξ_j como variables holgantes en lugar de sus cuadrados. Las tres opciones del solucionador, y de minimizar laSMOISDAL1QPfitcsvmL¹-problema de norma.

• elL²-el problema de la norma es:

  $$\underset{\beta ,b,\xi }{\min }\left(\frac{1}{2}\beta \prime \beta +C{\displaystyle \sum _j{\xi }_j^2}\right)$$

  sujetas a las mismas restricciones.

En estas formulaciones, se puede ver que el aumento pone más peso en las variables holgantesC Ξ_j, lo que significa que la optimización intenta establecer una separación más estricta entre las clases. Equivalentemente, reducir hacia 0 hace que la clasificación errónea sea menos importante.C

Formulación matemática: Dual.  Para cálculos más fáciles, considere laL¹ doble problema a esta formulación de margen suave. Uso de multiplicadores Lagrange Μ_j, la función a minimizar para elL¹-el problema de la norma es:

$$L_P=\frac{1}{2}\beta \prime \beta +C{\displaystyle \sum _j{\xi }_j}-{\displaystyle \sum _j{\alpha }_j\left(y_{i}f\left(x_j\right)-\left(1-{\xi }_j\right)\right)}-{\displaystyle \sum _j{\mu }_j{\xi }_j},$$

donde se busca un punto estacionario de L_P más de , , y positivoβb Ξ_j. Ajuste del gradiente de L_P a 0, se obtiene

$$\begin{array}{c}\beta ={\displaystyle \sum _j{\alpha }_j{y}_j{x}_j}\\ {\displaystyle \sum _j{\alpha }_j{y}_j}=0\\ {\alpha }_j=C-{\mu }_j\\ {\alpha }_j,{\mu }_j,{\xi }_j\ge 0.\end{array}$$

Estas ecuaciones conducen directamente a la formulación dual:

$$\underset{\alpha }{\max }{\displaystyle \sum _j{\alpha }_j}-\frac{1}{2}{\displaystyle \sum _j{\displaystyle \sum _k{\alpha }_j{\alpha }_k{y}_j{y}_k{x}_j\prime x_k}}$$

sujeto a las limitaciones

$$\begin{array}{l}{\displaystyle \sum _j{y}_j{\alpha }_j}=0\\ 0\le {\alpha }_j\le C.\end{array}$$

El conjunto final de desigualdades, 0 ≤ α_j ≤ C, muestra por qué a veces se llama un archivo . mantiene los valores permitidos de los multiplicadores LagrangeCrestricción de cajaC Α_j en una "caja", una región delimitada.

La ecuación de gradiente para da la solución en términos del conjunto debb Α_j, que corresponden a los vectores de soporte.

Puede escribir y resolver el doble de laL²-problema de norma de una manera análoga. Para más detalles, véase Christianini y Shawe-Taylor , Capítulo 6.[2]

Implementaciónfitcsvm.  Ambos problemas de margen blando dual son problemas de programación cuadráticos. Internamente, tiene varios algoritmos diferentes para resolver los problemas.fitcsvm

• Para la clasificación de una clase o binaria, si no establece una fracción de valores atípicos esperados en los datos (consulte ), el solucionador predeterminado es Optimización mínima secuencial (SMO).OutlierFraction SMO minimiza el problema de una norma mediante una serie de minimizaciones de dos puntos. Durante la optimización, SMO respeta la restricción lineal $${\displaystyle \sum _i{\alpha }_i}{y}_i=0,$$ e incluye explícitamente el término de sesgo en el modelo. SMO es relativamente rápido. Para obtener más información sobre SMO, consulte .[3]

• Para la clasificación binaria, si establece una fracción de los valores atípicos esperados en los datos, el solucionador predeterminado es el algoritmo iterativo de datos únicos. Al igual que SMO, ISDA resuelve el problema de una norma. A diferencia de SMO, ISDA minimiza mediante una serie en minimizaciones de un punto, no respeta la restricción lineal y no incluye explícitamente el término de sesgo en el modelo. Para obtener más información sobre ISDA, consulte .[4]

• Para la clasificación de una clase o binaria, y si tiene una licencia, puede optar por usar para resolver el problema de una norma. utiliza una buena parte de la memoria, pero resuelve programas cuadráticos con un alto grado de precisión.Optimization Toolboxquadprog (Optimization Toolbox)quadprog Para obtener más información, consulte .Definición de programación cuadrática (Optimization Toolbox)

Transformación no lineal con núcleos

Algunos problemas de clasificación binaria no tienen un hiperplano simple como criterio de separación útil. Para esos problemas, hay una variante del enfoque matemático que conserva casi toda la simplicidad de un hiperplano de separación SVM.

Este enfoque utiliza estos resultados de la teoría de la reproducción de kernels:

• Hay una clase de funciones (Gx₁,x₂) con la siguiente propiedad. Hay un espacio lineal y una asignación de funciones para queSφxS

  G(x₁,x₂) = < (φx₁),φ(x₂)>.

  El producto punto tiene lugar en el espacio .S

• Esta clase de funciones incluye:

  • Polinomios: Para algún entero positivo,p

    G(x₁,x₂) (1 +x₁′x₂)^p.

  • Función de base radial (gaussiana):

    G(x₁,x₂) á exp(–-?x₁–x₂)A)²).

  • Perceptrón multicapa o sigmoide (red neuronal): Para un número positivop₁ y un número negativop₂,

    G(x₁,x₂) - tanh(p₁x₁′x₂ +p₂).

    Nota

    • No todos los conjuntos dep₁ Yp₂ produce un núcleo de reproducción válido.

    • no soporta el núcleo sigmoide.fitcsvm En su lugar, puede definir el kernel sigmoid y especificarlo mediante el argumento de par nombre-valor.'KernelFunction' Para obtener más información, consulte .Train SVM Classifier Using Custom Kernel

El enfoque matemático mediante kernels se basa en el método computacional de hiperplanos. Todos los cálculos para la clasificación de hiperplanos no utilizan más que productos de puntos. Por lo tanto, los kernels no lineales pueden utilizar cálculos idénticos y algoritmos de solución, y obtener clasificadores que no son lineales. Los clasificadores resultantes son hipersuperficies en algún espacio, pero el espacio no tiene que ser identificado o examinado.SS

Uso de máquinas vectoriales de soporte

Al igual que con cualquier modelo de aprendizaje supervisado, primero se entrena una máquina vectorial de soporte técnico y, a continuación, se valida el clasificador. Utilice la máquina entrenada para clasificar (predecir) nuevos datos. Además, para obtener una precisión predictiva satisfactoria, puede utilizar varias funciones del kernel SVM, y debe ajustar los parámetros de las funciones del núcleo.

• Capacitación de un clasificador de SVM

• Clasificación de nuevos datos con un clasificador SVM

• Ajuste de un clasificador SVM

Capacitación de un clasificador de SVM

Entrene y, opcionalmente, valide, un clasificador SVM mediante .fitcsvm La sintaxis más común es:

SVMModel = fitcsvm(X,Y,'KernelFunction','rbf',...     'Standardize',true,'ClassNames',{'negClass','posClass'});

Las entradas son:

• — Matriz de datos predictores, donde cada fila es una observación, y cada columna es un predictor.X

• — Matriz de etiquetas de clase con cada fila correspondiente al valor de la fila correspondiente en . puede 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.YXY

• — El valor predeterminado es para el aprendizaje de dos clases, que separa los datos por un hiperplano.KernelFunction'linear' El valor (o ) es el valor predeterminado para el aprendizaje de una clase y especifica utilizar el kernel gaussiano (o función de base radial).'gaussian''rbf' Un paso importante para entrenar con éxito un clasificador SVM es elegir una función de kernel adecuada.

• — Indicador que indica si el software debe estandarizar los predictores antes de entrenar el clasificador.Standardize

• : distingue entre las clases negativas y positivas, o especifica qué clases incluir en los datos.ClassNames La clase negativa es el primer elemento (o fila de una matriz de caracteres), por ejemplo, , y la clase positiva es el segundo elemento (o fila de una matriz de caracteres), por ejemplo, . debe ser el mismo tipo de datos que .'negClass''posClass'ClassNamesY Se recomienda especificar los nombres de clase, especialmente si está comparando el rendimiento de diferentes clasificadores.

El modelo entrenado resultante ( ) contiene los parámetros optimizados del algoritmo SVM, lo que le permite clasificar nuevos datos.SVMModel

Para obtener más pares nombre-valor que puede usar para controlar el entrenamiento, consulte la página de referencia.fitcsvm

Clasificación de nuevos datos con un clasificador SVM

Clasificar nuevos datos utilizando predict. La sintaxis para clasificar nuevos datos mediante un clasificador SVM entrenado ( ) es:SVMModel

[label,score] = predict(SVMModel,newX);

El vector resultante, , representa la clasificación de cada fila en . es una matriz -by-2 de puntuaciones blandas.EtiquetaXscoren Cada fila corresponde a una fila en , que es una nueva observación.X La primera columna contiene las puntuaciones de las observaciones que se clasifican en la clase negativa, y la segunda columna contiene las observaciones de puntuaciones que se clasifican en la clase positiva.

Para estimar las probabilidades posteriores en lugar de las puntuaciones, primero pase el clasificador SVM entrenado ( ) aSVMModel fitPosterior, que se ajusta a una función de transformación de puntuación a posterior de probabilidad a las puntuaciones. La sintaxis es:

ScoreSVMModel = fitPosterior(SVMModel,X,Y);

La propiedad del clasificador contiene la función de transformación óptima.ScoreTransformScoreSVMModel Pase a .ScoreSVMModelpredict En lugar de devolver las puntuaciones, el argumento de salida contiene las probabilidades posteriores de que una observación se clasifique en la clase negativa (columna 1 de ) o positiva (columna 2 de ).scorescorescore

Ajuste de un clasificador SVM

Utilice el argumento de par nombre-valor para buscar valores de parámetro que minimicen la pérdida de validación cruzada.'OptimizeHyperparameters'fitcsvm Los parámetros elegibles son , , , , y .'BoxConstraint''KernelFunction''KernelScale''PolynomialOrder''Standardize' Para obtener un ejemplo, consulte .Optimice un ajuste de clasificador SVM mediante la optimización bayesiana Alternativamente, puede utilizar la función, como se muestra en .bayesoptOptimize a Cross-Validated SVM Classifier Using bayesopt La función permite una mayor flexibilidad para personalizar la optimización.bayesopt Puede utilizar la función para optimizar cualquier parámetro, incluidos los parámetros que no son aptos para optimizar cuando se utiliza la función.bayesoptfitcsvm

También puede intentar ajustar los parámetros de su clasificador manualmente de acuerdo con este esquema:

1. Pase los datos a , y establezca el argumento de par nombre-valor .fitcsvm'KernelScale','auto' Supongamos que el modelo SVM entrenado se llama .SVMModel El software utiliza un procedimiento heurístico para seleccionar la escala del kernel. El procedimiento heurístico utiliza submuestreo. Por lo tanto, para reproducir los resultados, establezca un número aleatorio de semilla según el uso antes de entrenar el clasificador.rng

2. Valide el clasificador de forma cruzada pasándolo a crossval. De forma predeterminada, el software lleva a cabo una validación cruzada de 10 veces.

3. Pase el modelo de SVM validado de forma cruzada a kfoldLoss para estimar y conservar el error de clasificación.

4. Vuelva a entrenar el clasificador SVM, pero ajuste los argumentos de par nombre-valor y los argumentos.'KernelScale''BoxConstraint'

   • — Una estrategia consiste en probar una secuencia geométrica del parámetro de restricción de caja.BoxConstraint Por ejemplo, tome 11 valores, de a por un factor de 10.1e-51e5 El aumento puede disminuir el número de vectores de soporte, pero también puede aumentar el tiempo de entrenamiento.BoxConstraint

   • — Una estrategia es probar una secuencia geométrica del parámetro RBF sigma escalada en la escala original del núcleo.KernelScale Haga esto por:

     1. Recuperar la escala original del núcleo, por ejemplo, mediante notación de puntos: .ksks = SVMModel.KernelParameters.Scale

     2. Utilícelo como nuevos factores de escala del núcleo del original. Por ejemplo, multiplique por los 11 valores a , aumentando por un factor de 10.ks1e-51e5

Elija el modelo que produce el error de clasificación más bajo. Es posible que desee refinar aún más los parámetros para obtener una mejor precisión. Comience con los parámetros iniciales y realice otro paso de validación cruzada, esta vez utilizando un factor de 1.2.

Train SVM Classifiers Using a Gaussian Kernel

En este ejemplo se muestra cómo generar un clasificador no lineal con la función de kernel gaussiana. En primer lugar, genere una clase de puntos dentro del disco de la unidad en dos dimensiones y otra clase de puntos en el anillo desde el radio 1 hasta el radio 2. A continuación, genera un clasificador basado en los datos con el kernel de función de base radial gaussiana. El clasificador lineal predeterminado es obviamente inadecuado para este problema, ya que el modelo es circularmente simétrico. Establezca el parámetro de restricción de cuadro para que forme una clasificación estricta, lo que significa que no hay puntos de entrenamiento mal clasificados.Inf Es posible que otras funciones del kernel no funcionen con esta restricción de cuadro estricta, ya que podrían ser incapaces de proporcionar una clasificación estricta. Aunque el clasificador rbf puede separar las clases, el resultado se puede sobreentrenar.

Genere 100 puntos distribuidos uniformemente en el disco de la unidad. Para ello, genere un radio como la raíz cuadrada de una variable aleatoria uniforme, genere un ángulo uniformemente en (0,rt

<math display="block">

<mrow>

<mn>2</mn>

<mi>π</mi>

</mrow>

</math>

), y ponga el punto en ( cos( ), sin( )).rtrt

rng(1); % For reproducibility r = sqrt(rand(100,1)); % Radius t = 2*pi*rand(100,1);  % Angle data1 = [r.*cos(t), r.*sin(t)]; % Points

Generar 100 puntos distribuidos uniformemente en el anillo. El radio es de nuevo proporcional a una raíz cuadrada, esta vez una raíz cuadrada de la distribución uniforme de 1 a 4.

r2 = sqrt(3*rand(100,1)+1); % Radius t2 = 2*pi*rand(100,1);      % Angle data2 = [r2.*cos(t2), r2.*sin(t2)]; % points

Trazar los puntos y trazar círculos de radios 1 y 2 para la comparación.

figure; plot(data1(:,1),data1(:,2),'r.','MarkerSize',15) hold on plot(data2(:,1),data2(:,2),'b.','MarkerSize',15) ezpolar(@(x)1);ezpolar(@(x)2); axis equal hold off

Coloque los datos en una matriz y haga un vector de clasificaciones.

data3 = [data1;data2]; theclass = ones(200,1); theclass(1:100) = -1;

Entrene un clasificador SVM con establecido en y establecido en .KernelFunction'rbf'BoxConstraintInf Trazar el límite de decisión y marcar los vectores de soporte.

%Train the SVM Classifier cl = fitcsvm(data3,theclass,'KernelFunction','rbf',...     'BoxConstraint',Inf,'ClassNames',[-1,1]);  % Predict scores over the grid d = 0.02; [x1Grid,x2Grid] = meshgrid(min(data3(:,1)):d:max(data3(:,1)),...     min(data3(:,2)):d:max(data3(:,2))); xGrid = [x1Grid(:),x2Grid(:)]; [~,scores] = predict(cl,xGrid);  % Plot the data and the decision boundary figure; h(1:2) = gscatter(data3(:,1),data3(:,2),theclass,'rb','.'); hold on ezpolar(@(x)1); h(3) = plot(data3(cl.IsSupportVector,1),data3(cl.IsSupportVector,2),'ko'); contour(x1Grid,x2Grid,reshape(scores(:,2),size(x1Grid)),[0 0],'k'); legend(h,{'-1','+1','Support Vectors'}); axis equal hold off

genera un clasificador que está cerca de un círculo de radio 1.fitcsvm La diferencia se debe a los datos de entrenamiento aleatorios.

El entrenamiento con los parámetros predeterminados hace que un límite de clasificación casi circular, pero que clasifique erróneamente algunos datos de entrenamiento. Además, el valor predeterminado de es , y, por lo tanto, hay más vectores de soporte.BoxConstraint1

cl2 = fitcsvm(data3,theclass,'KernelFunction','rbf'); [~,scores2] = predict(cl2,xGrid);  figure; h(1:2) = gscatter(data3(:,1),data3(:,2),theclass,'rb','.'); hold on ezpolar(@(x)1); h(3) = plot(data3(cl2.IsSupportVector,1),data3(cl2.IsSupportVector,2),'ko'); contour(x1Grid,x2Grid,reshape(scores2(:,2),size(x1Grid)),[0 0],'k'); legend(h,{'-1','+1','Support Vectors'}); axis equal hold off

Train SVM Classifier Using Custom Kernel

En este ejemplo se muestra cómo utilizar una función de kernel personalizada, como el kernel sigmoid, para entrenar clasificadores SVM y ajustar los parámetros de función del kernel personalizados.

Genere un conjunto aleatorio de puntos dentro del círculo de la unidad. Etiquetar puntos en el primer y tercer cuadrante como pertenecientes a la clase positiva, y los del segundo y cuarto cuadrantes de la clase negativa.

rng(1);  % For reproducibility n = 100; % Number of points per quadrant  r1 = sqrt(rand(2*n,1));                     % Random radii t1 = [pi/2*rand(n,1); (pi/2*rand(n,1)+pi)]; % Random angles for Q1 and Q3 X1 = [r1.*cos(t1) r1.*sin(t1)];             % Polar-to-Cartesian conversion  r2 = sqrt(rand(2*n,1)); t2 = [pi/2*rand(n,1)+pi/2; (pi/2*rand(n,1)-pi/2)]; % Random angles for Q2 and Q4 X2 = [r2.*cos(t2) r2.*sin(t2)];  X = [X1; X2];        % Predictors Y = ones(4*n,1); Y(2*n + 1:end) = -1; % Labels 

Trazar los datos.

figure; gscatter(X(:,1),X(:,2),Y); title('Scatter Diagram of Simulated Data') 

Escriba una función que acepte dos matrices en el espacio de entidades como entradas y las transforme en una matriz Gram utilizando el kernel sigmoid.

 function G = mysigmoid(U,V) % Sigmoid kernel function with slope gamma and intercept c gamma = 1; c = -1; G = tanh(gamma*U*V' + c); end  

Guarde este código como un archivo denominado en la ruta de acceso matlab® MATLAB.mysigmoid

Entrene a un clasificador SVM utilizando la función de kernel sigmoid. Es una buena práctica estandarizar los datos.

Mdl1 = fitcsvm(X,Y,'KernelFunction','mysigmoid','Standardize',true); 

es un clasificador que contiene los parámetros estimados.Mdl1ClassificationSVM

Trazar los datos e identificar los vectores de soporte y el límite de decisión.

    % Compute the scores over a grid d = 0.02; % Step size of the grid [x1Grid,x2Grid] = meshgrid(min(X(:,1)):d:max(X(:,1)),...     min(X(:,2)):d:max(X(:,2))); xGrid = [x1Grid(:),x2Grid(:)];        % The grid [~,scores1] = predict(Mdl1,xGrid); % The scores  figure; h(1:2) = gscatter(X(:,1),X(:,2),Y); hold on h(3) = plot(X(Mdl1.IsSupportVector,1),...     X(Mdl1.IsSupportVector,2),'ko','MarkerSize',10);     % Support vectors contour(x1Grid,x2Grid,reshape(scores1(:,2),size(x1Grid)),[0 0],'k');     % Decision boundary title('Scatter Diagram with the Decision Boundary') legend({'-1','1','Support Vectors'},'Location','Best'); hold off 

Puede ajustar los parámetros del kernel en un intento de mejorar la forma del límite de decisión. Esto también puede disminuir la tasa de clasificación incorrecta dentro de la muestra, pero, primero, debe determinar la tasa de clasificación errónea fuera de la muestra.

Determine la tasa de clasificación errónea fuera de muestra mediante la validación cruzada de 10 veces.

CVMdl1 = crossval(Mdl1); misclass1 = kfoldLoss(CVMdl1); misclass1 

 misclass1 =      0.1375  

La tasa de clasificación errónea fuera de la muestra es del 13,5%.

Escribe otra función sigmoid, pero Set .gamma = 0.5;

 function G = mysigmoid2(U,V) % Sigmoid kernel function with slope gamma and intercept c gamma = 0.5; c = -1; G = tanh(gamma*U*V' + c); end  

Guarde este código como un archivo denominado en la ruta de acceso matlab® MATLAB.mysigmoid2

Entrene a otro clasificador SVM utilizando el kernel sigmoid ajustado. Trazar los datos y la región de decisión y determinar la tasa de clasificación errónea fuera de muestra.

Mdl2 = fitcsvm(X,Y,'KernelFunction','mysigmoid2','Standardize',true); [~,scores2] = predict(Mdl2,xGrid);  figure; h(1:2) = gscatter(X(:,1),X(:,2),Y); hold on h(3) = plot(X(Mdl2.IsSupportVector,1),...     X(Mdl2.IsSupportVector,2),'ko','MarkerSize',10); title('Scatter Diagram with the Decision Boundary') contour(x1Grid,x2Grid,reshape(scores2(:,2),size(x1Grid)),[0 0],'k'); legend({'-1','1','Support Vectors'},'Location','Best'); hold off  CVMdl2 = crossval(Mdl2); misclass2 = kfoldLoss(CVMdl2); misclass2 

 misclass2 =      0.0450  

Después del ajuste de la pendiente sigmoide, el nuevo límite de decisión parece proporcionar un mejor ajuste dentro de la muestra, y los contratos de tasa de validación cruzada en más del 66%.

Optimice un ajuste de clasificador SVM mediante la optimización bayesiana

En este ejemplo se muestra cómo optimizar una clasificación SVM mediante el par función y nombre-valor.fitcsvmOptimizeHyperparameters La clasificación funciona en ubicaciones de puntos de un modelo de mezcla gaussiana. En , Hastie, Tibshirani, y Friedman (2009), la página 17 describe el modelo.The Elements of Statistical Learning El modelo comienza con la generación de 10 puntos base para una clase "verde", distribuidas como normales independientes 2D con media (1,0) y varianza de unidad. También genera 10 puntos base para una clase "roja", distribuidas como normales independientes 2D con media (0,1) y varianza unitaria. Para cada clase (verde y rojo), genere 100 puntos aleatorios de la siguiente manera:

1. Elija un punto base del color adecuado uniformemente al azar.m

2. Genere un punto aleatorio independiente con distribución normal 2-D con media y varianza I/5, donde I es la matriz de identidad 2 por 2.m En este ejemplo, utilice una varianza I/50 para mostrar la ventaja de la optimización con mayor claridad.

Generar los puntos y clasificador

Genere los 10 puntos base para cada clase.

rng default % For reproducibility grnpop = mvnrnd([1,0],eye(2),10); redpop = mvnrnd([0,1],eye(2),10);

Ver los puntos base.

plot(grnpop(:,1),grnpop(:,2),'go') hold on plot(redpop(:,1),redpop(:,2),'ro') hold off

Dado que algunos puntos base rojos están cerca de puntos base verdes, puede ser difícil clasificar los puntos de datos solo en función de la ubicación.

Genere los 100 puntos de datos de cada clase.

redpts = zeros(100,2);grnpts = redpts; for i = 1:100     grnpts(i,:) = mvnrnd(grnpop(randi(10),:),eye(2)*0.02);     redpts(i,:) = mvnrnd(redpop(randi(10),:),eye(2)*0.02); end

Ver los puntos de datos.

figure plot(grnpts(:,1),grnpts(:,2),'go') hold on plot(redpts(:,1),redpts(:,2),'ro') hold off

Preparar datos para la clasificación

Coloque los datos en una matriz y haga un vector que egráfica la clase de cada punto.grp

cdata = [grnpts;redpts]; grp = ones(200,1); % Green label 1, red label -1 grp(101:200) = -1;

Preparar la validación cruzada

Configure una partición para la validación cruzada. Este paso corrige los conjuntos de entrenamiento y prueba que usa la optimización en cada paso.

c = cvpartition(200,'KFold',10);

Optimizar el ajuste

Para encontrar un buen ajuste, es decir, uno con una pérdida de validación cruzada baja, establezca opciones para usar la optimización bayesiana. Utilice la misma partición de validación cruzada en todas las optimizaciones.c

Para reproducibilidad, utilice la función de adquisición.'expected-improvement-plus'

opts = struct('Optimizer','bayesopt','ShowPlots',true,'CVPartition',c,...     'AcquisitionFunctionName','expected-improvement-plus'); svmmod = fitcsvm(cdata,grp,'KernelFunction','rbf',...     'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',opts)

|=====================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstraint|  KernelScale | |      | result |             | runtime     | (observed)  | (estim.)    |              |              | |=====================================================================================================| |    1 | Best   |       0.345 |     0.34739 |       0.345 |       0.345 |      0.00474 |       306.44 | 

|    2 | Best   |       0.115 |     0.30642 |       0.115 |     0.12678 |       430.31 |       1.4864 | 

|    3 | Accept |        0.52 |     0.44395 |       0.115 |      0.1152 |     0.028415 |     0.014369 | 

|    4 | Accept |        0.61 |     0.21798 |       0.115 |     0.11504 |       133.94 |    0.0031427 | 

|    5 | Accept |        0.34 |      0.3229 |       0.115 |     0.11504 |     0.010993 |       5.7742 | 

|    6 | Best   |       0.085 |     0.19964 |       0.085 |    0.085039 |       885.63 |      0.68403 | 

|    7 | Accept |       0.105 |     0.24149 |       0.085 |    0.085428 |       0.3057 |      0.58118 | 

|    8 | Accept |        0.21 |     0.40475 |       0.085 |     0.09566 |      0.16044 |      0.91824 | 

|    9 | Accept |       0.085 |     0.26232 |       0.085 |     0.08725 |       972.19 |      0.46259 | 

|   10 | Accept |         0.1 |      0.2218 |       0.085 |    0.090952 |       990.29 |        0.491 | 

|   11 | Best   |        0.08 |     0.20486 |        0.08 |    0.079362 |       2.5195 |        0.291 | 

|   12 | Accept |        0.09 |     0.16831 |        0.08 |     0.08402 |       14.338 |      0.44386 | 

|   13 | Accept |         0.1 |     0.35192 |        0.08 |     0.08508 |    0.0022577 |      0.23803 | 

|   14 | Accept |        0.11 |     0.18252 |        0.08 |    0.087378 |       0.2115 |      0.32109 | 

|   15 | Best   |        0.07 |     0.37931 |        0.07 |    0.081507 |        910.2 |      0.25218 | 

|   16 | Best   |       0.065 |     0.21272 |       0.065 |    0.072457 |       953.22 |      0.26253 | 

|   17 | Accept |       0.075 |     0.34893 |       0.065 |    0.072554 |       998.74 |      0.23087 | 

|   18 | Accept |       0.295 |     0.24279 |       0.065 |    0.072647 |       996.18 |       44.626 | 

|   19 | Accept |        0.07 |     0.25015 |       0.065 |     0.06946 |       985.37 |      0.27389 | 

|   20 | Accept |       0.165 |     0.23183 |       0.065 |    0.071622 |     0.065103 |      0.13679 | 

|=====================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstraint|  KernelScale | |      | result |             | runtime     | (observed)  | (estim.)    |              |              | |=====================================================================================================| |   21 | Accept |       0.345 |     0.23514 |       0.065 |    0.071764 |        971.7 |       999.01 | 

|   22 | Accept |        0.61 |     0.31666 |       0.065 |    0.071967 |    0.0010168 |    0.0010005 | 

|   23 | Accept |       0.345 |      0.2052 |       0.065 |    0.071959 |    0.0010674 |       999.18 | 

|   24 | Accept |        0.35 |     0.19984 |       0.065 |    0.071863 |    0.0010003 |       40.628 | 

|   25 | Accept |        0.24 |     0.39655 |       0.065 |    0.072124 |       996.55 |       10.423 | 

|   26 | Accept |        0.61 |     0.20282 |       0.065 |    0.072068 |       958.64 |    0.0010026 | 

|   27 | Accept |        0.47 |     0.34322 |       0.065 |     0.07218 |       993.69 |     0.029723 | 

|   28 | Accept |         0.3 |     0.40935 |       0.065 |    0.072291 |       993.15 |       170.01 | 

|   29 | Accept |        0.16 |     0.84263 |       0.065 |    0.072104 |       992.81 |       3.8594 | 

|   30 | Accept |       0.365 |     0.24255 |       0.065 |    0.072112 |    0.0010017 |     0.044287 | 

__________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 80.2722 seconds. Total objective function evaluation time: 8.9359  Best observed feasible point:     BoxConstraint    KernelScale     _____________    ___________         953.22          0.26253    Observed objective function value = 0.065 Estimated objective function value = 0.072112 Function evaluation time = 0.21272  Best estimated feasible point (according to models):     BoxConstraint    KernelScale     _____________    ___________         985.37          0.27389    Estimated objective function value = 0.072112 Estimated function evaluation time = 0.27901 

svmmod =    ClassificationSVM                          ResponseName: 'Y'                 CategoricalPredictors: []                            ClassNames: [-1 1]                        ScoreTransform: 'none'                       NumObservations: 200     HyperparameterOptimizationResults: [1x1 BayesianOptimization]                                 Alpha: [77x1 double]                                  Bias: -0.2352                      KernelParameters: [1x1 struct]                        BoxConstraints: [200x1 double]                       ConvergenceInfo: [1x1 struct]                       IsSupportVector: [200x1 logical]                                Solver: 'SMO'     Properties, Methods  

Encuentre la pérdida del modelo optimizado.

lossnew = kfoldLoss(fitcsvm(cdata,grp,'CVPartition',c,'KernelFunction','rbf',...     'BoxConstraint',svmmod.HyperparameterOptimizationResults.XAtMinObjective.BoxConstraint,...     'KernelScale',svmmod.HyperparameterOptimizationResults.XAtMinObjective.KernelScale))

lossnew = 0.0650 

Esta pérdida es la misma que la pérdida notificada en la salida de optimización en "Valor de función objetivo observado".

Visualice el clasificador optimizado.

d = 0.02; [x1Grid,x2Grid] = meshgrid(min(cdata(:,1)):d:max(cdata(:,1)),...     min(cdata(:,2)):d:max(cdata(:,2))); xGrid = [x1Grid(:),x2Grid(:)]; [~,scores] = predict(svmmod,xGrid); figure; h = nan(3,1); % Preallocation h(1:2) = gscatter(cdata(:,1),cdata(:,2),grp,'rg','+*'); hold on h(3) = plot(cdata(svmmod.IsSupportVector,1),...     cdata(svmmod.IsSupportVector,2),'ko'); contour(x1Grid,x2Grid,reshape(scores(:,2),size(x1Grid)),[0 0],'k'); legend(h,{'-1','+1','Support Vectors'},'Location','Southeast'); axis equal hold off

Trazar regiones de probabilidad posterior para modelos de clasificación SVM

Este ejemplo muestra cómo predecir las probabilidades posteriores de los modelos SVM a través de una cuadrícula de observaciones y, a continuación, trazar las probabilidades posteriores sobre la cuadrícula. La gráfica de probabilidades posteriores expone los límites de decisión.

Cargue el conjunto de datos de iris de Fisher. Entrena al clasificador usando las longitudes y anchuras de los pétalos, y elimina las especies virginicas de los datos.

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

Entrene un clasificador SVM utilizando los datos. Se recomienda especificar el orden de las clases.

SVMModel = fitcsvm(X,y,'ClassNames',{'setosa','versicolor'});

Calcule la función de transformación de puntuación óptima.

rng(1); % For reproducibility [SVMModel,ScoreParameters] = fitPosterior(SVMModel); 

Warning: Classes are perfectly separated. The optimal score-to-posterior transformation is a step function. 

ScoreParameters

ScoreParameters = struct with fields:
                        Type: 'step'
                  LowerBound: -0.8431
                  UpperBound: 0.6897
    PositiveClassProbability: 0.5000

La función de transformación de puntuación óptima es la función de paso porque las clases son separables. Los campos y de indican los puntos del extremo inferior y superior del intervalo de puntuaciones correspondientea a las observaciones dentro de los hiperplanos de separación de clases (el margen).LowerBoundUpperBoundScoreParameters Ninguna observación de entrenamiento está dentro del margen. Si una nueva puntuación está en el intervalo, el software asigna a la observación correspondiente una probabilidad posterior de clase positiva, es decir, el valor en el campo de .PositiveClassProbabilityScoreParameters

Defina una cuadrícula de valores en el espacio predictor observado. Predecir las probabilidades posteriores para cada instancia de la cuadrícula.

xMax = max(X); xMin = min(X); d = 0.01; [x1Grid,x2Grid] = meshgrid(xMin(1):d:xMax(1),xMin(2):d:xMax(2));  [~,PosteriorRegion] = predict(SVMModel,[x1Grid(:),x2Grid(:)]);

Trazar la región de probabilidad posterior de clase positiva y los datos de entrenamiento.

figure; contourf(x1Grid,x2Grid,...         reshape(PosteriorRegion(:,2),size(x1Grid,1),size(x1Grid,2))); h = colorbar; h.Label.String = 'P({\it{versicolor}})'; h.YLabel.FontSize = 16; caxis([0 1]); colormap jet;  hold on gscatter(X(:,1),X(:,2),y,'mc','.x',[15,10]); sv = X(SVMModel.IsSupportVector,:); plot(sv(:,1),sv(:,2),'yo','MarkerSize',15,'LineWidth',2); axis tight hold off

En el aprendizaje de dos clases, si las clases son separables, entonces hay tres regiones: una donde las observaciones tienen probabilidad posterior de clase positiva, una donde está, y la otra donde es la probabilidad previa de la clase positiva.01

Analizar imágenes utilizando máquinas vectoriales de soporte lineal

En este ejemplo se muestra cómo determinar qué cuadrante de una imagen ocupa una forma mediante el entrenamiento de un modelo de códigos de salida de corrección de errores (ECOC) compuesto por alumnos binarios SVM lineales. Este ejemplo también ilustra el consumo de espacio en disco de los modelos ECOC que almacenan vectores de soporte, sus etiquetas y el estimado

<math display="block">

<mrow>

<mi>α</mi>

</mrow>

</math>

Coeficientes.

Crear el conjunto de datos

Coloque aleatoriamente un círculo con radio cinco en una imagen de 50 por 50. Haga 5000 imágenes. Cree una etiqueta para cada imagen que indique el cuadrante que ocupa el círculo. El cuadrante 1 está en la parte superior derecha, el cuadrante 2 está en la parte superior izquierda, el cuadrante 3 está en la parte inferior izquierda y el cuadrante 4 en la parte inferior derecha. Los predictores son las intensidades de cada píxel.

d = 50;  % Height and width of the images in pixels n = 5e4; % Sample size  X = zeros(n,d^2); % Predictor matrix preallocation  Y = zeros(n,1);   % Label preallocation theta = 0:(1/d):(2*pi); r = 5;            % Circle radius rng(1);           % For reproducibility  for j = 1:n     figmat = zeros(d);                       % Empty image     c = datasample((r + 1):(d - r - 1),2);   % Random circle center     x = r*cos(theta) + c(1);                 % Make the circle      y = r*sin(theta) + c(2);                    idx = sub2ind([d d],round(y),round(x));  % Convert to linear indexing     figmat(idx) = 1;                         % Draw the circle     X(j,:) = figmat(:);                % Store the data     Y(j) = (c(2) >= floor(d/2)) + 2*(c(2) < floor(d/2)) + ...         (c(1) < floor(d/2)) + ...         2*((c(1) >= floor(d/2)) & (c(2) < floor(d/2))); % Determine the quadrant end

Trazar una observación.

figure imagesc(figmat) h = gca; h.YDir = 'normal'; title(sprintf('Quadrant %d',Y(end)))

Capacitar el modelo ECOC

Utilice una muestra de retención del 25% y especifique los índices de muestra de entrenamiento y retención.

p = 0.25; CVP = cvpartition(Y,'Holdout',p); % Cross-validation data partition isIdx = training(CVP);            % Training sample indices oosIdx = test(CVP);               % Test sample indices

Cree una plantilla SVM que especifique el almacenamiento de los vectores de soporte de los alumnos binarios. Páselo y los datos de entrenamiento para entrenar el modelo.fitcecoc Determine el error de clasificación del ejemplo de entrenamiento.

t = templateSVM('SaveSupportVectors',true); MdlSV = fitcecoc(X(isIdx,:),Y(isIdx),'Learners',t); isLoss = resubLoss(MdlSV)

isLoss = 0 

es un modelo multiclase entrenado.MdlSVClassificationECOC Almacena los datos de entrenamiento y los vectores de soporte de cada alumno binario. Para grandes conjuntos de datos, como los del análisis de imágenes, el modelo puede consumir mucha memoria.

Determine la cantidad de espacio en disco que consume el modelo ECOC.

infoMdlSV = whos('MdlSV'); mbMdlSV = infoMdlSV.bytes/1.049e6

mbMdlSV = 763.6151 

El modelo consume 763,6 MB.

Mejorar la eficiencia del modelo

Puede evaluar el rendimiento fuera de muestra. También puede evaluar si el modelo se ha sobreajustado con un modelo compactado que no contiene los vectores de soporte, sus parámetros relacionados y los datos de entrenamiento.

Deseche los vectores de soporte y los parámetros relacionados del modelo ECOC entrenado. A continuación, descarte los datos de entrenamiento del modelo resultante mediante .compact

Mdl = discardSupportVectors(MdlSV); CMdl = compact(Mdl); info = whos('Mdl','CMdl'); [bytesCMdl,bytesMdl] = info.bytes; memReduction = 1 - [bytesMdl bytesCMdl]/infoMdlSV.bytes

memReduction = 1×2

    0.0626    0.9996

En este caso, descartar los vectores de soporte reduce el consumo de memoria en aproximadamente un 6%. Compactar y descartar vectores de soporte reduce el tamaño en aproximadamente un 99,96%.

Una forma alternativa de administrar vectores de soporte es reducir sus números durante el entrenamiento especificando una restricción de cuadro más grande, como 100. Aunque los modelos SVM que utilizan menos vectores de soporte son más deseables y consumen menos memoria, aumentar el valor de la restricción de cuadro tiende a aumentar el tiempo de entrenamiento.

Quitar y del espacio de trabajo.MdlSVMdl

clear Mdl MdlSV

Evaluar el rendimiento de la muestra de retención

Calcule el error de clasificación de la muestra de retención. Trazar una muestra de las predicciones de ejemplo de retención.

oosLoss = loss(CMdl,X(oosIdx,:),Y(oosIdx))

oosLoss = 0 

yHat = predict(CMdl,X(oosIdx,:)); nVec = 1:size(X,1); oosIdx = nVec(oosIdx);  figure; for j = 1:9     subplot(3,3,j)     imagesc(reshape(X(oosIdx(j),:),[d d]))     h = gca;     h.YDir = 'normal';     title(sprintf('Quadrant: %d',yHat(j))) end text(-1.33*d,4.5*d + 1,'Predictions','FontSize',17)

El modelo no clasifica erróneamente ninguna observación de muestra de retención.

Consulte también

bayesopt | fitcsvm | kfoldLoss

Temas relacionados

• Train Support Vector Machines Using Classification Learner App
• Optimize a Cross-Validated SVM Classifier Using bayesopt

Referencias

[1] Hastie, T., R. Tibshirani, and J. Friedman. The Elements of Statistical Learning, second edition. New York: Springer, 2008.

[2] Christianini, N., and J. Shawe-Taylor. An Introduction to Support Vector Machines and Other Kernel-Based Learning Methods. Cambridge, UK: Cambridge University Press, 2000.

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

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

×

Abrir ejemplo

Existe una versión modificada de este ejemplo en su sistema. ¿Prefiere abrir esta versión?

No, sobrescribir la versión modificada Sí