Istilah2 dan Kode2 Matlab

DETEKSI TEPI:

Suatu obyek yang berada dalam bidang citra dan tidak bersinggungan dengan batas bidang citra, berarti obyek tersebut dikelilingi daerah yang bukan obyek yaitu latar belakang. Pertemuan antara bagian obyek dan bagian latar belakang disebut tepi obyek.

 Demikian juga bila dua buah atau lebih obyek saling tumpang tindih, bila intensitas mereka tidak sama, akan meninggalkan jejak tepi sehingga diketahui obyek yang satu berada di depan obyek yang lain atau sebaliknya. Hal ini penting untuk mengembalikan atau merekonstruksi bentuk yang seharusnya dari obyek yang berada di belakang obyek lainnya, atau memisahkan obyek yang tumpang tindih sehingga mereka dapat dianalisis secara individu.

 Dengan demikian tepi suatu obyek juga berguna untuk memisahkan obyek-obyek yang saling bersinggungan sehingga mereka tidak dianggap sebagai satu obyek yang besar dan tetap dapat dilacak atau dianalisis secara individu.

Deteksi tepi atau edge detection digunakan untuk menentukan lokasi titik-titik yang merupakan tepi obyek. Secara umum, tepi suatu obyek dalam citra dinyatakan sebagai titik yang nilai keabuannya berbeda cukup besar dengan titik yang ada di sebelahnya. Banyak bentuk yang dipakai dalam operasi ini, misalnya operator Robert, Prewitt, Sobel, Canny, Laplacian, dan Laplacian of Gaussian


Coding :

I = imread(‘lp2maray.jpg’);
gray=rgb2gray(I);
BW1 = edge(gray,’prewitt’);
BW2 = edge(gray,’canny’);
BW3 = edge(gray,’sobel’);
BW4 = edge(gray,’roberts’);
imshow(BW1);
figure, imshow(BW2);
figure, imshow(BW3);
figure, imshow(BW4);


RECONSTRUCTOR:
gambar = imread('naruto.jpg');
[X,map] = rgb2ind(gambar, 128);
I = ind2gray(X,map);
thresh=graythresh(gray);
imbw=im2bw(gray,thresh);
Ifill = imfill(imbw,'holes');
figure, imshow(imbw);figure, imshow(Ifill)



FILTERING:
gambar=imread('naruto.jpg');
gaussianFilter = fspecial('gaussian', [12, 12], 5)
hasil = imfilter(gambar, gaussianFilter, 'symmetric', 'conv');
subplot(1,2,1), image(gambar);
subplot(1,2,2), image(hasil), title('Blurred Taz, blur matrix size 12');

HISTOGRAM:
gambar=imread('naruto.jpg');
red=gambar(:,:,1);
green=gambar(:,:,2);
blue=gambar(:,:,3);
merahgray2=0.3*red+0.5*green+0.2*blue ;
imhist(red)
imhist(green)
imhist(blue)
imhist(gray)

Macam-Macam Noise Matlab

Ada banyak jenis noise yang dapat mempengaruhi kualitas citra, diantaranya adalah salt and pepper, gaussian, speckle, localvar dan poisson. Efek masing-masing noise tentunya berbeda-beda. Ada yang efeknya sangat mempengaruhi tampilan citra, tapi ada juga yang tidak begitu berpengaruh terhadap citra.

Salt & Peper

Seperti namanya noise jenis ini terlihat seperti salt and pepper. Pada citra akan nampak seperti titik-titik. Untuk citra RGB titik-titik muncul dalam tiga warna yakni merah (red), hijau (green) dan biru (blue), sedangkan pada citra GRAY noise akan muncul dalam dua warna yakni hitam (black) dan putih (white). Noise ini memberikan efek ”on dan off” pada pixel. Pada MatLab kita dapat mengatur ”konstanta” noise. Konstanta berupa angka numerik non negatif dengan range 0 sampai dengan 1. Makin besar konstantanya citra akan semakin kabur, sebaliknya makin kecil konstantanya efek pada citra makin tidak terlihat. Nilai default untuk konstanta noise adalah 0.05.

Gaussian
Disebut juga Gaussian White Noise. Untuk menambahkan noise ini pada MatLab memerlukan input tambahan berupa rata-rata dan variasi. Rata-rata dan variasi merupakan suatu konstanta real. Nilainya bisa positif maupun negative. Makin besar rata-rata dan variasinya maka citra akan semakin kabur, sebaliknya makin kecil konstantanya efek pada citra makin tidak terlihat. Nilai default adalah 0 untuk mean dan 0.01 untuk variance. Disebut white noise karena pada saat nilai rata-rata dan variasinya besar maka citra seolah-olah hanya terlihat seperti citra putih saja.

Poisson
Poisson noise bukan merupakan noise buatan. Poisson merupakan noise yang ditambahkan langsung pada citra tanpa kita menambahkan parameter apapun, sehingga efeknya pada citra pun tetap, berbeda dengan tipe noise yang sudah dijelaskan sebelumnya. Pada MatLab, jika matrik citra adalah double precision, maka nilai piksel inputnya dianggap sebagai mean dari distribusi Poisson dengan skala 10^12. Sebagai contoh jika piksel inputnya mempunyai nilai 5.5 10^-12, maka piksel output akan dibangkitkan dari distribusi Poisson dengan mean 5.5 di kembalikan lagi ke skala 10^12. Jika matrik citra adalah single precision, maka factor skalanya menggunakan 10^6. Jika matrik citra adalah uint8 atau uint16, maka nilai input piksel digunakan langsung tanpa factor skala. Sebagai contoh jika input piksel uint8 mempunyai nilai 10, maka piksel output akan dibangkitkan dari distribusi Poisson dengan mean 10.

Speckle
Speckle merupakan noise ganda. Noise ini ditambahkan pada citra menggunakan persamaan J=I+n*I, dimana n terdistribusi random seragam dengan mean 0 dan variance V. V adalah konstanta non negative yang besarnya dapat berubah-ubah. Default nilai untuk V adalah 0.04. Makin besar nilai V maka citra akan semakiin kabur.

Localvar
Pada MatLab kita harus mengunakan dua parameter untuk menambahkan noise ini pada citra. Dua parameter tersebut berupa vector yang ukurannya sama, dan grafik kedua parameter tersebut menggambarkan relasi fungsional antara varians noise dan intensitas citra. Vektor intensitas citra harus bernilai antara 0 dan 1 (normal). Localvar merupakan Gaussian noise dengan mean 0, dengan variance noise adalah fungsi dari intensitas citra yang nilainya berada dalam matrik citra. Vektor intensitas citra tidak boleh bernilai sama karena citra akan nampak sebagai layar putih (Gaussian White Noise).

Macam-macam Filter Image/Citra pada Matlab

Filter pada dasarnya adalah sebuah metode untuk meredamkan atau menghilangkan noise pada citra digital atau image. Jenis filter bermacam-macam dan fungsi serta efeknya juga berbeda-beda pula. Filter citra dibagi menjadi dua, yaitu filter linear dan filter non-linear. Filter spasial linear adalah filter yang bekerja dengan cara korelasi atau konvolusi. Filter spasial non-linier atau biasanya disebut juga dengan filter statistik berdasar urutan adalah filter yang respon nya didasarkan pada urutan atau rangking piksel yang ada dalam citra yang dicakup oleh area filter dengan menggantikan nilai dari piksel yang berada di tengah digantikan dengan nila hasil pengurutan atau perangkingan tersebut. Filter non-linear memiliki lebih banyak keunggulan dibandingkan dengan filter linear pada ukuran jendela filter yang sama.

Macam-macam filter spasial linear antara lain :

1. Filter Rata-rata

Penghalusan dengan filter rata-rata adalah proses filtering citra f(x,y) dengan filter rata-rata g(x,y) untuk berbagai ukuran filter, dari ukuran 3×3, 5×5, 7×7, 9×9, dan seterusnya.

2. Filter Gaussian

Penghalusan dengan filter gaussian tekniknya sama dengan filter rata-rata, yaitu filtering citra f(x,y) dengan filter gaussian g(x,y) untuk berbagai ukuran filter, dari ukuran 3×3, 5×5, 7×7, 9×9, dan seterusnya.

Macam-macam filter spasial non-linear antara lain :

1. Filter Median

Penghalusan dengan filter median adalah dengan menggantikan nilai tengah dari piksel yang di cakup oleh area filter dengan sebuah nilai tengah (median) setelah diurutkan terlebih dahulu dari yang terkecil ke yang terbesar.

2. Filter Maksimum

Penghalusan dengan filter median adalah menggantikan piksel dengan nilai tertinggi dari suatu deret yang terbentuk dari matriks yang sesuai dengan ukuran dari jendela filter.

3. Filter Minimum

Penghalusan dengan filter median adalah menggantikan piksel dengan nilai terendah dari suatu deret yang terbentuk dari matriks yang sesuai dengan ukuran dari jendela filter.

Contoh JST + Normalisasi code nya

function [gab] = Normalisasi( G)

u=66;

v=100;

max=u*v;

I=imresize(G,[u v]);

M=NR(I);

filter_khusus=fspecial('unsharp');

Q=imfilter(M,filter_khusus,'replicate');

red=Q(:,:,1);

A1= edge(red,'canny');

A=reshape(A1,1,max);

green=Q(:,:,2);

B1= edge(green,'canny');

B=reshape(B1,1,max);

blue=Q(:,:,3);

C1= edge(blue,'canny');

C=reshape(C1,1,max);

gab=[A,B,C];

end

function [ K ] = NR(I) %Noise Remover

%M = wiener2(V);

%N = medfilt2(J);

%O = imnoise(J,'gaussian');%pilih1

w=size(I,1);

h=size(I,2);

R=I(:,:,1);

G=I(:,:,2);

B=I(:,:,3);

JR=medfilt2(R);

JG=medfilt2(G);

JB=medfilt2(B);

        

J=[];

for i=1:w

    for j=1:h

        J(i,j,1)=JR(i,j);

        J(i,j,2)=JG(i,j);

        J(i,j,3)=JB(i,j);

    end

end    

K=uint8(J);

end

Perintah dan Pengujian JST 

I=imread('matang\1.jpg');

    U=Normalisasi(I);

    Data(1,:)=U;

I=imread('matang\2.jpg');

    U=Normalisasi(I);

    Data(2,:)=U;

I=imread('matang\3.jpg');

    U=Normalisasi(I);

    Data(3,:)=U;

I=imread('matang\4.jpg');

    U=Normalisasi(I);

    Data(4,:)=U;    

I=imread('matang\5.jpg');

    U=Normalisasi(I);

    Data(5,:)=U;

I=imread('matang\6.jpg');

    U=Normalisasi(I);

    Data(6,:)=U;

 I=imread('matang\7.jpg');

    U=Normalisasi(I);

    Data(7,:)=U;

 I=imread('matang\8.jpg');

    U=Normalisasi(I);

    Data(8,:)=U;   

 I=imread('matang\9.jpg');

    U=Normalisasi(I);

    Data(9,:)=U;  

 I=imread('matang\10.jpg');

    U=Normalisasi(I);

    Data(10,:)=U;

 I=imread('mentah\1.JPG');

    U=Normalisasi(I);

    Data(11,:)=U;

 I=imread('mentah\2.JPG');

    U=Normalisasi(I);

    Data(12,:)=U;

 I=imread('mentah\3.JPG');

    U=Normalisasi(I);

    Data(13,:)=U;

 I=imread('mentah\4.JPG');

    U=Normalisasi(I);

    Data(14,:)=U;   

 I=imread('mentah\5.JPG');

    U=Normalisasi(I);

    Data(15,:)=U;   

 I=imread('mentah\6.JPG');

    U=Normalisasi(I);

    Data(16,:)=U;

 I=imread('mentah\7.JPG');

    U=Normalisasi(I);

    Data(17,:)=U;   

 I=imread('mentah\8.JPG');

    U=Normalisasi(I);

    Data(18,:)=U;   

 I=imread('mentah\9.JPG');

    U=Normalisasi(I);

    Data(19,:)=U;

 I=imread('mentah\10.JPG');

    U=Normalisasi(I);

    Data(20,:)=U;   

 I=imread('ranum\1.jpg');

    U=Normalisasi(I);

    Data(21,:)=U;

 I=imread('ranum\2.jpg');

    U=Normalisasi(I);

    Data(22,:)=U;   

 I=imread('ranum\3.jpg');

    U=Normalisasi(I);

    Data(23,:)=U;   

 I=imread('ranum\4.jpg');

    U=Normalisasi(I);

    Data(24,:)=U;   

 I=imread('ranum\5.jpg');

    U=Normalisasi(I);

    Data(25,:)=U;

 I=imread('ranum\6.jpg');

    U=Normalisasi(I);

    Data(26,:)=U;   

 I=imread('ranum\7.jpg');

    U=Normalisasi(I);

    Data(27,:)=U;

 I=imread('ranum\8.jpg');

    U=Normalisasi(I);

    Data(28,:)=U;   

 I=imread('ranum\9.jpg');

    U=Normalisasi(I);

    Data(29,:)=U;

 I=imread('ranum\10.jpg');

    U=Normalisasi(I);

    Data(30,:)=U;   

    

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%    

Training=Data;

jummatang=10;    

jummentah=10;

jumranum=10;

jumdata=jummatang+jummentah+jumranum;    

t=linspace(0,1,jumdata)

Target=t;

save myTraining.mat Training;

save myTarget.mat Target;

%=====================================================================

Pengujian

load myTraining.mat;

load myTarget.mat;

data_latih=Training';

kelas_latih=Target;

    net = newff(minmax (double(data_latih)), [15,7,1], {'logsig','logsig','logsig'},'traincgf');

    net.performFcn='mse';%sse

    net.trainParam.mc=0.95;

    net.trainParam.epochs = 1000;

    net.trainParam.goal = 0.1;

    net.trainParam.lr = 0.001;

    net.trainParam.show = 100;

    [net_keluaran,tr,Y,E]=train(net,double(data_latih),double(kelas_latih));

    jumlah_iterasi=tr.num_epochs;

    nilai_keluaran=Y;

    nilai_error=E;

    error=0.5*sum(nilai_error.^2)

    %%PENGUJIAN

I=imread('ranum\3.jpg');

    dataUji=Normalisasi(I);

    Q=dataUji';

    kelas_uji=sim(net_keluaran,double(Q))

    

    c1=Target(1,10);

    c2=Target(1,20);

    c3=Target(1,30);

    

    hasil='Ranum';

    if kelas_uji <=c1

        hasil='Matang';

    elseif kelas_uji <=c2

        hasil='Mentah';

    end    

    

    disp(hasil);

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    

LVQ melakukan pembelajaran pada lapisan kompetitif yang terawasi. 
Lapisan kompetitif akan secara otomatis belajar untuk mengklasifikasikan vector-vector input. 

Kelas-kelas yang didapat sebagai hasil dari lapisan kompetitif ini hanya tergantung pada jarak antara vector-vector input. Jika vector input mendekati sama maka lapisan kompetitif akan mengklasifikasikan kedua vector input tersebut kedalam kelas yang sama.


LVQ (Learning Vector Quantization) juga merupakan metode dalam Jaringan Syaraf Tiruan untuk melakukan pembelajaran terhadap layer yang supervised. 

Metode klasifikasi pola dengan setiap unit-keluaran mewakili satu kelas tertentu atau satu kategori tertentu. Digunakan vektor acuan (Vector Reference/Codebook). Vektor bobot dari satu unit keluaran yang menjadi acuan bagi kelas/kategori yang diwakili oleh keluaran tersebut. Pendekatan yang dilakukan adalah dengan mengelompokkan vektor input berdasarkan kedekatan jarak vector input terhadap bobot (metode kuadrat jarak Euclidean minimum).

Arsitektur di atas merupakan contoh struktur jaringan LVQ yang memiliki 4 input layer dengan 2 unit neuron pada output layer. W1 dan W2 merupakan bobot yang menghubungkan input layer ke output layer. Setiap fungsi aktivasi F melakukan pemetaan setiap y_In ke klasifikasi y1 atau y2. 

Pada F1, jika |x-w1|<|x-w2| maka y_In1 dipetakan ke y1=1 dan dipetakan ke y1=0 jika sebaliknya. Kondisi ini berlaku juga pada F2, dengan kondisi yang sesuai.



Metode LVQ (Learning Vector Quantization) Untuk Pengenalan Pola

Posted in Umum  February 18, 2016  hwsmartsolution  2
LVQ (Learning Vector Quantization) merupakan metode dalam Jaringan Syaraf Tiruan untuk melakukan pembelajaran terhadap layer yang supervised. Metode klasifikasi pola dengan setiap unit-keluaran mewakili satu kelas tertentu atau satu kategori tertentu. Digunakan vektor acuan (Vector Reference/Codebook). Vektor bobot dari satu unit keluaran yang menjadi acuan bagi kelas/kategori yang diwakili oleh keluaran tersebut. Pendekatan yang dilakukan adalah dengan mengelompokkan vektor input berdasarkan kedekatan jarak vector input terhadap bobot (metode kuadrat jarak Euclidean minimum).

Arsitektur LVQ :

Arsitektur LVQ

Arsitektur di atas merupakan contoh struktur jaringan LVQ yang memiliki 4 input layer dengan 2 unit neuron pada output layer. W1 dan W2 merupakan bobot yang menghubungkan input layer ke output layer. Setiap fungsi aktivasi F melakukan pemetaan setiap y_In ke klasifikasi y1 atau y2. Pada F1, jika |x-w1|<|x-w2| maka y_In1 dipetakan ke y1=1 dan dipetakan ke y1=0 jika sebaliknya. Kondisi ini berlaku juga pada F2, dengan kondisi yang sesuai.

Algoritma :

Langkah 0: Inisialisasi /Inisialisai Vektor-Vektor Acuan dan Inisialisai Laju Pembelajaran alfa=0
Langkah 1: Jika kondisi stop salah, lakukan langkah 2-6
Langkah 2: Untuk setiap training vector, lakukan langkah 3-4
Langkah 3: Dapatkan nilai j sehingga ||x-wj|| bernilai minimum
Langkah 4: Update nilai bobot wj

Jika T = Cj
Wj(baru) = wj(lama) + α(x-wj(lama))

Jika T ≠ Cj
Wj(baru) = wj(lama) – α(x-wj(lama))

Langkah 5: Update nilai learning rate

Langkah 6: Uji kondisi stop
      Uji kondisi stop ini dapat dilakukan berdasarkan jumlah iterasi tertentu (mulai dari langkah 1) atau setelah laju pembelajaran yang telah mencapai harga yang sangat kecil.

Dimana:
      X = training vector (x1 ,….,xi,… ,xn)

      T = kategori training vector yang benar untuk pelatihan

      Wj = vector bobot untuk unit keluaran ke-j (w1j,….,wij,…..,win)

      Cj = kategori  atau kelas yang diwakili oleh nilai unit keluaran  ke-j(hasil training)


      ||x-wj|| = Euclidian  distances antara vektor masukkan dan vektor bobot dari unit keluaran ke-j.

Reff Doc

++++++++++++++++
Pengujian Dasar + Pembuktian (Kasus 2 Row / Ya atau Tidak / 1 atau 0)

P = [-3 -2 -2  0  0  0  0 +2 +2 +3; 0 +1 -1 +2 +1 -1 -2 +1 -1  0];
Tc = [1 1 1 2 2 2 2 1 1 1];
T = ind2vec(Tc);
net = newlvq(P,4,[.6 .4]);
net = train(net,P,T);
Y = sim(net,P)
Yc = vec2ind(Y)
E = Tc-Yc

MSE = mse(E)

Y =

     1     1     1     0     0     0     0     1     1     1
     0     0     0     1     1     1     1     0     0     0


Yc =

     1     1     1     2     2     2     2     1     1     1


E =

     0     0     0     0     0     0     0     0     0     0


MSE =


     0

Implementasi Multi Row(Lebih dari 2 Output)



load datalatih
load datatarget     
datatraining=datalatih';

T=[1 1 1 2 2 2];
A=[1:3];
B=[4:6];
C=[7:9];
D=[10:12];
E=[13:15];
F=[16:18];
G=[19:21];
H=[22:24];
I=[25:27];
J=[28:30];

netAB=getNet(datatraining,A,B,T);save netAB.mat netAB;
netAC=getNet(datatraining,A,C,T);save netAC.mat netAC;
netAD=getNet(datatraining,A,D,T);save netAD.mat netAD;
netAE=getNet(datatraining,A,E,T);save netAE.mat netAE;
netAF=getNet(datatraining,A,F,T);save netAF.mat netAF;
netAG=getNet(datatraining,A,G,T);save netAG.mat netAG;
netAH=getNet(datatraining,A,H,T);save netAH.mat netAH;
netAI=getNet(datatraining,A,I,T);save netAI.mat netAI;
netAJ=getNet(datatraining,A,J,T);save netAJ.mat netAJ;
netBC=getNet(datatraining,B,C,T);save netBC.mat netBC;
netBD=getNet(datatraining,B,D,T);save netBD.mat netBD;
netBE=getNet(datatraining,B,E,T);save netBE.mat netBE;
netBF=getNet(datatraining,B,F,T);save netBF.mat netBF;
netBG=getNet(datatraining,B,G,T);save netBG.mat netBG;
netBH=getNet(datatraining,B,H,T);save netBH.mat netBH;
netBI=getNet(datatraining,B,I,T);save netBI.mat netBI;
netBJ=getNet(datatraining,B,J,T);save netBJ.mat netBJ;
netCD=getNet(datatraining,C,D,T);save netCD.mat netCD;
netCE=getNet(datatraining,C,E,T);save netCE.mat netCE;
netCF=getNet(datatraining,C,F,T);save netCF.mat netCF;
netCG=getNet(datatraining,C,G,T);save netCG.mat netCG;
netCH=getNet(datatraining,C,H,T);save netCH.mat netCH;
netCI=getNet(datatraining,C,I,T);save netCI.mat netCI;
netCJ=getNet(datatraining,C,J,T);save netCJ.mat netCJ;
netDE=getNet(datatraining,D,E,T);save netDE.mat netDE;
netDF=getNet(datatraining,D,F,T);save netDF.mat netDF;
netDG=getNet(datatraining,D,G,T);save netDG.mat netDG;
netDH=getNet(datatraining,D,H,T);save netDH.mat netDH;
netDI=getNet(datatraining,D,I,T);save netDI.mat netDI;
netDJ=getNet(datatraining,D,J,T);save netDJ.mat netDJ;
netEF=getNet(datatraining,E,F,T);save netEF.mat netEF;
netEG=getNet(datatraining,E,G,T);save netEG.mat netEG;
netEH=getNet(datatraining,E,H,T);save netEH.mat netEH;
netEI=getNet(datatraining,E,I,T);save netEI.mat netEI;
netEJ=getNet(datatraining,E,J,T);save netEJ.mat netEJ;
netFG=getNet(datatraining,F,G,T);save netFG.mat netFG;
netFH=getNet(datatraining,F,H,T);save netFH.mat netFH;
netFI=getNet(datatraining,F,I,T);save netFI.mat netFI;
netFJ=getNet(datatraining,F,J,T);save netFJ.mat netFJ;
netGH=getNet(datatraining,G,H,T);save netGH.mat netGH;
netGI=getNet(datatraining,G,I,T);save netGI.mat netGI;
netGJ=getNet(datatraining,G,J,T);save netGJ.mat netGJ;
netHI=getNet(datatraining,H,I,T);save netHI.mat netHI;
netHJ=getNet(datatraining,H,J,T);save netHJ.mat netHJ;
netIJ=getNet(datatraining,I,J,T);save netIJ.mat netIJ;

TOT=zeros(1,10);
Uji=datatraining(:,5);

gA=0;
gB=0;
gC=0;
gD=0;
gE=0;
gF=0;
gG=0;
gH=0;
gI=0;
gJ=0;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Y = sim(netAB,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gB=gB+1; 
end    

Y = sim(netAC,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gC=gC+1; 
end   

Y = sim(netAD,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gD=gD+1; 
end    

Y = sim(netAE,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gE=gE+1; 
end   

Y = sim(netAF,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gF=gF+1; 
end   

Y = sim(netAG,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gG=gG+1; 
end   

Y = sim(netAH,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netAI,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netAJ,Uji);
g= vec2ind(Y);
if g==1
    gA=gA+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netBC,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gC=gC+1; 
end   

Y = sim(netBD,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gD=gD+1; 
end   

Y = sim(netBE,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gE=gE+1; 
end   

Y = sim(netBF,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gF=gF+1; 
end   

Y = sim(netBG,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gG=gG+1; 
end   

Y = sim(netBH,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netBI,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netBJ,Uji);
g= vec2ind(Y);
if g==1
    gB=gB+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netDE,Uji);
g= vec2ind(Y);
if g==1
    gD=gD+1;
elseif g==2
    gE=gE+1; 
end   

Y = sim(netCD,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gD=gD+1; 
end   

Y = sim(netCE,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gE=gE+1; 
end   

Y = sim(netCF,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gF=gF+1; 
end   

Y = sim(netCG,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gG=gG+1; 
end   

Y = sim(netCH,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netCI,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netCJ,Uji);
g= vec2ind(Y);
if g==1
    gC=gC+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netDF,Uji);
g= vec2ind(Y);
if g==1
    gD=gD+1;
elseif g==2
    gF=gF+1; 
end   

Y = sim(netDG,Uji);
g= vec2ind(Y);
if g==1
    gD=gD+1;
elseif g==2
    gG=gG+1; 
end   

Y = sim(netDH,Uji);
g= vec2ind(Y);
if g==1
    gD=gD+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netDI,Uji);
g= vec2ind(Y);
if g==1
    gD=gD+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netDJ,Uji);
g= vec2ind(Y);
if g==1
    gD=gD+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netEF,Uji);
g= vec2ind(Y);
if g==1
    gE=gE+1;
elseif g==2
    gF=gF+1; 
end   

Y = sim(netEG,Uji);
g= vec2ind(Y);
if g==1
    gE=gE+1;
elseif g==2
    gG=gG+1; 
end   

Y = sim(netEH,Uji);
g= vec2ind(Y);
if g==1
    gE=gE+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netEI,Uji);
g= vec2ind(Y);
if g==1
    gE=gE+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netEJ,Uji);
g= vec2ind(Y);
if g==1
    gE=gE+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netFG,Uji);
g= vec2ind(Y);
if g==1
    gF=gF+1;
elseif g==2
    gG=gG+1; 
end   

Y = sim(netFH,Uji);
g= vec2ind(Y);
if g==1
    gF=gF+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netFI,Uji);
g= vec2ind(Y);
if g==1
    gF=gF+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netFJ,Uji);
g= vec2ind(Y);
if g==1
    gF=gF+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netGH,Uji);
g= vec2ind(Y);
if g==1
    gG=gG+1;
elseif g==2
    gH=gH+1; 
end   

Y = sim(netGI,Uji);
g= vec2ind(Y);
if g==1
    gG=gG+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netGJ,Uji);
g= vec2ind(Y);
if g==1
    gG=gG+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netHI,Uji);
g= vec2ind(Y);
if g==1
    gH=gH+1;
elseif g==2
    gI=gI+1; 
end   

Y = sim(netHJ,Uji);
g= vec2ind(Y);
if g==1
    gH=gH+1;
elseif g==2
    gJ=gJ+1; 
end   

Y = sim(netIJ,Uji);
g= vec2ind(Y);
if g==1
    gI=gI+1;
elseif g==2
    gJ=gJ+1; 
end   

gA
gB
gC
gD
gE
gF
gG
gH
gI
gJ

siapa='?';
citra=[''];
if gA>=gB && gA>=gC && gA>=gD && gA>=gE && gA>=gF && gA>=gG && gA>=gH && gA>=gI && gA>=gJ
    siapa='klasifikasi1';
    citra=['datalatih/1.jpg'];
elseif gB>=gA && gB>=gC && gB>=gD && gB>=gE && gB>=gF && gB>=gG && gB>=gH && gB>=gI && gB>=gJ
    siapa='klasifikasi2';
    citra=['datalatih/4.jpg'];
elseif gC>=gB && gC>=gA && gC>=gD && gC>=gE && gC>=gF && gC>=gG && gC>=gH && gC>=gI && gC>=gJ
        siapa='klasifikasi3';
    citra=['datalatih/7.jpg'];
elseif gD>=gB && gD>=gC && gD>=gA && gD>=gE && gD>=gF && gD>=gG && gD>=gH && gD>=gI && gD>=gJ
       siapa='klasifikasi4';
    citra=['datalatih/10.jpg'];
elseif gE>=gB && gE>=gC && gE>=gD && gE>=gA && gE>=gF && gE>=gG && gE>=gH && gE>=gI && gE>=gJ
       siapa='klasifikasi5';
    citra=['datalatih/13.jpg'];
elseif gF>=gB && gF>=gC && gF>=gD && gF>=gE && gF>=gA && gF>=gG && gF>=gH && gF>=gI && gF>=gJ
        siapa='klasifikasi6';
    citra=['datalatih/16.jpg'];
elseif gG>=gB && gG>=gC && gG>=gD && gG>=gE && gG>=gF && gG>=gA && gG>=gH && gG>=gI && gG>=gJ
        siapa='klasifikasi7';
    citra=['datalatih/19.jpg'];
elseif gH>=gB && gH>=gC && gH>=gD && gH>=gE && gH>=gF && gH>=gG && gH>=gA && gH>=gI && gH>=gJ
        siapa='klasifikasi8';
    citra=['datalatih/22.jpg'];
elseif gI>=gB && gI>=gC && gI>=gD && gI>=gE && gI>=gF && gI>=gG && gI>=gH && gI>=gA && gI>=gJ
        siapa='klasifikasi9';
    citra=['datalatih/5.jpg'];
elseif gJ>=gB && gJ>=gC && gJ>=gD && gJ>=gE && gJ>=gF && gJ>=gG && gJ>=gH && gJ>=gI && gJ>=gA
        siapa='klasifikasi10';
    citra=['datalatih/28.jpg'];


end




Sehingga Kita bisa menerapkan LVQ bawaannya Matlab ke dalam multi row atau banyak klasifikasi Output yang diinginkan.....

Hasil :
gA =

     1


gB =

     2


gC =

     9


gD =

     7


gE =

     8


gF =

     5


gG =

     6


gH =

     2


gI =

     2


gJ =


     3


Klasifiaksi kategori 3 atau gC dengan nilai tertinggi (9)./ Terbukti karena Uji=datatraining(:,5) terletak pada klasifikasi / gropu ke 3 atau C.
datatarget=[1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 10];

%dtatargetsim =[AAABBBCCCDDDEEEFFFGGGHHHIIIJJJ]

dengan code generatenya adlah sbb:

al=['datalatih/'];
B=30;
path=[al '1.jpg'];
I=imread(path);
ED=double(getNormalisasi(I));
w=size(ED,1);
h=size(ED,2);
wh=w*h;
for i=1:B
    path=[al num2str(i) '.jpg']
    I=imread(path);
    ED=double(getNormalisasi(I));
    M=reshape(ED,[1,wh]);
    datalatih(i,:)=M;
end    

datatarget=[1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 10];
save datalatih.mat datalatih
save datatarget.mat datatarget


msgbox('Generate Berhasil','sukse','help');

oK SELAMAT MENCOBAAA...................................