Rsultats obtenus avec la premire toolbox ( Anton Schwaighofer)

1. Scripts Matlab.
a) Toolbox 1 : entrainement, classification et « test »
%Entraînement de la machine à vecteurs supports
%==================================
%Toolbox d'Anton Schwaighofer ( Graz)
clear all;
%Lecture de l'image d'entrainement et classification par la fonction « test » pour disposer
d’un ensemble d’entrainement
%Une réduction de taille est effectuée afin de ne pas trop gonfler les calculs
test; %On peut aller changer dans la fonction test l'image d'entrainement
fprintf('Test effectué\n');
%Dimensionnement des images d'entrainement et cible (Nx3 et Nx1)
X=[];
Y=[];
[l,c]=size(r2);
N=l*c;
for i=1:N
X(i,1)=r2(i);
X(i,2)=g2(i);
X(i,3)=b2(i);
Z(i)=t(i);
if(Z(i)==0);
Z(i)=-1;
end
end
Y=Z';
size(X)
size(Y)
fprintf('dimensionnement effectué\n');
%Fabrication de la structure 'net' qui portera les paramètres de la machine entraînée
%C'est ici qu'on choisit la fonction kernel ainsi que ses paramètres éventuels
size(X,2)
net = svm(size(X,2), 'rbf', 1);
fprintf('net construit');
%Entrainement proprement dit
net = svmtrain(net, X, Y)
fprintf('machine entrainée\n');
%Classification par la SVM entraînée
%==========================
%Toolbox d'Anton Schwaighofer ( Graz)
%Lecture de l'image à classifier
[r g b]=bmpread('calcaire'); % Mettre le nom de l'image à classifier
réduction des matrices
r1=haarsub(r);
r2=haarsub(r1);
g1=haarsub(g);
g2=haarsub(g1);
b1=haarsub(b);
b2=haarsub(b1);
%changement de format matrice trois dim-->matrice Nx3
X1=[];
[l,c]=size(r2);
N=l*c;
for i=1:N
X1(i,1)=r2(i);
X1(i,2)=g2(i);
X1(i,3)=b2(i);
end
fprintf('dimensionnement effectué\n');
%Classification par SVM
Y1=[];
Y1=svmfwd(net,X1);
fprintf('classification effectuée\n');
% remise en forme pour affichage
% A partir du vecteur, on fabrique l'image binaire
image=[];
for i=0:(c-1)
image(:,i+1)=Y1(i*l+1:(i+1)*l);
end
figure(2)
imshow(image);
%Calssification argile-calcaire
%Fonction « test », effectue une classification pour l’ensemble d’entrainement
[r,g,b]=bmpread('composite.bmp');
[y,u,v]=rgb2yuv(r,g,b);
colormap(gray);
colormap(gray);
x=-u.*v;
colormap(gray);
%réduction de la taille de x
z=haarsub(x);
z2=haarsub(z);
t=(z2>0.01);
figure(1);
imshow(t);
%Réduction de la taille de [r g b]
r1=haarsub(r);
r2=haarsub(r1);
g1=haarsub(g);
g2=haarsub(g1);
b1=haarsub(b);
b2=haarsub(b1);
X=[];
Y=[];
Z=[];
[l,c]=size(r2);
N=l*c;
for i=1:N
X(i,1)=r2(i);
X(i,2)=g2(i);
X(i,3)=b2(i);
Z(i)=t(i);
if(Z(i)==0);
Z(i)=-1;
end
end
Y=Z';
b) Toolbox 2 : entrainement, classification
%Entraînement de la machine à vecteurs supports
%==================================
function [AlphaY, SVs, Bias, Parameters, nSV,
nLabel,X,Y]=entrainement(photo,methode,p1,p2,p3,p4);
% Cette fonction entraîne la machine SVM
%---------------------------------------%Toolbox SVM OSU
%
%
%INPUTS:
%
%image : image d'entrainement de la machine (par ex 'argile.bmp')
%methode : on a le choix entre :
% 1 --> linear
% 2 --> rbf
% 3 --> poly
%parametre: le nombre de parametres possibles varie selon la méthode choisie pour la
classification
% Si linear :
%
C(parametre1): Cout d'une violation de contrainte (default 1)
% Si rbf :
%
Gamma(parametre2): paramètre du radial based kernel qui a la forme (exp(Gamma*|X(:,i)-X(:,j)|^2)). (default 1)
%
C(parametre1): Cout d'une violation de contrainte (default 1)
% Si poly :
%
C(parametre1): Cout d'une violation de contrainte (default 1)
%
Paramètres du polynome (Gamma*<X(:,i),X(:,j)>+Coefficient)^Degree)
%
Degree(parametre2) ---(default: 3)
%
Gamma(parametre3) ---(default: 1)
%
Coeff(parametre4) ---(default: 1)
clear all;
%Fonction "test" pour la fabrication de l'ensemble d'entrainement
[r,g,b]=bmpread(photo);
[y,u,v]=rgb2yuv(r,g,b);
colormap(gray);
colormap(gray);
x=-u.*v;
colormap(gray);
%réduction de la taille de x
z=haarsub(x);
z2=haarsub(z);
t=(z2>0.01);
figure(1);
imshow(t);
%Réduction de la taille de [r g b]
r1=haarsub(r);
r2=haarsub(r1);
g1=haarsub(g);
g2=haarsub(g1);
b1=haarsub(b);
b2=haarsub(b1);
X=[];
Y=[];
Z=[];
[l,c]=size(r2);
N=l*c;
for i=1:N
X(i,1)=r2(i);
X(i,2)=g2(i);
X(i,3)=b2(i);
Z(i)=t(i);
if(Z(i)==0);
Z(i)=-1;
end
end
Y=Z';
Samples=X';
Labels=Y';
%Entraînement SVM linéaire
if(methode==1)
if(nargin <3)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = LinearSVC(Samples, Labels);
end
elseif(nargin==3)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = LinearSVC(Samples, Labels,p1);
end
end
%Entraînement SVM rbf
if(methode==2)
if(nargin==2)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = RbfSVC(Samples, Labels);
end
if(nargin==3)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = RbfSVC(Samples, Labels, 1, p1);
end
if(nargin==4)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = RbfSVC(Samples, Labels, p2,p1);
end
end
%Entraînement SVM poly
if(methode==3)
if(nargin==2)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = PolySVC(Samples, Labels);
end
if(nargin==4)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = PolySVC(Samples, Labels, 3, p1);
end
if(nargin==6)
[AlphaY, SVs, Bias, Parameters, nSV, nLabel] = PolySVC(Samples, Labels, p2,p1, p3,
p4);
end
end
%Classification par la SVM entraînée
%==========================
function [IMAGE,Y3]=classification(image,AlphaY, SVs, Bias, Parameters, nSV,
nLabel,X,Y)
%Classification
%-------------%Cette fonction effectue la classification de l'image entrée
%en paramètre. La classification se fait par la machine à
%vecteurs supports qui a du être entraînée préalablement.
%
%INPUTS
%
%image : l'image à classifier (par ex : 'pierre_brute.bmp')
%les autres entrées sont les sorties de la fonction entrainement.m
%Lecture de l'image à classifier
[r g b]=bmpread(image);
%réduction des matrices
r1=haarsub(r);
r2=haarsub(r1);
g1=haarsub(g);
g2=haarsub(g1);
b1=haarsub(b);
b2=haarsub(b1);
%changement de format matrice trois dim-->matrice Nx3
X1=[];
[l,c]=size(r2);
N=l*c;
for i=1:N
X1(i,1)=r2(i);
X1(i,2)=g2(i);
X1(i,3)=b2(i);
end
X1=X1';
%Classification
[Y1,Y2]= SVMClass(X1, AlphaY, SVs, Bias, Parameters, nSV,nLabel);
%remise en forme de l'image classifiée
Y1=Y1';
Y2=Y2';
IMAGE=zeros(l,c);
Y3=zeros(l,c);
for i=0:(c-1)
IMAGE(:,i+1)=Y1(i*l+1:(i+1)*l);
Y3(:,i+1)=Y2(i*l+1:(i+1)*l);
end
figure(2)
imshow(IMAGE); %image tout ou rien
figure(4);
imshow(Y3); %valeurs de décision
figure(5)
mesh(IMAGE)
%image en 3D
Remarque générale : les fonctions d’entraînement sont utilisées une fois au départ sur l’image
désirée ; ensuite, la classification s’effectue autant de fois que l’on veut sur l’image que l’on
désire classifier. Une fois la machine entraînée, tous les paramètres restent en mémoire, il ne
faut donc pas lancer l’entraînement à chaque classification, c’est d’ailleurs le but d’une
méthode à réseaux de neurones.
2. Résultats obtenus
Schwaighofer).
avec
la
première
toolbox
(
Anton
Une petite remarque avant de découvrir les autres résultats. Voici les photos « pierre_brute2 » et
« pierre_brute » (cette dernière a déjà été traitée dans le rapport) : à première vue, les deux photos
originales sont identiques mis à part le fait que la luminosité n’est pas la même. Vous allez alors
observer que le résultat de la classification est tout à fait différent quelque soit le noyau utilisé (pour
les résultats complets de « pierre_brute », se référer au rapport).
image « pierre_brute » originale et classifiée avec noyau linéaire
image « pierre_brute2 » originale et classifiée avec noyau linéaire
image « pierre_brute2 » originale et classifiée avec noyau polynomial (degré 5)
image « pierre_brute2 » originale et classifiée avec noyau rbf (rayon 1)
Voici un test effectué sur une autre image :
image « pierre+argile » originale et classifiée avec noyau rbf (rayon 1)
3. Résultats obtenus avec la deuxième toolbox ( université d’Ohio).
image « pierre_brute2 » originale et classifiée avec noyau rbf (rayon 1)
image « pierre_brute2 » classifiée avec noyau rbf (rayon 5)
image « pierre_brute2 » classifiée avec noyau polynomial (degré 8)
image « pierre_brute » originale et classifiée avec noyau polynomial (degré 8)