fitcsvm - svm matlab example

Validación cruzada de 10 veces en SVM uno contra todos(usando LibSVM)

Question

Quiero hacer una validación cruzada de 10 veces en mi clasificación de máquinas vectoriales de soporte contra todos en MATLAB.

Traté de mezclar de alguna manera estas dos respuestas relacionadas:

• Clasificación de clases múltiples en libsvm
• Ejemplo de 10 veces la clasificación de SVM en MATLAB

Pero como soy nuevo en MATLAB y su sintaxis, no pude hacerlo funcionar hasta ahora.

Por otro lado, vi solo las siguientes líneas acerca de la validación cruzada en los archivos README de LibSVM y no pude encontrar ningún ejemplo relacionado allí:

option -v divide aleatoriamente los datos en n partes y calcula la precisión de la validación cruzada / error cuadrático medio en ellos.

Consulte las preguntas frecuentes de libsvm sobre el significado de los resultados.

¿Alguien podría darme un ejemplo de 10 veces la validación cruzada y la clasificación uno contra todos?

Answer 1

Principalmente hay dos razones por las que hacemos la validación cruzada :

• como un método de prueba que nos da una estimación casi imparcial del poder de generalización de nuestro modelo (evitando el sobreajuste)
• como una forma de selección del modelo (p. ej .: encuentre los mejores parámetros C y gamma sobre los datos de entrenamiento, consulte esta publicación para ver un ejemplo)

Para el primer caso en el que estamos interesados, el proceso implica el entrenamiento de k modelos para cada pliegue, y luego el entrenamiento de un modelo final en todo el conjunto de entrenamiento. Reportamos la precisión promedio sobre los k-pliegues.

Ahora que estamos utilizando el enfoque de uno contra todos para manejar el problema de clases múltiples, cada modelo consiste en máquinas de vectores de soporte N (una para cada clase).

Las siguientes son funciones de envoltura que implementan el enfoque de uno contra todos:

function mdl = libsvmtrain_ova(y, X, opts)
    if nargin < 3, opts = ''''; end

    %# classes
    labels = unique(y);
    numLabels = numel(labels);

    %# train one-against-all models
    models = cell(numLabels,1);
    for k=1:numLabels
        models{k} = libsvmtrain(double(y==labels(k)), X, strcat(opts,'' -b 1 -q''));
    end
    mdl = struct(''models'',{models}, ''labels'',labels);
end

function [pred,acc,prob] = libsvmpredict_ova(y, X, mdl)
    %# classes
    labels = mdl.labels;
    numLabels = numel(labels);

    %# get probability estimates of test instances using each 1-vs-all model
    prob = zeros(size(X,1), numLabels);
    for k=1:numLabels
        [~,~,p] = libsvmpredict(double(y==labels(k)), X, mdl.models{k}, ''-b 1 -q'');
        prob(:,k) = p(:, mdl.models{k}.Label==1);
    end

    %# predict the class with the highest probability
    [~,pred] = max(prob, [], 2);
    %# compute classification accuracy
    acc = mean(pred == y);
end

Y aquí hay funciones para respaldar la validación cruzada:

function acc = libsvmcrossval_ova(y, X, opts, nfold, indices)
    if nargin < 3, opts = ''''; end
    if nargin < 4, nfold = 10; end
    if nargin < 5, indices = crossvalidation(y, nfold); end

    %# N-fold cross-validation testing
    acc = zeros(nfold,1);
    for i=1:nfold
        testIdx = (indices == i); trainIdx = ~testIdx;
        mdl = libsvmtrain_ova(y(trainIdx), X(trainIdx,:), opts);
        [~,acc(i)] = libsvmpredict_ova(y(testIdx), X(testIdx,:), mdl);
    end
    acc = mean(acc);    %# average accuracy
end

function indices = crossvalidation(y, nfold)
    %# stratified n-fold cros-validation
    %#indices = crossvalind(''Kfold'', y, nfold);  %# Bioinformatics toolbox
    cv = cvpartition(y, ''kfold'',nfold);          %# Statistics toolbox
    indices = zeros(size(y));
    for i=1:nfold
        indices(cv.test(i)) = i;
    end
end

Finalmente, aquí hay una demostración simple para ilustrar el uso:

%# laod dataset
S = load(''fisheriris'');
data = zscore(S.meas);
labels = grp2idx(S.species);

%# cross-validate using one-vs-all approach
opts = ''-s 0 -t 2 -c 1 -g 0.25'';    %# libsvm training options
nfold = 10;
acc = libsvmcrossval_ova(labels, data, opts, nfold);
fprintf(''Cross Validation Accuracy = %.4f%%/n'', 100*mean(acc));

%# compute final model over the entire dataset
mdl = libsvmtrain_ova(labels, data, opts);

Compare eso con el enfoque de uno contra uno que es utilizado por defecto por libsvm:

acc = libsvmtrain(labels, data, sprintf(''%s -v %d -q'',opts,nfold));
model = libsvmtrain(labels, data, strcat(opts,'' -q''));

Answer 2

Puede confundirte que una de las dos preguntas no sea sobre LIBSVM. Deberías tratar de ajustar esta respuesta e ignorar la otra.

Debe seleccionar los pliegues y hacer el resto exactamente como la pregunta vinculada. Suponga que los datos se han cargado en los data y las etiquetas en labels :

n = size(data,1);
ns = floor(n/10);
for fold=1:10,
    if fold==1,
        testindices= ((fold-1)*ns+1):fold*ns;
        trainindices = fold*ns+1:n;
    else
        if fold==10,
            testindices= ((fold-1)*ns+1):n;
            trainindices = 1:(fold-1)*ns;
        else
            testindices= ((fold-1)*ns+1):fold*ns;
            trainindices = [1:(fold-1)*ns,fold*ns+1:n];
         end
    end
    % use testindices only for testing and train indices only for testing
    trainLabel = label(trainindices);
    trainData = data(trainindices,:);
    testLabel = label(testindices);
    testData = data(testindices,:)
    %# train one-against-all models
    model = cell(numLabels,1);
    for k=1:numLabels
        model{k} = svmtrain(double(trainLabel==k), trainData, ''-c 1 -g 0.2 -b 1'');
    end

    %# get probability estimates of test instances using each model
    prob = zeros(size(testData,1),numLabels);
    for k=1:numLabels
        [~,~,p] = svmpredict(double(testLabel==k), testData, model{k}, ''-b 1'');
        prob(:,k) = p(:,model{k}.Label==1);    %# probability of class==k
    end

    %# predict the class with the highest probability
    [~,pred] = max(prob,[],2);
    acc = sum(pred == testLabel) ./ numel(testLabel)    %# accuracy
    C = confusionmat(testLabel, pred)                   %# confusion matrix
end