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 de vectores de soporte para clasificación binaria

Entender las máquinas de vectores de soporte

• Datos separables

• Datos no separables

• Transformación no lineal con kernels

Datos separables

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

Son los puntos de datos más cercanos al hiperplano separador; estos puntos están en el límite de la losa.vectores de soporte 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 la formación son un conjunto de puntos (vectores) X_j junto con sus categorías y_j. Para algunas dimensiones, 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 separador (es decir, el límite de decisión).Mejor Busque y minimice | | || tal que para todos los puntos de datos (βbβX_j,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 la conveniencia 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 la y representa la distancia es desde el límite de decisión.puntuación de clasificaciónz

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

$$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 y.βb Establecer el degradado de L_P a 0, obtienes

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

(1)

Sustituyendo en L_P, obtienes 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 maximizan sobre α_j ≥ 0. En general, muchos Α_j son 0 al máximo. El distinto de cero Α_j en la solución al problema dual definen el hiperplano, como se ve en, que da como la suma deEcuación 1β Α_jy_jX_j. Los puntos de datos X_j correspondiente a distinto de cero Α_j son los.vectores de soporte

La derivada de L_D con respecto a un Α_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 cualquier con distinto de cerobj Α_j.

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

Datos no separables

Es posible que los datos no permitan un hiperplano de separación. En ese caso, SVM puede utilizar a, es decir, un hiperplano que separa muchos, pero no todos los puntos de datos.margen blando

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

• elL¹problema de 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 de Slack en lugar de sus cuadrados. Las tres opciones de solucionador, y de minimizar elSMOISDAL1QPfitcsvmL¹problema de norma.

• elL²problema de norma es:

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

  sujeto a las mismas restricciones.

En estas formulaciones, se puede ver que aumentar los lugares más peso en las variables de SlackC Ξ_j, lo que significa que la optimización intenta hacer 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: doble.  Para cálculos más fáciles, considere laL¹ doble problema a esta formulación de margen blando. El uso de multiplicadores de Lagrange Μ_j, la función para minimizar elL¹problema de 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 , y positivoβb Ξ_j. Establecer el degradado de L_P a 0, obtienes

$$\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}}$$

sujeta a las restricciones

$$\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 a. mantiene los valores permitidos de los multiplicadores de LagrangeCrestricción de cuadroC Α_j en una "caja", una región delimitada.

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

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

Implementación de fitcsvm.  Ambos problemas de margen suave dual son problemas de programación cuadrática. 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 los valores atípicos esperados en los datos (consulte), el solucionador predeterminado es la 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,$$ y explícitamente incluye 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 de datos único iterativo. Al igual que SMO, ISDA resuelve el problema de una norma. A diferencia de SMO, ISDA minimiza por una serie de 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 usted tiene una licencia, usted puede elegir utilizar para resolver el problema de una norma. utiliza una buena cantidad de memoria, pero resuelve los programas cuadráticos a un alto grado de precisión.Optimization Toolboxquadprogquadprog Para obtener más información, consulte.Definición de programación cuadrática (Optimization Toolbox)

Transformación no lineal con kernels

Algunos problemas de clasificación binaria no tienen un hiperplano simple como criterio de separación útil. Para estos problemas, hay una variante del enfoque matemático que retiene casi toda la simplicidad de un hiperplano de separación de 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 función a tal queSφxS

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

  El producto punto tiene lugar en el espacio.S

• Esta clase de funciones incluye:

  • Polinomios: Para un número entero positivo,p

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

  • Función de base radial (gaussiana):

    (Gx₁,x₂) = exp (– ∥x₁–x₂)∥²).

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

    (Gx₁,x₂) = tanh (p₁x₁′x₂ +p₂).

    Nota

    • No cada conjunto dep₁ Yp₂ produce un kernel de reproducción válido.

    • no es compatible con el kernel sigmoide.fitcsvm En su lugar, puede definir el kernel sigmoide y especificarlo mediante el argumento de par nombre-valor.'KernelFunction' Para obtener más información, consulte.Entrenar clasificador SVM utilizando kernel personalizado

El enfoque matemático que utiliza kernels se basa en el método computacional de los hiperplanos. Todos los cálculos para la clasificación de hiperplano no utilizan nada más que productos de punto. 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

El uso de máquinas de vectores de soporte

Al igual que con cualquier modelo de aprendizaje supervisado, primero se entrena una máquina de vectores de soporte y luego se cruza la validación del 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 de SVM, y debe ajustar los parámetros de las funciones del kernel.

• Entrenar un clasificador de SVM

• Clasificar nuevos datos con un clasificador de SVM

• Ajustar un clasificador de SVM

Entrenar un clasificador de SVM

Entrenar y, opcionalmente, validar de forma cruzada un clasificador de SVM usando.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 caracteres o de cadena, un vector lógico o numérico o una matriz 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 predeterminado para el aprendizaje de una clase y especifica el uso del 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 apropiada del kernel.

• — 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 las clases que se incluirán 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 Es recomendable especificar los nombres de clase, especialmente si se compara el rendimiento de diferentes clasificadores.

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

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

Clasificar nuevos datos con un clasificador de SVM

Clasifique nuevos datos mediante predict. La sintaxis para clasificar nuevos datos utilizando 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 de puntuaciones suaves de-por-2.EtiquetaXPuntuaciónn 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 las puntuaciones que se clasifican en la clase positiva.

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

ScoreSVMModel = fitPosterior(SVMModel,X,Y);

La propiedad del clasificador contiene la función de transformación óptima.ScoreTransformScoreSVMModel Pasar a.ScoreSVMModelPredecir 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).PuntuaciónPuntuaciónPuntuación

Ajustar un clasificador de SVM

Utilice el argumento de par nombre-valor de 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 ver un ejemplo, vea.Optimice un ajuste del clasificador SVM usando la optimización bayesiana Alternativamente, puede utilizar la función, como se muestra en.bayesoptOptimice un clasificador SVM con validación cruzada mediantebayesopt 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 del clasificador manualmente de acuerdo con este esquema:

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

2. Cross valida el clasificador pasándole a crossval. De forma predeterminada, el software realiza una validación cruzada de 10 veces.

3. Pase el modelo SVM validado por la Cruz para kfoldLoss para estimar y retener el error de clasificación.

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

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

   • — Una estrategia es intentar una secuencia geométrica del parámetro RBF Sigma escalado a la escala del kernel original.KernelScale Haga esto al:

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

     2. Utilice como nuevos factores de escala del kernel 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 sus parámetros para obtener una mayor precisión. Comience con sus parámetros iniciales y realice otro paso de validación cruzada, esta vez usando un factor de 1,2.

Entrenar clasificadores SVM utilizando un kernel gaussiano

Este ejemplo muestra cómo generar un clasificador no lineal con la función del kernel gaussiano. Primero, genere una clase de puntos dentro del disco de la unidad en dos dimensiones, y otra clase de puntos en el anillo del radio 1 al radio 2. A continuación, genera un clasificador basado en los datos con el kernel de la función de base radial Gaussiana. El clasificador lineal por defecto es obviamente inadecuado para este problema, ya que el modelo es circularmente simétrico. Establezca el parámetro de restricción de cuadro para hacer 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 es posible que no puedan proporcionar una clasificación estricta. Aunque el clasificador Rbf puede separar las clases, el resultado puede ser sobreentrenado.

Genere 100 puntos uniformemente distribuidos 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 poner 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

Graficar 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;

Entrenar un clasificador SVM con set to y set to.KernelFunction'rbf'BoxConstraintInf Trace el límite de decisión y marque 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 un límite de clasificación más casi circular, pero uno que clasifica incorrectamente algunos datos de entrenamiento. Además, el valor predeterminado 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

Entrenar clasificador SVM utilizando kernel personalizado

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

Genere un conjunto aleatorio de puntos dentro del círculo de la unidad. Los puntos de etiqueta en el primer y tercer cuadrantes como pertenecientes a la clase positiva, y los del segundo y cuarto cuadrantes en 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 

Graficar 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 sigmoide.

 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 de MATLAB®.mysigmoid

Entrenar un clasificador SVM utilizando la función del kernel sigmoide. 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

Trace los datos e identifique 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 podría disminuir la tasa de clasificación errónea dentro de la muestra, pero primero debe determinar la tasa de clasificación errónea fuera de 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.1350  

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

Escriba otra función sigmoide, 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 de MATLAB®.mysigmoid2

Entrenar otro clasificador SVM utilizando el kernel sigmoide ajustado. Trace los datos y la región de decisión, y determine 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 por más de 66%.

Optimice un ajuste del clasificador SVM usando la optimización bayesiana

En este ejemplo se muestra cómo optimizar una clasificación de SVM mediante el par de 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), página 17 describe el modelo.The Elements of Statistical Learning El modelo comienza con la generación de 10 puntos de base para una clase "verde", distribuida como normales 2-D independientes con media (1, 0) y varianza de unidad. También genera 10 puntos base para una clase "roja", distribuida como normales 2-D independientes con media (0,1) y varianza de unidad. 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 una distribución normal en 2-D con la media y la 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 más claridad.

Genere 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 de base rojos están cerca de puntos de base verdes, puede ser difícil clasificar los puntos de datos en función de la ubicación por sí solo.

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 etiqueta la clase de cada punto.grp

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

Prepare la validación cruzada

Configure una partición para la validación cruzada. Este paso corrige los conjuntos de trenes y pruebas que utiliza la optimización en cada paso.

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

Optimice el Fit

Para encontrar un buen ajuste, es decir, uno con una pérdida de validación cruzada baja, establezca las 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 |      1.9791 |       0.345 |       0.345 |      0.00474 |       306.44 | |    2 | Best   |       0.115 |     0.52987 |       0.115 |     0.12678 |       430.31 |       1.4864 | |    3 | Accept |        0.52 |     0.30548 |       0.115 |      0.1152 |     0.028415 |     0.014369 | |    4 | Accept |        0.61 |     0.33018 |       0.115 |     0.11504 |       133.94 |    0.0031427 | |    5 | Accept |        0.34 |     0.53534 |       0.115 |     0.11504 |     0.010993 |       5.7742 | |    6 | Best   |       0.085 |     0.24329 |       0.085 |    0.085039 |       885.63 |      0.68403 | |    7 | Accept |       0.105 |     0.25509 |       0.085 |    0.085428 |       0.3057 |      0.58118 | |    8 | Accept |        0.21 |     0.44793 |       0.085 |     0.09566 |      0.16044 |      0.91824 | |    9 | Accept |       0.085 |     0.36844 |       0.085 |     0.08725 |       972.19 |      0.46259 | |   10 | Accept |         0.1 |     0.54416 |       0.085 |    0.090952 |       990.29 |        0.491 | |   11 | Best   |        0.08 |     0.24339 |        0.08 |    0.079362 |       2.5195 |        0.291 | |   12 | Accept |        0.09 |     0.28613 |        0.08 |     0.08402 |       14.338 |      0.44386 | |   13 | Accept |         0.1 |     0.56852 |        0.08 |     0.08508 |    0.0022577 |      0.23803 | |   14 | Accept |        0.11 |     0.88183 |        0.08 |    0.087378 |       0.2115 |      0.32109 | |   15 | Best   |        0.07 |     0.47299 |        0.07 |    0.081507 |        910.2 |      0.25218 | |   16 | Best   |       0.065 |     0.56562 |       0.065 |    0.072457 |       953.22 |      0.26253 | |   17 | Accept |       0.075 |     0.40486 |       0.065 |    0.072554 |       998.74 |      0.23087 | |   18 | Accept |       0.295 |      0.3027 |       0.065 |    0.072647 |       996.18 |       44.626 | |   19 | Accept |        0.07 |      0.4378 |       0.065 |     0.06946 |       985.37 |      0.27389 | |   20 | Accept |       0.165 |     0.35348 |       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.3715 |       0.065 |    0.071764 |        971.7 |       999.01 | |   22 | Accept |        0.61 |     0.37192 |       0.065 |    0.071967 |    0.0010168 |    0.0010005 | |   23 | Accept |       0.345 |     0.30894 |       0.065 |    0.071959 |    0.0010674 |       999.18 | |   24 | Accept |        0.35 |     0.28889 |       0.065 |    0.071863 |    0.0010003 |       40.628 | |   25 | Accept |        0.24 |     0.59111 |       0.065 |    0.072124 |       996.55 |       10.423 | |   26 | Accept |        0.61 |     0.31363 |       0.065 |    0.072068 |       958.64 |    0.0010026 | |   27 | Accept |        0.47 |     0.32193 |       0.065 |     0.07218 |       993.69 |     0.029723 | |   28 | Accept |         0.3 |     0.21378 |       0.065 |    0.072291 |       993.15 |       170.01 | |   29 | Accept |        0.16 |     0.84964 |       0.065 |    0.072104 |       992.81 |       3.8594 | |   30 | Accept |       0.365 |     0.22514 |       0.065 |    0.072112 |    0.0010017 |     0.044287 |  __________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 118.7525 seconds. Total objective function evaluation time: 13.9126  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.56562  Best estimated feasible point (according to models):     BoxConstraint    KernelScale     _____________    ___________         985.37          0.27389    Estimated objective function value = 0.072112 Estimated function evaluation time = 0.40507 

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 objetiva observada".

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 de SVM

En este ejemplo se muestra cómo predecir las probabilidades posteriores de los modelos SVM sobre una cuadrícula de observaciones y, a continuación, trazar las probabilidades posteriores sobre la cuadrícula. Trazar las probabilidades posteriores expone los límites de decisión.

Cargue el conjunto de datos de iris de Fisher. Entrena el clasificador usando las longitudes y anchos del pétalo, y elimina las especies virginicas de los datos.

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

Entrenar un clasificador SVM utilizando los datos. Es recomendable especificar el orden de las clases.

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

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

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 e indican los puntos inferiores y superiores del intervalo de puntuaciones correspondientes a las observaciones dentro de los hiperplanos de separación de clases (el margen).LowerBoundUpperBoundScoreParameters Ninguna observación de entrenamiento cae dentro del margen. Si una nueva puntuación está en el intervalo, a continuación, el software asigna la observación correspondiente una clase positiva de probabilidad posterior, es decir, el valor en el campo de.PositiveClassProbabilityScoreParameters

Defina una rejilla de valores en el espacio pronosticador observado. Predecir las probabilidades posteriores para cada instancia en 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(:)]);

Trace 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 los aprendizajes de dos clases, si son separables, entonces hay tres regiones: una donde las observaciones tienen una probabilidad posterior de clase positiva, una donde está, y la otra donde es la probabilidad previa de la clase positiva.01

Analizar imágenes mediante máquinas de vectores de soporte lineales

Este ejemplo 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 de SVM lineales. En este ejemplo también se ilustra el consumo de espacio en disco de los modelos ECOC que almacenan vectores de soporte, sus etiquetas y el estimado Coeficientes.

Cree el conjunto de datos

Coloque aleatoriamente un círculo con el radio cinco en una imagen de 50-by-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 

Trace una observación.

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

Entrenar el modelo ECOC

Utilice una muestra de retención del 25% y especifique los índices de muestreo de entrenamiento y de exclusió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 de SVM que especifique el almacenamiento de los vectores de soporte de los alumnos binarios. Pasarla y los datos de entrenamiento para entrenar el modelo.fitcecoc Determine el error de clasificación de muestra de entrenamiento.

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

 isLoss =       0  

es un modelo entrenado de varias clases.MdlSVClassificationECOC Almacena los datos de entrenamiento y los vectores de soporte de cada alumno binario. Para conjuntos de datos grandes, como los de 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.5919  

El modelo consume 1477,5 MB.

Mejore la eficiencia del modelo

Puede evaluar el rendimiento fuera de la muestra. También puede evaluar si el modelo se ha sobreajuste 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 utilizando.compact

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

 memReduction =      0.0626    0.9996  

En este caso, descartar los vectores de soporte reduce el consumo de memoria en aproximadamente un 3%. Compactando y desechando vectores de soporte reduce el tamaño en aproximadamente 99,99%.

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 de SVM que utilizan menos vectores de soporte son más deseables y consumen menos memoria, el aumento del valor de la restricción de cuadro tiende a aumentar el tiempo de entrenamiento.

Eliminar y desde el espacio de trabajo.MdlSVMdl

clear Mdl MdlSV; 

Evalúe el rendimiento de muestra de exclusión

Calcule el error de clasificación de la muestra de exclusión. Trace una muestra de las predicciones de ejemplo de exclusión.

oosLoss = loss(CMdl,X(oosIdx,:),Y(oosIdx)) 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) 

 oosLoss =       0  

El modelo no clasifica erróneamente las observaciones de la muestra de exclusión.

Consulte también

bayesopt | fitcsvm | kfoldLoss

Temas relacionados

• Entrenar máquinas de vectores de soporte usando la aplicación de clasificación aprendiz
• Optimice un clasificador SVM con validación cruzada mediantebayesopt

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.

×

Open Example (es)

A modified version of this example exists on your system. Do you want to open this version instead? (es)

No, overwrite the modified version (es) Yes (es)