Algoritma Gabor Filter dengan teknik GDA (Generalized Discriminant Analysis) 2

Pengenalan Pola adalah cabang kecerdasan yang menitik-beratkan pada metode pengklasifikasian objek ke dalam klas – klas tertentu untuk menyelesaikan masalah tertentu. Contoh yang dibahas kali ini adalah mengenai penentuan pola wajah baru berdasarkan pola wajah yang sudah ada sebelumnya dengan menggunakan metode Gabor Filter.
Algoritma ini adalah pengembangan lebih lanjut dari Algoritma Gabor Filter, yaitu dengan menambahkan sebuah metode yang dinamakan GDA (General Discriminant Analysis). Metode ini digunakan untuk mereduksi ukuran matriks feature dari ruang berdimensi besar menjadi ruang berdimensi kecil, sehingga dapat meningkatkan performa dan tingkat kecocokan data.

Diasumsikan ada 10 wajah manusia yang sudah diketahui sebelumnya, dengan data sebagai berikut:

Selanjutnya ada pola wajah baru yang ingin diketahui hasilnya
Maka tentukan pola wajah baru ini cocok dengan pola wajah yang mana
Diasumsikan pola wajah yang baru adalah sebagai berikut:

Langkah-langkah penggunaan algoritma ini adalah

* Lakukan inisialisasi variabel yang digunakan dalam perhitungan (poin 1)

1a. Tentukan parameter u,v,m,n untuk digunakan dalam perhitungan gabor filter bank
u adalah jumlah skala (kecil ke besar), dengan nilai default adalah 5
v adalah jumlah orientasi (horizontal, vertikal, diagonal), dengan nilai default adalah 8
m adalah jumlah baris dalam matriks gabor filter 2 dimensi, nilainya harus integer bulat ganjil, dengan nilai default adalah 39
m adalah jumlah kolom dalam matriks gabor filter 2 dimensi, nilainya harus integer bulat ganjil, dengan nilai default adalah 39

gaborFB.u = 5;
gaborFB.v = 8;
gaborFB.m = 39;
gaborFB.n = 39;

Dengan menggunakan parameter default diatas, maka hasil visualisasi untuk array gabor adalah sebagai berikut. Akan terdapat gambar matriks berjumlah 5 * 8 buah, dengan masing-masing gambar memiliki tingkat skala dan orientasi yang berbeda-beda dengan ukuran 39 x 39

1b. Tentukan parameter d1, d2 untuk digunakan dalam perhitungan gabor features
d1 adalah faktor downsampling dari baris matriks
d2 adalah faktor downsampling dari kolom matriks
downsampling adalah proses untuk mengecilkan ukuran matriks dengan hanya mengambil poin-poin penting dari matriks tersebut
semakin besar nilai downsampling, maka semakin kecil pula ukuran matriks yang dihasilkan,
sehingga perhitungan dapat dilakukan lebih cepat, tetapi tingkat kecocokannya akan semakin lemah
Demikian pula sebaliknya
Angka faktor downsampling juga harus merupakan faktor bilangan bulat dari baris atau kolom yang dimaksud,
jika baris matriks berjumlah 10, maka nilai faktor hanya bisa menggunakan angka 2 atau 5, tidak bisa menggunakan angka lainnya

gaborFE.d1 = 4;
gaborFE.d2 = 4;

* Lakukan pembacaan gambar contoh data yang tersedia (poin 2)

2a. Tentukan path folder dari gambar contoh data dan gambar data baru

pathContohData = 'ContohData';
pathDataBaru = 'DataBaru';

2b. Cari semua gambar contoh wajah dan data baru yang tersedia pada masing-masing folder
Kemudian hitung jumlah gambar untuk masing-masing contoh data dan data baru yang tersedia

bmpContohData=dir(sprintf('%s/*.bmp',pathContohData));    
bmpDataBaru=dir(sprintf('%s/*.bmp',pathDataBaru));
jumlahContohData=size(bmpContohData,1);
jumlahDataBaru=size(bmpDataBaru,1);

2c. Tentukan tinggi (H) dan lebar (W) dari masing-masing gambar
Kemudian buat matriks kosong berukuran H*W sebanyak jumlah gambar contoh data

str=strcat(pathContohData,'\',bmpContohData(1).name);    
im=imread(str);
H=size(im,1);
W=size(im,2);
daftarGambar=zeros(H,W,jumlahContohData);

2d. Tampilkan data contoh gambar yang tersedia
dan masukkan ke dalam matriks gambar

for i=1:jumlahContohData
    str=strcat(pathContohData,'\',bmpContohData(i).name);    
    daftarGambar(:,:,i)=imread(str);
    
    subplot(5,jumlahContohData,i)
    imshow(str)
    if i==1
        title('Contoh gambar wajah: ','Position',[105,0])
    end
end

3. Lakukan proses perhitungan dengan metode Gabor Filter
Penjelasan tentang fungsi ini akan dijelaskan pada perhitungan dibawah ini (poin 3a – 3e)

[GDAContohData, GDADataBaru] = GaborFilter(gaborFB, gaborFE, ...
    pathDataBaru, bmpDataBaru, jumlahContohData, jumlahDataBaru, daftarGambar);

Memasuki perhitungan pada fungsi GaborFilter

3a. Lakukan perhitungan gabor filter bank untuk mendapatkan array gabor
array gabor akan dihasilkan akan berukuan u x v, dengan masing-masing sel akan berisikan matriks berukuran m x n
contoh gambar gabor array dapat dilihat pada gambar diatas
Penjelasan lebih detail tentang fungsi ini dapat dilihat pada penjelasan skrip dibawah ini

gaborArray = gaborFilterBank(gaborFB.u, gaborFB.v, gaborFB.m, gaborFB.n);

* Gunakan fungsi ini untuk menghitung array gabor

function gaborArray = gaborFilterBank(u,v,m,n)
if (nargin ~= 4)
    error('Jumlah paramter harus ada 4, yaitu jumlah skala, jumlah orientasi, dan ukuran 2 dimensi dari filter')
end

gaborArray = cell(u,v);
fmax = 0.25;
gama = sqrt(2);
eta = sqrt(2);

for i = 1:u    
    fu = fmax/((sqrt(2))^(i-1));
    alpha = fu/gama;
    beta = fu/eta;
    
    for j = 1:v
        tetav = ((j-1)/v)*pi;
        gFilter = zeros(m,n);
        
        for x = 1:m
            for y = 1:n
                xprime = (x-((m+1)/2))*cos(tetav)+(y-((n+1)/2))*sin(tetav);
                yprime = -(x-((m+1)/2))*sin(tetav)+(y-((n+1)/2))*cos(tetav);
                gFilter(x,y) = (fu^2/(pi*gama*eta))*exp(-((alpha^2)*(xprime^2)+(beta^2)*(yprime^2)))*exp(1i*2*pi*fu*xprime);
            end
        end
        
        gaborArray{i,j} = gFilter;        
    end
end

3b. Lakukan perhitungan pada masing-masing contoh data
Lakukan perhitungan ekstraksi gabor feature untuk mendapatkan vektor feature dari contoh data tersebut
Penjelasan lebih detail tentang fungsi ini dapat dilihat pada penjelasan skrip dibawah ini (poin 3b1 – 3b3)

matriksFeatureContohData = [];
label = [];
for i=1:jumlahContohData
    matriksFeatureContohData(:, i) = gaborFeatures(daftarGambar(:,:,i), gaborArray, gaborFE.d1, gaborFE.d2);
    label = [label i];
end

Memasuki perhitungan pada fungsi gaborFeatures

3b1. Lakukan konversi gambar ke dalam bentuk grayscale apabila data gambar belum dalam bentuk grayscale

if size(img,3) == 3
    warning('Data gambar ini akan dikonversi menjadi bentuk grayscale!')
    img = rgb2gray(img);
end

img = double(img);

3b2. Lakukan proses filter pada data gambar menggunakan masing-masing matriks dalam array gabor

[u,v] = size(gaborArray);
gaborResult = cell(u,v);
for i = 1:u
    for j = 1:v
        gaborResult{i,j} = imfilter(img, gaborArray{i,j});
    end
end

* Lakukan proses ekstraksi vektor feature dari data gambar (poin 3b3)

3b3. Lakukan perhitungan pada masing-masing hasil filter diatas (poin 3b3a – 3b3c)

for i = 1:u
    for j = 1:v
	. . .

3b3a. Lakukan proses downsampling untuk mereduksi ukuran hasil filter gabor

gaborAbs = abs(gaborResult{i,j});
gaborAbs = downsample(gaborAbs,d1);
gaborAbs = downsample(gaborAbs.',d2);
gaborAbs = gaborAbs(:);

3b3b. Lakukan normalisasi menggunakan rata-rata dan standar deviasi dari hasil perhitungan sebelumnya
Proses ini dapat dilewati apabila normalisasi tidak dapat diterapkan pada hasil perhitungan gabor

gaborAbs = (gaborAbs-mean(gaborAbs))/std(gaborAbs,1);

3b3c. Masukkan hasil perhitungan ke dalam matriks feature

featureVector =  [featureVector; gaborAbs];

3c. Lakukan perhitungan dengan metode GDA (General Discriminant Analysis) untuk matriks feature contoh data
Metode ini digunakan untuk mereduksi ukuran matriks feature dari ruang berdimensi besar menjadi ruang berdimensi kecil,
dengan cara memaksimalkan rasio antara matriks scatter between dan matriks scatter within
Metode ini terbukti dapat meningkatkan performa dan tingkat kecocokan data
Penjelasan lebih detail tentang fungsi ini dapat dilihat pada penjelasan skrip dibawah ini (poin 3c1 – 3c14)

GDAContohData = gda(matriksFeatureContohData,matriksFeatureContohData,label);

Memasuki perhitungan pada fungsi gda

3c1. Lakukan pemisahan sample dari masing-masing obyek / class ke dalam array

c = max(label);
dataCell = cell(1,c);
jumlahSample = zeros(1,c);
for i = 1:c
    idx = find(label==i);
    jumlahSample(i) = length(idx);
    dataCell{1,i} = contohData(:,idx);
end
clear trainLabel

3c2. Lakukan pembuatan kernel spesifik dari masing-masing obyek contoh data

kTrainCell = cell(c,c);
for p = 1:c
    for q = 1:c
        Kpq = zeros(jumlahSample(p),jumlahSample(q));
        classP = dataCell{1,p};
        classQ = dataCell{1,q};
        for i = 1:jumlahSample(p)
            for j = 1:jumlahSample(q)
                Kpq(i,j) = kernel(classP(:,i),classQ(:,j),options);
            end
        end
        kTrainCell{p,q} = Kpq;
    end
end
kTrain = cell2mat(kTrainCell);
clear kTrainCell 

3c3. Lakukan normalisasi pada data sehingga data tersebut memiliki zero mean

[~,n] = size(contohData);
One = (1/n) * ones(n,n);
zeroMeanKtrain = kTrain - One*kTrain - kTrain*One + One*kTrain*One;
clear trainData

3c4. Lakukan perhitungan matriks blok diagonal W

wTrainCell=cell(c,c);
for p = 1:c
    for q = 1:c
        if p == q
            wTrainCell{p,q}=(1/jumlahSample(p))*ones(jumlahSample(p),jumlahSample(q));
        else
            wTrainCell{p,q}=zeros(jumlahSample(p),jumlahSample(q));
        end
    end
end
wTrain = cell2mat(wTrainCell);
clear wTrainCell

3c5. Lakukan dekomposisi pada data zero mean menggunakan teknik dekomposisi eigen

[P, gamma] = eig(zeroMeanKtrain);
diagonal = diag(gamma);
[~,idxTerurut] = sort(diagonal,'descend');
gamma = diagonal(idxTerurut);
P = P(:,idxTerurut);

3c6. Hilangkan semua eigenvalue yang memiliki nilai cukup rendah

maksEigenValue = max(abs(gamma));
idxZeroEigen = find((abs(gamma)/maksEigenValue)<1e-6);
gamma(idxZeroEigen) = [];
P(:,idxZeroEigen) = [];

3c7. Lakukan normalisasi pada eigenvector yang telah ditemukan

jumlahEigen = length(gamma);
for i = 1:jumlahEigen
    P(:,i) = P(:,i)/norm(P(:,i));
end

3c8. Hitung nilai eigenvector (beta) dan eigenvalue (lambda)

BB = (P')*(wTrain)*(P);
[beta, lambda] = eig(BB);
diagonal = diag(lambda);
[~, idxTerurut] = sort(diagonal,'descend');
lambda = diagonal(idxTerurut);
beta = beta(:,idxTerurut);
clear BB wTrain

3c9. Hilangkan semua eigenvalue yang memiliki nilai cukup rendah

maksEigenValue = max(abs(lambda));
idxZeroEigen = find((abs(lambda)/maksEigenValue)<1e-6);
lambda(idxZeroEigen) = [];
beta(:,idxZeroEigen) = [];

3c10. Hitung nilai alpha dan lakukan normalisasi pada alpha

gamma = diag(gamma);
alpha = (P/gamma)*beta;
jumlahEigen = length(lambda);
for i = 1:jumlahEigen
    scalar = sqrt((alpha(:,i).')*(zeroMeanKtrain)*(alpha(:,i)));
    alpha(:,i)=alpha(:,i)/scalar;
end
clear zeroMeanKtrain P gamma beta

3c11. Lakukan proses reduksi dimensi menjadi parameter jumlah dimensi
Jika paramter jumlah dimensi tidak didefinisikan sebelumnya, maka nilainya akan digantikan oleh jumlah eigenvector

if (~exist('subDim','var'))
   jumlahDimensi = jumlahEigen;
elseif (jumlahDimensi > jumlahEigen)
   warning(['Target dimensionality reduced to ' num2str(jumlahEigen) '.']);
end

w = alpha(:,1:jumlahDimensi);

3c12. Lakukan pembuatan kernel spesifik untuk semua obyek contoh data

[~,jumlahPrime] = size(data);
kDataCell = cell(c,1);
for p = 1:c
    Kp = zeros(jumlahSample(p),jumlahPrime);
    classP = dataCell{1,p};
    for i = 1:jumlahSample(p)
        for j = 1:jumlahPrime
            Kp(i,j) = kernel(classP(:,i),data(:,j),options);
        end
    end
    kDataCell{p,1} = Kp;
end
kData = cell2mat(kDataCell);
clear data dataCell kDataCell

3c13. Lakukan normalisasi pada data sehingga data tersebut memiliki zero mean

Oneprime = (1/n)*ones(n,jumlahPrime);
zeroMeanKdata = kData - kTrain*Oneprime - One*kData + One*kTrain*Oneprime;
clear kTrain kData

3c14. Lakukan proyeksi semua data poin secara non linier ke dalam ruang berdimensi kecil yang baru

mappedData = (w.') * (zeroMeanKdata);

3d. Lakukan perhitungan pada masing-masing data baru
Lakukan perhitungan ekstraksi gabor feature untuk mendapatkan vektor feature dari data baru tersebut
Penjelasan tentang fungsi ini sudah dijelaskan pada perhitungan sebelumnya

matriksFeatureDataBaru = [];
for i=1:jumlahDataBaru
    str=strcat(pathDataBaru,'\',bmpDataBaru(i).name);
    dataBaru = imread(str);    
    
    matriksFeatureDataBaru(:, i) = gaborFeatures(dataBaru(:,:,1), gaborArray, gaborFE.d1, gaborFE.d2);
end

3e. Lakukan perhitungan dengan metode GDA (General Discriminant Analysis) untuk matriks feature data baru
Penjelasan tentang fungsi ini sudah dijelaskan pada perhitungan sebelumnya

GDADataBaru  =  gda(matriksFeatureDataBaru,matriksFeatureContohData,label);

4. Lakukan perhitungan pada masing-masing data baru (poin 4a - 4c)

for i=1:jumlahDataBaru
. . .

4a. Hitung jarak Euclidean antara proyeksi GDA data baru dengan proyeksi GDA dari semua contoh data

jarakEuclidean = [];
for j=1:jumlahContohData
	tmp = (norm(GDADataBaru(:,i) - GDAContohData(:,j)))^2;
	jarakEuclidean = [jarakEuclidean tmp];
end

4b. Ambil jarak paling minimal sebagai jawaban gambar contoh data yang paling sesuai dengan gambar data baru

[~, idxMinimal] = min(jarakEuclidean);

4c. Tampilkan hasil akhir pada layar

subplot(5,jumlahContohData,sp(i))
imshow(str)
title(strcat('Data ',int2str(i)),'Position',[25,0])

subplot(5,jumlahContohData,sp(i)+1)
imshow(uint8(daftarGambar(:,:,idxMinimal)))
title('Dikenali sebagai','Position',[75,0])

Hasil akhir adalah: (klik untuk perbesar gambar)

Contoh modul / source code menggunakan Matlab dapat didownload disini:

Jika membutuhkan jasa kami dalam pembuatan program, keterangan selanjutnya dapat dilihat di Fasilitas dan Harga
Jika ada yang kurang paham dengan langkah-langkah algoritma diatas, silahkan berikan komentar Anda.
Selamat mencoba.