DAFTAR ISI
Recurrent (Time Cycling) Back Propagation Networks
Struktur berulang dapat dimasukkan ke dalam jaringan saraf
propagasi belakang dengan memberi makan kembali output jaringan ke input
setelah masa pembelajaran telah lengkap. Fitur berulang ini dalam langkah-langkah terpisah
(siklus) perhitungan berat. Ini pertama kali diusulkan oleh Rumelhart et al. (1986) dan
selanjutnya oleh Pineda (1988), Hecht – Nielson (1990) dan oleh Hertz et al. (1991).
Pengaturan ini memungkinkan mempekerjakan propagasi belakang dengan sejumlah kecil
lapisan tersembunyi (dan karenanya of weight) dengan cara yang secara efektif setara dengan
menggunakan m-kali yang banyak lapisan jika m siklus komputasi berulang digunakan [lih.
Fausett, 1993].
Jaringan propagasi balik berulang (siklus waktu) dijelaskan
pada Gambar 12.1.
Elemen penundaan (D pada Gambar 12.1) di loop umpan balik
terpisah antara langkah-waktu (zaman, yang biasanya berhubungan dengan
iterasi tunggal). Di akhir zaman pertama output diumpankan kembali ke input.
Atau, seseorang dapat memberi makan kembali output-kesalahan sendirian di akhir setiap zaman,
untuk berfungsi sebagai input untuk zaman berikutnya.
Jaringan Gambar 12.1 menerima input x1 dan x2 pada berbagai
langkah waktu satu urutan lengkap (set) yang merupakan era pertama (siklus).
Bobotnya adalah dihitung seperti dalam jaringan propagasi balik konvensional
dan dijumlahkan sepanjang waktu langkah-langkah zaman tanpa penyesuaian bobot yang
sebenarnya sampai akhir zaman itu. Pada setiap langkah, output y1 dan y2 diumpankan kembali
untuk digunakan sebagai input untuk langkah waktu berikutnya. Di akhir satu pemindaian
lengkap dari semua input, satu era berikutnya dimulai dengan pemindaian lengkap baru dari input yang sama
dan langkah waktu seperti pada zaman sebelumnya. Ketika jumlah input berbeda dari jumlah
output, maka struktur Gambar 12.2 dapat digunakan.
Kedua struktur dalam Gambar. 12.1 dan 12.2 setara dengan
struktur di mana jaringan dasar (kecuali untuk umpan balik dari satu langkah
waktu ke langkah lain) diulangi m-kali, untuk memperhitungkan langkah-langkah waktu dalam
struktur berulang.
Jaringan yang berulang sepenuhnya mirip dengan jaringan Sec.
12.1 kecuali masing-masing lapisan memberi makan kembali ke setiap lapisan sebelumnya,
seperti pada Gambar. 12.4 (daripada memberi makan kembali dari output jaringan n-layer ke input jaringan, seperti
dalam Sec. 12.1). Sekarang output di setiap zaman menjadi input ke neuron
berulang di zaman berikutnya.
Jaringan saraf berbasis propagasi kembali berulang terus
menerus menggunakan struktur yang sama seperti pada Gambar. 12.1 dan 12.2 tetapi
recurrency diulangi dalam interval waktu yang sangat kecil. Oleh karena itu,
recurrency mematuhi perkembangan persamaan diferensial seperti pada jaringan
Hopfield berkelanjutan, yaitu
di mana τ adalah koefisien konstanta waktu, xi menjadi input
eksternal, g (· · ·) yang menunjukkan fungsi aktivasi, yi menunjukkan output dan vj menjadi output
dari lapisan tersembunyi neuron. Untuk stabilitas diperlukan
setidaknya satu solusi stabil dari Persamaan. (12.1) ada, yaitu
Studi Kasus Bagian. 6D menggambarkan algoritma back-propagation
berulang.
Studi kasus saat ini berkaitan dengan penyelesaian
pengenalan karakter sederhana masalah menggunakan jaringan saraf propagasi kembali
berulang. Tugasnya adalah mengajar jaringan saraf untuk mengenali 3 karakter, yaitu untuk
memetakan mereka masing-masing pasang {0,1}, {1,0} dan {1,1}. Jaringan juga harus
menghasilkan sinyal kesalahan khusus 0,0 sebagai respons terhadap karakter lain.
Struktur: Jaringan saraf terdiri dari tiga lapisan dengan
masing-masing 2 neuron, satu lapisan keluaran dan dua lapisan tersembunyi. Ada 36 input
reguler ke jaringan dan 2 input yang terhubung ke 2 kesalahan output. Jadi,
total ada 38 input ke jaringan saraf. Jaringan saraf seperti pada Bagian
6.A, kecuali itu itu adalah jaringan berulang, sehingga outputnya y1 dan y2
diumpankan kembali sebagai tambahan input pada akhir setiap iterasi. Istilah Bias (sama dengan
1) dengan bobot yang bisa dilatih juga termasuk dalam struktur jaringan. Diagram struktural
saraf kita jaringan diberikan pada Gambar. 12.A.1.
(a) Desain Dataset: Jaringan saraf dirancang untuk mengenali
karakter ‘A’, ‘B’, dan ‘C’. Untuk melatih jaringan untuk menghasilkan
sinyal kesalahan kita akan menggunakan 6 lainnya karakter: ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, dan ‘I’. Untuk memeriksa
apakah jaringan telah belajar untuk mengenali kesalahan, kita akan menggunakan karakter
‘X’, ‘Y’, dan ‘Z’. Perhatikan bahwa kami tertarik dalam memeriksa respons jaringan untuk kesalahan pada
karakter yang tidak terlibat dalam prosedur pelatihan. Karakter yang akan
dikenali diberikan pada a 6 × 6 kotak. Masing-masing dari 36 piksel diatur ke 0 atau
1. Matriks 6 × 6 yang sesuai adalah sebagai berikut :
(B) Pengaturan Berat: Belajar propagasi kembali digunakan
untuk memecahkan masalah. Tujuan dari algoritma ini adalah untuk meminimalkan energi
kesalahan pada lapisan output. Pengaturan berat badan seperti pada Propagasi-Kembali,
Bagian 6.2 dari Bab 6 di atas. Kode sumber untuk studi kasus ini (ditulis dalam C ++)
diberikan dalam Sect. 12.A.5.
(a) Mode Pelatihan
Untuk melatih jaringan untuk mengenali karakter-karakter di
atas yang kami terapkan sesuai 6 × 6 grid dalam bentuk 1 × 36 vektor ke input jaringan.
Tambahan dua input pada awalnya ditetapkan sama dengan nol dan selama
prosedur pelatihan diset sama dengan kesalahan output saat ini. Karakter
dianggap diakui jika kedua output jaringan tidak lebih dari 0,1 yang
diinginkan masing-masing nilai-nilai. Tingkat pembelajaran awal η secara
eksperimental ditetapkan pada 1,5 dan menurun dengan faktor 2 setelah setiap iterasi ke-100. Sama seperti
pada back propagation biasa (Bagian 6.A), setelah setiap iterasi ke-400 kita mereset
tingkat pembelajaran ke nilai awal, untuk mencegah proses pembelajaran macet di minimum lokal. Kemudian setelah sekitar 3000 iterasi kami dapat mengenali semua set data dengan benar. Namun, kami melanjutkan hingga 5.000 iterasi diselesaikan
untuk memastikan bahwa nilai kesalahan energi tidak dapat diturunkan lebih jauh.
Pada titik ini kita peroleh:
VEKTOR PELATIHAN 0: [0,0296153 0,95788] - DIAKUI -
VEKTOR PELATIHAN 1: [0.963354 2.83491e-06] - DIAKUI -
VEKTOR PELATIHAN 2: [0.962479 0.998554] - DIAKUI -
VEKTOR PELATIHAN 3: [0,0162449 0,0149129] - DIAKUI -
VEKTOR PELATIHAN 4: [0,0162506 0,0149274] - DIAKUI -
VEKTOR PELATIHAN 5: [0,0161561 0,014852] - DIAKUI -
VEKTOR PELATIHAN 6: [0,0168284 0,0153119] - DIAKUI -
VEKTOR PELATIHAN 7: [0,016117 0,0148073] - DIAKUI -
VEKTOR PELATIHAN 8: [0,016294 0,0149248] - DIAKUI -
Vektor pelatihan 0, 1,. . . , 8 pada entri log ini sesuai
dengan karakter ‘A’, ‘B’,. . . , ‘I’.
(b) Hasil Pengenalan (uji coba)
Deteksi Kesalahan: Untuk memeriksa kinerja deteksi
kesalahan, kami menyimpan yang diperoleh
menimbang ke dalam file data, memodifikasi dataset dalam
program yang menggantikan karakter ‘G’, ‘H’ dan ‘I’ (vektor pelatihan 6, 7 dan
8) dengan karakter ‘X’, ‘Y’, ‘Y’ dan ‘Z’.
Kemudian kami menjalankan program, memuat bobot yang
sebelumnya disimpan dari file data
dan menerapkan input ke jaringan. Perhatikan bahwa kami
tidak melakukan pelatihan lebih lanjut.
Kami mendapat hasil sebagai berikut:
VEKTOR PELATIHAN 6: [0,00599388 0,00745234] - DIAKUI -
VEKTOR PELATIHAN 7: [0,0123415 0,00887678] - DIAKUI -
VEKTOR PELATIHAN 8: [0,0433571 0,00461456] - DIAKUI -
Ketiga karakter berhasil dipetakan ke sinyal kesalahan {0,
0}.
Robustness: Untuk menyelidiki seberapa kuat jaringan saraf
kami, kami menambahkan beberapa noise ke input dan mendapat hasil berikut. Dalam kasus
distorsi 1-bit (keluar dari 36 bit) tingkat pengenalan adalah:
SET PELATIHAN 0: 18/38 pengenalan (47,3684%)
SET PELATIHAN 1: 37/38 pengenalan (97,3684%)
SET PELATIHAN 2: 37/38 pengenalan (97,3684%)
SET PELATIHAN 3: 5/38 pengenalan (13,1579%)
SET PELATIHAN 4: 5/38 pengenalan (13,1579%)
SET PELATIHAN 5: 5/38 pengenalan (13,1579%)
SET PELATIHAN 6: 6/38 pengenalan (15,7895%)
SET PELATIHAN 7: 5/38 pengenalan (13,1579%)
SET PELATIHAN 8: 6/38 pengenalan (15,7895%)
Dengan 2 bit kesalahan per karakter, kinerjanya bahkan lebih
buruk.
Kami dapat melatih jaringan saraf kami sehingga berhasil
mengenali tiga karakter yang diberikan dan pada saat yang sama dapat
mengklasifikasikan karakter lain sebagai kesalahan. Namun, hasilnya tidak spektakuler untuk dataset
input terdistorsi. Karakter ‘A’, ‘B’, dan ‘C’, yang dilatih oleh jaringan kami,
berhasil dikenali dengan distorsi 1 dan 2 bit (dengan kemungkinan
pengecualian karakter ‘A’
tetapi bisa ditingkatkan dengan meningkatkan jumlah
iterasi). Tapi pengakuan karakter ‘dari seluruh dunia’ tidak bagus. Membandingkan hasil ini dengan hasil yang dicapai
menggunakan propagasi balik murni, kita dapat melihat bahwa untuk masalah khusus ini, jika bit
noise ditambahkan ke data, recurrency memperburuk hasil kinerja pengakuan dibandingkan
dengan reguler (tidak berulang) Propagasi Kembali. Juga, karena pengenalan
input berulang kami harus menambah jumlah input sebanyak dua. Ini
mengakibatkan peningkatan jumlah bobot dalam jaringan dan, karenanya, dalam
pembelajaran yang agak lambat.
/*
*/
#include<cmath>
#include<iostream>
#include<fstream>
using namespace std;
#define N_DATASETS 9
#define N_INPUTS 38
#define N_OUTPUTS 2
#define N_LAYERS 3
{# inputs, # of neurons in L1, # of neurons in
L2, # of neurons in
L3}
short conf[4] = {N_INPUTS, 2, 2, N_OUTPUTS};
According to the number of
layers double **w[3], *z[3], *y[3], *Fi[3], eta; ofstream
ErrorFile("error.txt", ios::out);
3 training sets; inputs 36 and 37 (starting from
0) will be used
for feeding back the output error bool
dataset[N_DATASETS][N_INPUTS] = {
{
|
0,
|
0,
|
1,
|
1,
|
0,
|
0,
|
//
|
‘A’
|
|
0,
|
1,
|
0,
|
0,
|
1,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
0,
|
0},
|
||
{
|
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
//
|
‘B’
|
|
9
|
|||||||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
0,
|
0},
|
||
{
|
0,
|
1,
|
1,
|
1,
|
1,
|
1,
|
//
|
‘C’
|
|
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
0,
|
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
0},
|
||
{
|
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
//
|
‘D’
|
|
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
0,
|
0},
|
||
{
|
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
//
|
‘E’
|
|
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
0},
|
||
{
|
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
//
|
‘F’
|
|
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
0,
|
0},
|
||
{
|
0,
|
1,
|
1,
|
1,
|
1,
|
1,
|
//
|
‘G’
|
|
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
0,
|
1,
|
1,
|
1,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
0,
|
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
0},
|
||
{
|
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
//
|
‘H’
|
|
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
||||
10
|
|||||||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
0,
|
0},
|
||
{
|
0,
|
0,
|
1,
|
1,
|
1,
|
0,
|
//
|
‘I’
|
|
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
1,
|
1,
|
1,
|
0,
|
0,
|
0}
|
dibawah ini adalah dataset untuk memeriksa "keseluruhan". Bukan dilatih oleh NN.
/*
{
|
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
//
|
‘X’
|
|
0,
|
1,
|
0,
|
0,
|
1,
|
0,
|
||||
0,
|
0,
|
1,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
1,
|
1,
|
0,
|
0,
|
||||
0,
|
1,
|
0,
|
0,
|
1,
|
0,
|
||||
1,
|
0,
|
0,
|
0,
|
0,
|
1,
|
0,
|
0},
|
||
{
|
0,
|
1,
|
0,
|
0,
|
0,
|
1,
|
//
|
‘Y’
|
|
0,
|
0,
|
1,
|
0,
|
1,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
0,
|
0},
|
||
{
|
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
//
|
‘Z’
|
|
0,
|
0,
|
0,
|
0,
|
1,
|
0,
|
||||
0,
|
0,
|
0,
|
1,
|
0,
|
0,
|
||||
0,
|
0,
|
1,
|
0,
|
0,
|
0,
|
||||
0,
|
1,
|
0,
|
0,
|
0,
|
0,
|
||||
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
0,
|
0}*/
|
},
datatrue[N_DATASETS][N_OUTPUTS]
= {{0,1}, {1,0}, {1,1}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}};
Memory allocation and initialization function
void MemAllocAndInit(char S)
{
if(S == ‘A’)
for(int i = 0; i < N_LAYERS; i++) 11
w[i] = new double*[conf[i +
1]]; z[i] = new double[conf[i + 1]]; y[i] = new double[conf[i + 1]]; Fi[i] =
new double[conf[i + 1]]; for(int j = 0; j < conf[i + 1]; j++) {
}
}
w[i][j] = new double[conf[i] + 1];
Initializing in the range (-0.5;0.5) (including
bias
weight)
for(int k = 0; k <= conf[i]; k++)
w[i][j][k] = rand()/(double)RAND_MAX - 0.5;
if(S == ‘D’)
{
for(int i = 0; i < N_LAYERS; i++)
{
}
for(int j = 0; j < conf[i + 1]; j++)
delete[] w[i][j];
delete[] w[i], z[i], y[i], Fi[i];
}
}
ErrorFile.close();
Activation function double FNL(double z)
{
}
double y;
y = 1. / (1. + exp(-z));
return y;
Applying input
void ApplyInput(short sn)
{
double input;
12
// Counting layers
for(short i = 0; i < N_LAYERS; i++)
Counting neurons in each layer for(short j = 0;
j < conf[i + 1]; j++)
{
z[i][j] = 0.;
Counting input to each layer (= # of neurons in
the previous
layer)
for(short k = 0; k < conf[i]; k++)
{
If the layer is not the
first one if(i) input = y[i - 1][k];
else
input = dataset[sn][k];
z[i][j] += w[i][j][k] * input;
}
}
}
z[i][j] += w[i][j][conf[i]]; // Bias term y[i][j] = FNL(z[i][j]);
Training function, tr - # of runs void Train(int
tr)
{
short i, j, k, m, sn;
double eta, prev_output, multiple3, SqErr, eta0;
Starting learning rate eta0
= 1.5; eta = eta0;
Going through all tr training runs for(m = 0; m
< tr; m++)
{
SqErr = 0.;
Each training run consists
of runs through each training set for(sn = 0; sn < N_DATASETS; sn++)
{
13
ApplyInput(sn);
// Counting the layers down
for(i = N_LAYERS - 1; i >= 0; i--)
Counting neurons in the layer for(j = 0; j <
conf[i + 1]; j++)
{
if(i == 2) // If it is the output layer
multiple3 = datatrue[sn][j] - y[i][j]; else
{
}
multiple3 = 0.;
Counting neurons in the
following layer for(k = 0; k < conf[i + 2]; k++) multiple3 += Fi[i + 1][k] *
w[i + 1][k][j];
Fi[i][j] = y[i][j] * (1 - y[i][j]) * multiple3;
Counting weights in the neuron
(neurons in the previous layer)
for(k = 0; k < conf[i]; k++)
{
{
switch(k)
{
case 36:
if(i) // If it is not a first layer prev_output
= y[i - 1][k]; else
prev_output = y[N_LAYERS - 1][0] - datatrue[sn][0];
break;
case 37:
prev_output = y[N_LAYERS - 1][1] - datatrue[sn][1];
break;
default:
prev_output = dataset[sn][k];
}
}
}
w[i][j][k] += eta * Fi[i][j] * prev_output; 14
}
Bias weight correction w[i][j][conf[i]] += eta *
Fi[i][j];
}
SqErr += pow((y[N_LAYERS -
1][0] - datatrue[sn][0]), 2) + pow((y[N_LAYERS - 1][1] - datatrue[sn][1]), 2);
}
}
ErrorFile << 0.5 * SqErr << endl;
Decrease learning rate every 100th iteration
if(!(m % 100)) eta /= 2.;
Go back to original learning rate every 400th
iteration if(!(m % 400)) eta = eta0;
Prints complete information about the network
void PrintInfo(void)
{
// Counting layers
for(short i = 0; i < N_LAYERS; i++)
{
cout << "LAYER " << i << endl;
Counting neurons in each layer for(short j = 0;
j < conf[i + 1]; j++)
{
cout << "NEURON " << j << endl;
Counting input to each layer (= # of neurons in
the previous
layer)
for(short k = 0; k < conf[i]; k++)
cout << "w[" << i << "][" <<
j << "][" << k << "]="
<< w[i][j][k] << ‘ ’;
cout << "w[" << i << "][" <<
j << "][BIAS]="
<< w[i][j][conf[i]] << ‘ ’ << endl;
cout << "z[" << i << "][" <<
j << "]=" << z[i][j] << endl;
cout << "y[" << i << "][" <<
j << "]=" << y[i][j] << endl;
}
}
15
}
Prints the output of the network void
PrintOutput(void)
{
Counting number of datasets
for(short sn = 0; sn < N_DATASETS; sn++)
{
}
}
ApplyInput(sn);
cout << "TRAINING SET " << sn << ": [
";
Counting neurons in the
output layer for(short j = 0; j < conf[3]; j++) cout << y[N_LAYERS -
1][j] << ‘ ’;
cout << "] ";
if(y[N_LAYERS - 1][0] >
(datatrue[sn][0] - 0.1) && y[N_LAYERS - 1][0] < (datatrue[sn][0] +
0.1) && y[N_LAYERS - 1][1] > (datatrue[sn][1] - 0.1) &&
y[N_LAYERS - 1][1] < (datatrue[sn][1] + 0.1)) cout << "---
RECOGNIZED ---";
else
cout << "--- NOT
RECOGNIZED ---"; cout << endl;
Loads weithts from a file void LoadWeights(void)
{
double in;
ifstream file("weights.txt", ios::in);
// Counting layers
for(short i = 0; i < N_LAYERS; i++)
Counting neurons in each layer for(short j = 0;
j < conf[i + 1]; j++)
Counting input to each layer (= # of neurons in
the previous
// layer)
for(short k = 0; k <= conf[i]; k++)
{
16
}
file >> in;
w[i][j][k] = in;
}
file.close();
Saves weithts to a file void SaveWeights(void)
{
}
ofstream file("weights.txt", ios::out);
Counting layers
for(short i = 0; i < N_LAYERS; i++)
Counting neurons in each layer for(short j = 0;
j < conf[i + 1]; j++)
Counting input to each layer (= # of neurons in
the previous
layer)
for(short k = 0; k <= conf[i]; k++)
file << w[i][j][k] << endl;
file.close();
Gathers recognition
statistics for 1 and 2 false bit cases void GatherStatistics(void)
{
short sn, j, k, TotalCases;
int cou;
cout << "WITH 1 FALSE BIT PER CHARACTER:" << endl;
TotalCases = conf[0];
Looking at each dataset
for(sn = 0; sn < N_DATASETS; sn++)
{
cou = 0;
Looking at each bit in a dataset for(j = 0; j
< conf[0]; j++)
{
if(dataset[sn][j]) dataset[sn][j] = 0; 17
}
else
dataset[sn][j] = 1; ApplyInput(sn);
if(y[N_LAYERS - 1][0] > (datatrue[sn][0] - 0.1)
y[N_LAYERS - 1][0] < (datatrue[sn][0] + 0.1)
y[N_LAYERS - 1][1] > (datatrue[sn][1] - 0.1)
y[N_LAYERS - 1][1] < (datatrue[sn][1] + 0.1))
cou++;
// Switching back
if(dataset[sn][j]) dataset[sn][j] = 0;
else
dataset[sn][j] = 1;
}
cout << "TRAINING SET " << sn << ":
" << cou << ‘/’ << TotalCases
<< "
recognitions (" << (double)cou / TotalCases * 100. <<
"%)" << endl; cout << "WITH 2 FALSE BITS PER CHARACTER:"
<< endl;
TotalCases = conf[0] * (conf[0] - 1);
// Looking at each dataset
for(sn = 0; sn < N_DATASETS; sn++)
{
cou = 0;
Looking at each bit in a
dataset for(j = 0; j < conf[0]; j++) for(k = 0; k < conf[0]; k++)
{
if(j == k) continue;
if(dataset[sn][j]) dataset[sn][j] = 0; else dataset[sn][j] = 1;
if(dataset[sn][k]) dataset[sn][k] = 0; else dataset[sn][k] = 1; 18
}
ApplyInput(sn);
if(y[N_LAYERS - 1][0] > (datatrue[sn][0] - 0.1)
y[N_LAYERS - 1][0] < (datatrue[sn][0] + 0.1)
y[N_LAYERS - 1][1] > (datatrue[sn][1] - 0.1)
y[N_LAYERS - 1][1] < (datatrue[sn][1] + 0.1))
cou++;
if(dataset[sn][j]) // Switching back
dataset[sn][j] = 0; else
dataset[sn][j] = 1;
if(dataset[sn][k]) dataset[sn][k] = 0; else dataset[sn][k] = 1;
}
}
cout << "TRAINING SET " << sn << ":
" << cou << ‘/’ << TotalCases
<< "
recognitions (" << (double)cou / TotalCases * 100. <<
"%)" << endl; // Entry point: main menu int main(void)
{
short ch; int x;
MemAllocAndInit(‘A’); do
{
cout << "MENU" << endl;
cout << "1. Apply input and print parameters" <<
endl;
cout <<
"2. Apply input (all training sets) and print output" << endl;
cout << "3. Train network" << endl; cout <<
"4. Load weights" << endl; cout << "5. Save weights"
<< endl;
cout << "6.
Gather recognition statistics" << endl; cout << "0.
Exit" << endl;
19
cout << "Your choice: ";
cin >> ch; cout << endl; switch(ch)
{
case 1: cout << "Enter set number: ";
cin >> x; ApplyInput(x); PrintInfo(); break;
case 2: PrintOutput();
break;
case 3: cout << "How many training
runs?: "; cin >> x; Train(x); break; case 4: LoadWeights();
break;
case 5: SaveWeights();
break;
case 6: GatherStatistics();
break;
case 0: MemAllocAndInit(‘D’);
return 0;
}
}
cout << endl;
cin.get();
cout << "Press ENTER to continue..." << endl;
cin.get();
}
while(ch);
20
Tidak ada komentar:
Posting Komentar