THE MADALINE
Madaline (Many Adaline) adalah
ekstensi multilayer dari bipolar neuron tunggal adaline ke jaringan. Ini juga
karena B. Widrow (1988). Metodologi penyesuaian bobotnya lebih intuitif daripada di Propagasi Belakang
dan memberikan pemahaman tentang kesulitan penyesuaian bobot dalam jaringan multi-layer,
meskipun kurang efisien. Struktur dasarnya adalah diberikan pada Gambar. 5.1 yang
dalam hal dua lapisan Adalines, ditambah lapisan input yang hanya berfungsi sebagai
distributor input jaringan.
Pelatihan Madaline berbeda dari
pelatihan Adaline karena tidak ada output parsial yang diinginkan
dari lapisan dalam dapat tersedia. Lapisan dalam dengan demikian disebut lapisan tersembunyi. Seperti halnya pada
sistem saraf pusat manusia (SSP), kita dapat menerima pembelajaran informasi dalam hal hasil yang
diinginkan dan tidak diinginkan, meskipun manusia tidak sadar akan hasil dari neuron
individu di dalam SSP yang berpartisipasi di dalamnya belajar, jadi di JST tidak ada
informasi lapisan dalam neuron tersedia. Madaline menggunakan prosedur
pelatihan yang dikenal sebagai Madaline Rule II, yangdidasarkan pada Prinsip Gangguan
Minimum, sebagai berikut [Widrow et al., 1987]:
(1) Semua bobot diinisialisasi
dengan nilai acak rendah. Selanjutnya, satu set pelatihan L input vektor Xi (i = 1, 2,., L)
diterapkan satu vektor pada satu waktu ke input.
(2) Jumlah nilai bipolar yang
salah pada lapisan keluaran dihitung dan ini angka dilambangkan sebagai
kesalahan e per vektor input yang diberikan.
(3) Untuk semua neuron pada
lapisan keluaran:
- Dengan menyatakan th sebagai ambang fungsi aktivasi (lebih disukai 0), periksa: [z-th] untuk setiap vektor input dari set vektor pelatihan yang diberikan untuk lapisan tertentu yang dipertimbangkan pada langkah ini. Pilih neuron yang belum disetel pertama dari atas tetapi yang sesuai dengan abs terendah [z-th] yang terjadi set vektor input. Oleh karena itu, untuk kasus vektor input L dalam input mengatur dan untuk lapisan n neuron, seleksi adalah dari nilai n × L dari z. Ini adalah simpul yang dapat membalik polaritasnya dengan perubahan terkecil dalam bobotnya, Dengan demikian dilambangkan sebagai neuron gangguan minimum, dari mana nama prosedur diturunkan. Neuron yang sebelumnya tidak disetel adalah neuron yang bobot belum diatur.
- Selanjutnya, seseorang harus mengubah bobot neuron yang terakhir sehingga output bipolar y dari unit itu berubah. Perubahan terkecil dalam berat via prosedur paling curam yang dimodifikasi yang mempertimbangkan [z-th] sebagai gantinya. Atau, perubahan acak dapat dipekerjakan.
- Kumpulan input vektor diperbanyak ke output sekali lagi.
- Jika perubahan berat mengurangi biaya kinerja "e" dari Langkah 2, maka perubahan ini diterima. Selain itu, bobot asli (sebelumnya) dikembalikan ke neuron itu.
(4) Ulangi Langkah 3 untuk semua
lapisan kecuali untuk lapisan input.
(5) Untuk semua neuron pada
lapisan keluaran: Terapkan Langkah 3, 4 untuk sepasang neuron yang analog-outputs z paling dekat
dengan nol, dll.
(6) Untuk semua neuron pada
lapisan keluaran: Terapkan Langkah 3, 4 untuk triplet neuron yang analog-output-nya paling
dekat dengan nol, dll.
(7) Pergi ke vektor berikutnya
hingga vektor L.
(8) Ulangi untuk kombinasi lebih
lanjut dari vektor L sampai pelatihan memuaskan.
Hal yang sama dapat diulang untuk
empat kali lipat neuron, dll. Namun, pengaturan ini kemudian menjadi sangat panjang
dan karena itu dapat dibenarkan. Semua bobot awalnya setel ke (berbeda) nilai acak
rendah. Nilai bobot dapat positif atau negatif dalam beberapa rentang
tetap, katakanlah, antara −1 dan 1. Tingkat pembelajaran awal μ dari Persamaan. (3.18) dari bab
sebelumnya harus antara 1 dan 20. Agar memadai konvergensi, jumlah neuron lapisan
tersembunyi harus setidaknya 3, lebih disukai lebih tinggi. Banyak langkah
iterasi (seringkali, ribuan) dari algoritma penurunan paling curam diperlukan untuk
konvergensi. Lebih baik menggunakan bipolar daripada konfigurasi biner untuk fungsi
aktivasi.
Diskusi di atas dari jaringan
saraf Madeline (NN) menunjukkan bahwa Madeline adalah NN yang intuitif
tetapi agak primitif dan tidak efisien. Itu juga sangat sensitif terhadap
kebisingan. Padahal ia memiliki sifat dasar dari beberapa jaringan saraf
lainnya dibahas dalam bab-bab selanjutnya
dari teks ini, kita akan melihat bahwa jaringan dibahas nanti jauh lebih efisien dan
kurang sensitif terhadap kebisingan.
Sub Fungsi :
Merancang Jaringan Saraf Madaline
(Multi Adaline) untuk mengenali 3 karakter 0, C dan F yang disediakan dalam
format biner dan direpresentasikan menggunakan kisi 6 × 6. Itu Neural Network harus dilatih dan
diuji dengan berbagai pola dan total tingkat kesalahan dan jumlah
konvergensi harus diperhatikan. Pola khas yang digunakan untuk pelatihan
dan pengujian seperti pada Gambar 5.A.1.
Gambar 5.A.1 : Pola yang akan dikenali
Jaringan Madaline seperti pada
Gambar 5.A.2 diimplementasikan dengan 3 layer, input (6 neuron), tersembunyi (3 neuron),
dan output (2 neuron), lapisan. 36 input dari kisi berisi karakter 0, C atau F
diberikan sebagai input ke jaringan. 15 input tersebut set diberikan, masing-masing 5
untuk 3 dan 0. Bobot jaringan awalnya diatur dalam mode acak dalam kisaran {−1, 1}.
Gambar 5.A.2: Jaringan Madaline
Berikut ini adalah
langkah-langkah dasar untuk Pelatihan Jaringan Syaraf Tiruan Propagation Network
- Hasilkan satu set data pelatihan dengan 5 set masing-masing 0, C dan F masing-masing.
- Masukkan rangkaian pelatihan ini (lihat Gambar 5.A.3) ke jaringan.
- Tetapkan bobot jaringan secara acak dalam rentang {−1, 1}.
- Gunakan fungsi transfer hardlimiter untuk setiap neuron.
- Setiap output dilewatkan sebagai input ke lapisan berikutnya.
- Output akhir dibandingkan dengan output yang diinginkan dan kesalahan kumulatif untuk 15 input dihitung.
- Jika persen kesalahan di atas 15% maka bobot (untuk neuron yang memiliki output paling dekat dengan 0) dari lapisan output diubah menggunakan
- Berat diperbarui dan kesalahan baru ditentukan.
- Bobot diperbarui untuk berbagai neuron hingga tidak ada kesalahan atau kesalahan tersebut di bawah ambang batas yang diinginkan.
- Kumpulan data uji diumpankan ke jaringan dengan bobot yang diperbarui dan output (kesalahan) diperoleh dengan demikian menentukan efisiensi jaringan.
Gambar 5.A.3: Set Pelatihan:
gambar 5.A.3(a). Set Pelatihan 1
gambar 5.A.3(b). Set Pengujian 2
Hasil ditampilkan dibawah ini :
- Hidden Layer Weight Matrix:
Kolom 1 hingga 12
Kolom 13 hingga 24
Kolom 25 hingga 36
- Output Layer Weight Matrix:
Sebelum Perubahan
Modifikasi berat pada layer keluaran :
- Neuron dengan nilai Z terdekat dengan ambang batas : z index = 1
- Berat sebelum perubahan :
- Berat setelah perubahan :
- Output Layer Neuron berikutnya : z ind = 2
Nilai final untuk layer keluaran setelah dikonversi :
Nilai final untuk layer tersembunyi setelah dikonversi :
kolom 1 sampai 12
kolom 13 sampai 24
kolom 25 sampai 36
Eror Kumulatif Final :
counter = 7
Effisiensi Pelatihan :
eff : 82.5000
Prosedur pengujian :
Masing-masing 5 karakter untuk
‘0’, ‘C’ dan ‘F’ digunakan untuk menguji jaringan yang terlatih. Itu
jaringan ditemukan untuk
mendeteksi 12 karakter dari 15 karakter yang diberikan
dalam efisiensi 80%.
Efisiensi Pengujian :
eff : 80.0000%
- Jaringan Saraf Tiruan dilatih dan diuji untuk berbagai pola tes dan pelatihan. Dalam semua kasus, jumlah konvergensi dan tingkat kesalahan diamati.
- Konvergensi sangat tergantung pada lapisan tersembunyi dan jumlah neuron di setiap lapisan tersembunyi.
- Jumlah di setiap lapisan tersembunyi tidak boleh terlalu rendah atau terlalu tinggi.
- Jaringan saraf yang terlatih dengan baik sangat akurat dalam mengklasifikasikan data di sebagian besar kasus uji. Jumlah kesalahan yang diamati adalah 6% (rata-rata), yang sangat ideal untuk masalah klasifikasi seperti Deteksi Wajah.
Fungsi Utama :
%Training Patterns X = train_pattern; nu = 0.04;
%Displaying the 15 training patterns figure(1)
for i = 1:15, subplot(5,3,i) display_image(X(:,i),6,6,1);
end
%Testing Patterns
Y = test_pattern;
nu = 0.04;
%Displaying the 15 testing patterns figure(2)
for i = 1:15, subplot(5,3,i) display_image(Y(:,i),6,6,1);
end
%Initializations
index = zeros(2,6);
counter1 = 0;
counter2 = 0;
%Assign random weights initially at the start of training
w_hidden = (rand(6,36)-0.5)*2
w_output = (rand(2,6)-0.5)*2 %load w_hidden.mat
%load w_output.mat
%Function to calculate the parameters (z,y at the hidden and output layers given the weights at the two layers)
[z_hidden, w_hidden, y_hidden, z_output, w_output, y_output, counter] = calculation(w_hidden, w_output, X);
disp(‘Before Any Changes’)
w_output
z_output
y_output
save z_output z_output;
save z_hidden z_hidden;
save y_hidden y_hidden;
save y_output y_output;
counter
%i = 1;
%min_z_output = min(abs(z_output));
disp(‘At counter minimum’)
if (counter~= 0),
[w_output_min,z_index] =
min_case(z_output,w_output,counter,y_hidden,nu);
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min,
w_output_min, y_output_min, counter1] =
calculation(w_hidden, w_output_min, X); counter1
end
w_output_min;
z_output_min;
y_output_min;
if (counter > counter1),
%load w_output.mat;
%load z_output.mat;
%load y_output.mat;
counter = counter1;
w_output = w_output_min;
z_output = z_output_min;
y_output = y_output_min;
index(2,z_index) = 1;
end
%Adjusting the weights of
the hidden layer hidden_ind = zeros(1,6);
z_hid_asc =
sort(abs(z_hidden)); for i = 1:6,
for k = 1:6,
if z_hid_asc(i) == abs(z_hidden(k)),
hidden_ind(i) = k;
end
end
end
r1 = hidden_ind(1);
r2 = hidden_ind(2);
r3 = hidden_ind(3);
r4 = hidden_ind(4);
r5 = hidden_ind(5);
r6 = hidden_ind(6);
disp(‘At the beginning of the hidden layer Weight Changes - Neuron 1’)
%load w_hidden.mat;
if ((counter~=0)&(counter>6)),
[w_hidden_min] =
min_hidden_case(z_hidden,w_hidden,counter,X,nu,hidden_ind(1));
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_min, w_output, X); counter3
end
w_hidden;
if (counter3<counter),
counter=counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
index(1,r1) = 1;
end
disp(‘Hidden Layer - Neuron 2’)
%load w_hidden.mat;
%counter=counter2;
if ((counter~=0)&(counter>6)),
[w_hidden_min] =
min_hidden_case(z_hidden,w_hidden,counter,X,nu,hidden_ind(2));
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_min, w_output, X); counter3
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
index(1,r2)=1;
end
disp(‘Hidden Layer - Neuron 3’)
%load w_hidden.mat;
%counter=counter2;
if ((counter~=0)&(counter>6)),
[w_hidden_min] =
min_hidden_case(z_hidden,w_hidden,counter,X,nu,hidden_ind(3));
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_min, w_output, X); counter3
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
index(1,r3) = 1;
end
disp(‘Hidden Layer - Neuron 4’)
%load w_hidden.mat;
%counter=counter2;
if ((counter~=0)&(counter>6)),
[w_hidden_min] =
min_hidden_case(z_hidden,w_hidden,counter,X,nu,hidden_ind(4));
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min, w_output,
y_output_min, counter3] = calculation(w_hidden_min,
w_output, X); counter3
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
index(1,r4)=1;
end
disp(‘Hidden Layer - Neuron 5’)
%load w_hidden.mat;
%counter=counter2;
if (counter~=0),
[w_hidden_min] =
min_hidden_case(z_hidden,w_hidden,counter,X,nu,hidden_ind(5));
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_min, w_output, X); counter3
end
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
index(1,r5)=1;
end
disp(‘Combined Output Layer Neurons weight change’);
%load w_hidden.mat;
%counter = counter2;
if ((counter~=0)&(index(2,[1:2])~=1)&(counter>6)),
[w_output_two] =
min_output_double(z_hidden,y_hidden,counter,X,nu,w_output);
[z_hidden_min, w_hidden_min, y_hidden_min,
z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden,w_output_two, X); counter3
end
end
w_output;
%w_output_two;
if (counter3<counter),
counter = counter3;
%w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
w_output = w_output_two;
end
disp(‘Begin 2 neuron changes - First Pair’)
%load w_hidden.mat;
%counter = counter2;
if ((counter~=0)&(index(1,r1)~=1)&(index(1,r2)~=1)&(counter>6)),
[w_hidden_two] =
min_hidden_double(z_hidden,w_hidden,counter,X,nu,hidden_ind(1),hidden_ind(2));
[z_hidden_min, w_hidden_min, y_hidden_min, z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_two, w_output, X); counter3
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
end
disp(‘Begin 2 neuron changes - Second Pair’)
%load w_hidden.mat;
%counter = counter2;
if ((counter~=0)&(index(1,r2)~=1)&(index(1,r3)~=1)&(counter>6)),
[w_hidden_two] =
min_hidden_double(z_hidden,w_hidden,counter,X,nu,hidden_ind(2),hidden_ind(3));
[z_hidden_min, w_hidden_min, y_hidden_min, z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_two, w_output, X); counter3
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
end
disp(‘Begin 2 neuron changes - Third Pair’)
%load w_hidden.mat;
%counter = counter2;
if ((counter~=0)&(index(1,r3)~=1)&(index(1,r4)~=1)&(counter>6)),
[w_hidden_two] =
min_hidden_double(z_hidden,w_hidden,counter,X,nu,hidden_ind(3),hidden_ind(4));
[z_hidden_min, w_hidden_min, y_hidden_min, z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_two, w_output, X); counter3
end
w_hidden;
w_hidden_min;
if (counter3<counter),
counter = counter3;
w_hidden = w_hidden_min;
y_hidden = y_hidden_min;
z_hidden = z_hidden_min;
z_output = z_output_min;
y_output = y_output_min;
end
disp(‘Begin 2 neuron changes - Fourth Pair’)
%load w_hidden.mat;
%counter = counter2;
if ((counter~=0)&(index(1,r4)~=1)&(index(1,r5)~=1)&(counter>6)),
[w_hidden_two] =
min_hidden_double(z_hidden,w_hidden,counter,X,nu,hidden_ind(4),hidden_ind(5));
[z_hidden_min, w_hidden_min, y_hidden_min, z_output_min, w_output,
y_output_min, counter3] =
calculation(w_hidden_two, w_output, X); counter3
end
w_hidden;
w_hidden_min;
disp(‘Final Values For Output’)
w_output
z_output
y_output
disp(‘Final Values for Hidden’)
w_hidden
z_hidden
y_hidden
disp(‘Final Error Number’)
counter
disp(‘Efficiency’)
eff = 100 - counter/40*100
Sub Fungsi :
*****************Function to calculate the parameters (z,y at the
hidden and output layers given the weights at the two
layers)******************
function [z_hidden,
w_hidden, y_hidden, z_output, w_output, y_output, counter] =
calculation(w_hidden, w_output, X)
Outputs:
z_hidden - hidden layer z value
%w_hidden - hidden layer weight
%y_hidden - hidden layer output
%
%Respecitvely for the output layers
%Inputs:
%Weights at the hidden and output layers and the
training pattern set
counter = 0;
r = 1;
while(r<=15),
r;
for i = 1:6,
z_hidden(i) = w_hidden(i,:)*X(:,r);
if (z_hidden(i)>=0),
y_hidden(i) = 1;
else
y_hidden(i) =
-1;
end %%End of If
loop
end %% End of
for loop
z_hidden;
y_hiddent = y_hidden’;
for i = 1:2
z_output(i) = w_output(i,:)*y_hiddent;
if (z_output(i)>=0),
y_output(i) = 1;
else
y_output(i) = -1;
end %% End of If loop
end%% End of for loop
y_output;
Desired Output if (r<=5),
d1 = [1 1]; % For 0 else if
(r>10),
d1 = [-1 -1]
%For F
else
d1 = [-1 1]; % For C end
end
for i = 1:2,
error_val(i) = d1(i)-y_output(i);
if (error_val(i)~=0),
counter = counter+1;
end
end
r = r+1;
end
******Function to find weight changes for paired hidden layer**********
function [w_hidden_two] =
min_hidden_double(z_hidden,w_hidden,counter,X,nu,k,l)
w_hidden_two = w_hidden;
for j = 1:36,
w_hidden_two(k,j)
= w_hidden_two(k,j) + 2*nu*X(j,15)*counter; w_hidden_two(l,j) =
w_hidden_two(l,j) + 2*nu*X(j,15)*counter;
end
*********Function to find weight changes at hidden layer**************
function [w_hidden_min] =
min_hidden_case(z_hidden,w_hidden,counter,X,nu,k)
w_hidden_min = w_hidden;
for j = 1:36,
w_hidden_min(k,j) = w_hidden_min(k,j) +
2*nu*X(j,15)*counter;
end
%w_hidden_min
****Function to change weights for the max of 2z values at Output****
function [w_output_max,z_ind] =
max_case(z_output,w_output,counter,y_hidden,nu)
%load w_output;
%load z_output;
w_output_max = w_output;
z_ind = find(abs(z_output) == max(abs(z_output)))
for j = 1:5,
w_output_max(z_ind,j) =
w_output(z_ind,j)+2*nu*y_hidden(j)*counter;
end
z_output(z_index)
= w_output(z_index,:)*y_hiddent;
end
****************Function to
compute weight change at the output for neuron whose Z value is close to the
threshold**********************
function [w_output_min,z_index] =
min_case(z_output,w_output,counter,y_hidden,nu)
z_index = find(abs(z_output) == min(abs(z_output)))
w_output_min = w_output
for j = 1:5,
w_output_min(z_index,j) = w_output(z_index,j) +
2*nu*y_hidden(j)*counter;
end
w_output_min
*******Function to find weight changes with paired output neurons******
function [w_output_two] =
min_output_double(z_hidden,y_hidden,counter,X,nu,w_output)
w_output_two = w_output;
for j = 1:6,
w_output_two([1:2],j) =
w_output([1:2],j)+2*nu*y_hidden(j)*counter;
end
y_hidden;
counter;
2*nu*y_hidden*counter;
Tidak ada komentar:
Posting Komentar