Skip to content

Instantly share code, notes, and snippets.

@abrahamhurtado

abrahamhurtado/cancer_svm.mat

Created May 20, 2019 11:26
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save abrahamhurtado/21aa09e864270df74dc014fc7b4aae18 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save abrahamhurtado/21aa09e864270df74dc014fc7b4aae18 to your computer and use it in GitHub Desktop.
Download ZIP
Aplicación de LOOCV con SVM para el dataset de breast cancer de UCI.
Raw
cancer_svm.mat
% renombramos las variables del dataset para su reutilización
labels = LABELS;
samples = SAMPLES;
% matriz que contendrá todas las predicciones del algoritmo para cada
% data point del set original
predicciones = zeros(size(labels));
% recorremos todo el dataset
for i = 1:length(samples);
% como estamos utilizando Leave One Out Cross Validation (LOOCV),
% tendremos que separar un data point de la matriz original para usarlo
% como TEST y al resto como TRAIN. El data point de TEST se elige por
% la iteración actual.
test_label = labels(i,:);
test_sample = samples(i,:);
% El conjunto de TEST es igual a todo el cojunto...
train_labels = labels;
train_sample = samples;
% excepto por el data point de TEST, que es de la posición i
train_labels(i,:) = [];
train_sample(i,:) = [];
% Hacemos data mapping de cada clase
benignos_labels_map = train_labels == 2;
malignos_labels_map = train_labels == 4;
% Y con eso, separamos el dataset en dos conjuntos, cada uno para cada
% clase
benignos_samples = train_sample(benignos_labels_map, :);
malignos_samples = train_sample(malignos_labels_map, :);
% Formateo de los labels de cada conjunto
benignos_labels = ones(length(benignos_samples), 1);
malignos_labels = zeros(length(malignos_samples), 1);
benignos_labels(:,:) = 2;
malignos_labels(:,:) = 4;
% Le damos formato a los datos para ser procesados por LibSVM
todos_labels = [benignos_labels; malignos_labels];
todos_samples = [benignos_samples; malignos_samples];
% Alimentamos los datos a libsvm
svmstruct = svmtrain(todos_labels, todos_samples, '-s 0 -q');
[prediccion_label, ac, p] = svmpredict(test_label, test_sample, svmstruct, '-q');
% Añadimos la predicción a nuestra matriz de predicciones
predicciones(i,:) = prediccion_label;
end
% Accuracy general
disp('Accurary general');
disp(sum(predicciones == labels)/length(labels));
disp('');
% Precision, Recall, FScore para Benignos
% En esta parte calculamos los Verdaderos Positivos, Verdaderos Negativos,
% Falsos Positivos, Falsos Negativos
% ¿Cómo los calculamos?
% Hacemos data mapping a la matriz de predicciones y a la matriz de labels,
% con la clase que queremos estudiar, el resultado son dos matrices
% (PrediccionesMap y LabelsMap) que contienen valores de 0 a 1. Como ambas
% matrices son de la misma longitud, se pueden comparar valor por valor y,
% visualmente, podemos ver como están representadas las cuatro
% clasificaciones de cada predicción.
% PMap LMap
% 1 1 (Verdadero Positivo)
% 1 0 (Falso Positivo)
% 0 1 (Falso Negativo)
% 0 0 (Verdadero Negativo)
% ¿Pero cómo podemos representar esos valores lógicamente? Apli cando suma y
% resta entre las matrices PrediccionMap y LabelsMap.
% Si hacemos PMap + LMap, obtendremos una matriz que contiene los
% siguientes valores: 2, 1 y 0, dónde el 2 representa que el datapoint
% correspondiente es un Verdadero Positivo, el 0 representa que el
% datapoint es un Verdadero Negativo y el 1 representa que es un valor
% Falso, que puede ser Positivo o Negativo; para diferenciar entre éstos es
% que aplicamos la operación PMap - LMapp, que nos devuelve una matriz que
% contiene los valores 1, 0 y -1, dónde 1 significa que el datapoint es un
% Falso Positivo, -1 significa que el datapoint es un Falso Negativo y el
% 0, significa que el datapoint es un valor Verdadero, pero que no podemos
% distinguir entre Positivo y Negativo, y para diferenciarlos, ya hicimos
% la operación PMap + LMap anteriormente.
benignos_verdaderos = (predicciones == 2) + (labels == 2);
benignos_verdaderos_positivos = sum(benignos_verdaderos == 2);
benignos_verdaderos_negativos = sum(benignos_verdaderos == 0);
benignos_falsos = (predicciones == 2) - (labels == 2);
benignos_falsos_positivos = sum(benignos_falsos == 1);
benignos_falsos_negativos = sum(benignos_falsos == -1);
disp('BENIGNOS')
% Accuracy
disp('Accuracy: ');
benignos_accuracy = (benignos_verdaderos_positivos + benignos_verdaderos_negativos) / (benignos_verdaderos_positivos + benignos_verdaderos_negativos + benignos_falsos_positivos + benignos_falsos_negativos);
disp(benignos_accuracy);
disp('');
% Preicision
disp('Precision: ');
benignos_precision = benignos_verdaderos_positivos / (benignos_verdaderos_positivos + benignos_falsos_positivos);
disp(benignos_precision);
disp('');
% Recall
disp('Recall: ');
benignos_recall = benignos_verdaderos_positivos / (benignos_verdaderos_positivos + benignos_falsos_negativos);
disp(benignos_recall);
disp('');
% FScore
disp('FScore de Benignos: ');
benignos_fscore = 2 * (benignos_recall * benignos_precision) / (benignos_recall + benignos_precision);
disp(benignos_fscore);
disp('');
% Precision, Recall, FScore para Malignos
malignos_verdaderos = (predicciones == 4) + (labels == 4);
malignos_verdaderos_positivos = sum(malignos_verdaderos == 2);
malignos_verdaderos_negativos = sum(malignos_verdaderos == 0);
malignos_falsos = (predicciones == 4) - (labels == 4);
malignos_falsos_positivos = sum(malignos_falsos == 1);
malignos_falsos_negativos = sum(malignos_falsos == -1);
disp('MALIGNOS');
% Accuracy
disp('Accuracy: ');
malignos_accuracy = (malignos_verdaderos_positivos + malignos_verdaderos_negativos) / (malignos_verdaderos_positivos + malignos_verdaderos_negativos + malignos_falsos_positivos + malignos_falsos_negativos);
disp(malignos_accuracy);
disp('');
% Precision
disp('Precision: ');
malignos_precision = malignos_verdaderos_positivos / (malignos_verdaderos_positivos + malignos_falsos_positivos);
disp(malignos_precision);
disp('');
% Recall
disp('Recall: ');
malignos_recall = malignos_verdaderos_positivos / (malignos_verdaderos_positivos + malignos_falsos_negativos);
disp(malignos_recall);
disp('');
% FScore
disp('FScore: ');
malignos_fscore = 2 * (malignos_precision * malignos_recall) / (malignos_precision + malignos_recall);
disp(malignos_fscore);
disp('');
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment