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.
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) Xj junto con sus categorías y yj. Para alguna dimensión, eld xj ∊ Rd, y el yj = ±1. La ecuación de un hiperplano es
Dónde β ∊ Rd 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βXj,y yj),
Los vectores de soporte son los Xj en el límite, aquellos para los que
Para mayor comodidad matemática, el problema se suele dar como el problema equivalente de minimizar . Este es un problema de programación cuadrática. La solución óptima permite la clasificación de un vector de la siguiente manera:z
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:
donde se busca un punto estacionario de LP una y .βb Ajuste del gradiente de LP a 0, se obtiene
(1) |
Sustituir a LP, se obtiene el doble LD:
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 yjXj. Los puntos de datos Xj correspondiente a distinto de cero Αj son el archivo .vectores de apoyo
El derivado de LD con respecto a un distinto de cero Αj es 0 en un óptimo. Esto da
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)
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
elL1-el problema de la norma es:
tal que
elL1-norm se refiere al uso de Ξj como variables holgantes en lugar de sus cuadrados. Las tres opciones del solucionador, y de minimizar laSMO
ISDA
L1QP
fitcsvm
L1-problema de norma.
elL2-el problema de la norma es:
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 laL1 doble problema a esta formulación de margen suave. Uso de multiplicadores Lagrange Μj, la función a minimizar para elL1-el problema de la norma es:
donde se busca un punto estacionario de LP más de , , y positivoβb Ξj. Ajuste del gradiente de LP a 0, se obtiene
Estas ecuaciones conducen directamente a la formulación dual:
sujeto a las limitaciones
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 laL2-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 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)
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 (Gx1,x2) con la siguiente propiedad. Hay un espacio lineal y una asignación de funciones para queSφxS
G(x1,x2) = < (φx1),φ(x2)>.
El producto punto tiene lugar en el espacio .S
Esta clase de funciones incluye:
Polinomios: Para algún entero positivo,p
G(x1,x2) (1 +x1′x2)p.
Función de base radial (gaussiana):
G(x1,x2) á exp(–-?x1–x2)A)2).
Perceptrón multicapa o sigmoide (red neuronal): Para un número positivop1 y un número negativop2,
G(x1,x2) - tanh(p1x1′x2 +p2).
Nota
No todos los conjuntos dep1 Yp2 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
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.
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.Y
X
Y
— 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'
ClassNames
Y
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
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.Etiqueta
X
score
n 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.ScoreTransform
ScoreSVMModel
Pase a .ScoreSVMModel
predict
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 ).score
score
score
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 .bayesopt
Optimize 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.bayesopt
fitcsvm
También puede intentar ajustar los parámetros de su clasificador manualmente de acuerdo con este esquema:
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
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.
Pase el modelo de SVM validado de forma cruzada a kfoldLoss
para estimar y conservar el error de clasificación.
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-5
1e5
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:
Recuperar la escala original del núcleo, por ejemplo, mediante notación de puntos: .ks
ks = SVMModel.KernelParameters.Scale
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.ks
1e-5
1e5
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.
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
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'
BoxConstraint
Inf
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.BoxConstraint
1
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
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.Mdl1
ClassificationSVM
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%.
En este ejemplo se muestra cómo optimizar una clasificación SVM mediante el par función y nombre-valor.fitcsvm
OptimizeHyperparameters
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:
Elija un punto base del color adecuado uniformemente al azar.m
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
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).LowerBound
UpperBound
ScoreParameters
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 .PositiveClassProbability
ScoreParameters
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.0
1
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
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.MdlSV
ClassificationECOC
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.MdlSV
Mdl
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.
bayesopt
| fitcsvm
| kfoldLoss
[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.