Anda di halaman 1dari 66

Kendali PPR Dengan Neural Network Dengan Metode Direct, Open loop & Fine Tuning dengan Variasi Delay dan perbandingannya

Fine Tuning dengan Variasi Delay dan perbandingannya Disusun Oleh Andi Falih 1406608561 Fakulas Teknik

Disusun Oleh

Andi Falih 1406608561

Fakulas Teknik

Universitas Indonesia Depok

2018

I.

TEORI

Backpropagation neural network, seperti halnya dengan kebanyakan jaringan syaraf, tujuan dari Backpropagation adalah untuk melatih jaringan untuk mencapai keseimbangan antara kemampuan untuk merespon dengan benar pola input yang digunakan untuk pelatihan (penghafalan) dan kemampuan untuk memberikan respon yang wajar (baik) untuk input yang serupa, tetapi tidak identik, yang digunakan dalam pelatihan (generalisasi).

Setelah pelatihan, penerapan jaringan hanya melibatkan perhitungan fase feedforward. Bahkan jika pelatihannya lambat, jaringan terlatih dapat menghasilkan outputnya dengan sangat cepat.

Pelatihan jaringan dengan backpropagation melibatkan tiga tahap: Seperti halnya dengan kebanyakan jaringan syaraf, tujuan dari Backpropagation adalah untuk melatih jaringan untuk mencapai keseimbangan antara kemampuan untuk merespon dengan benar pola input yang digunakan untuk pelatihan (menghafal ) dan kemampuan untuk memberikan tanggapan yang masuk akal (baik) terhadap input yang serupa, tetapi tidak identik, dengan yang digunakan dalam pelatihan (generalisasi).

Setelah pelatihan, penerapan jaringan hanya melibatkan perhitungan fase feedforward. Bahkan jika pelatihannya lambat, jaring terlatih dapat menghasilkan outputnya dengan sangat cepat.

Pelatihan jaringan dengan backpropagation melibatkan tiga tahap:

1 feedforward dari pola pelatihan input.

2 Perhitungan dan backpropagation dari kesalahan terkait.

3 Penyesuaian bobot.

Untuk aplikasi pada bidang kendali dilakukan 2 buah neural network yaitu neural network untuk menggantikan plant/wahana dan neural network untuk pengendali. Cara kerja pada neural network ini berupa feedforward dan backpropagation untuk setiap input yang mempengaruhi input. Input pada kendali neural untuk pengganti plant adalah masukan pada plant dan keluarannya berupa keluaran pada plant, neural akan mempelajari karakteristik tiap input sehingga dapat menyerupai karakteristik plant, sedangkan pada input kendali neural untuk pengganti pengendali plant menggunakan output pada plant dan keluarannya merupakan input pada plant dengan memberikan delay agar sesuai dengan keadaan plant sebenarnya.

1.1 Arsitektur

Jaringan syaraf multilayer dengan satu lapis unit tersembunyi / hidden layer (unit Z) ditunjukkan pada Gambar 1. Unit output (unit Y) dan unit tersembunyi juga mungkin memiliki bias (seperti yang ditunjukkan). Bias pada unit output khas Yk dilambangkan dengan w0k; bias pada unit tersembunyi khas Zj dilambangkan dengan v0j.

Hanya arah arus informasi untuk fase operasi feedforward yang ditampilkan. Selama fase pembelajaran backpropagation, sinyal dikirim ke arah sebaliknya.

Algoritma disajikan untuk satu lapisan tersembunyi, yang memadai untuk sejumlah besar aplikasi.

1.2 Algoritma

Seperti disebutkan sebelumnya, melatih jaringan dengan backpropagation melibatkan tiga tahapan: umpan balik dari pola pelatihan input, backpropagation dari kesalahan terkait, dan penyesuaian bobot.

dari kesalahan terkait, dan penyesuaian bobot. Gambar 1.1 Jaringan syaraf tiruan backpropagation dengan

Gambar 1.1 Jaringan syaraf tiruan backpropagation dengan satu layer tersembunyi dengan X sebagai input, Z sebagai hidden layer, dan Y sebagai Output layer

a. Selama feedforward:

1. Setiap unit input (Xi) menerima sinyal input dan menyiarkan sinyal ini ke masing-masing

unit tersembunyi

, Zp.

2.

Setiap unit tersembunyi kemudian menghitung aktivasi dan mengirimkan zj sinyal ke setiap unit output.

3. Setiap unit output Yk menghitung aktivasi yk untuk membentuk respons net untuk pola input yang diberikan.

b. Selama pelatihan:

1. Setiap unit output membandingkan yk aktivasi yang dikomputasi dengan nilai target tk untuk menentukan kesalahan terkait untuk pola tersebut dengan unit itu.

2. Berdasarkan kesalahan ini, faktor δk (k = 1,

3. δk digunakan untuk mendistribusikan kesalahan pada unit output Yk kembali ke semua unit di lapisan sebelumnya (unit tersembunyi yang terhubung ke Yk).

4. Ini juga digunakan (nanti) untuk memperbarui bobot antara output dan layer tersembunyi.

5. Dengan cara yang sama, faktor δj (j = 1,

6. Tidak perlu untuk menyebarkan kesalahan kembali ke lapisan input, tetapi δj digunakan untuk memperbarui bobot antara lapisan tersembunyi dan lapisan input.

, m) dihitung.

, p) dihitung untuk setiap unit tersembunyi Zj.

c. Penyesuaian bobot:

1. Setelah semua faktor telah ditentukan, bobot untuk semua lapisan disesuaikan secara bersamaan.

2. Penyesuaian terhadap bobot wjk (dari unit tersembunyi Zj ke unit output Yk) didasarkan pada faktor δk dan zj aktivasi dari unit tersembunyi Zj.

3. Penyesuaian terhadap bobot vij (dari unit input Xi ke unit tersembunyi Zj) didasarkan pada faktor δj dan aktivasi xi dari unit input.

Istilah yang digunakan dalam algoritma pelatihan untuk jaringan backpropagation adalah sebagai berikut:

No

Symbol

Arti

1

x

Masukan vektor pelatihan: x = (x1,

 

,

xi,

,

xn).

2

t

Output vektor target: t = (tl,

,

te,

,

tm).

 

3

δk

Bagian penyesuaian bobot koreksi kesalahan untuk wjk yang disebabkan oleh kesalahan pada unit output Yk; juga, informasi

   

tentang kesalahan pada unit Yk yang diperbanyak kembali ke unit tersembunyi yang dimasukkan ke dalam unit Yk.

4

δj

Bagian penyesuaian bobot koreksi kesalahan untuk vij yang disebabkan oleh informasi kesalahan backpropagation dari lapisan output ke unit tersembunyi Zj

5

α (alpha)

Tingkat pembelajaran.

6

Xi

Unit masukan ke-i: Untuk unit input, sinyal input dan sinyal output adalah sama, yaitu, xi.

7

v0j

Bias pada unit tersembunyi Zj.

8

Zj

Unit tersembunyi j:

Input net ke Zj dilambangkan z_inj:

z_inj = v0j + ∑xi * vij Sinyal keluaran (aktivasi) Zj dilambangkan sebagai zj:

zj = f (z_inj)

9

w0k

Bias pada unit output k. Unit keluaran k:

Masukan bersih untuk Yk dilambangkan dengan y_ink:

y_ink = w0k + ∑zj wjk Sinyal output (aktivasi) dari Yk dilambangkan yk:

yk = f(y_ink)

Tabel 1.1 Istilah pada BPNN

1.3 Fungsi aktivasi

Fungsi aktivasi untuk jaring backpropagation harus memiliki beberapa karakteristik penting: Ini harus terus menerus, terdiferensiasi, dan tidak terjadi. Lebih jauh lagi, untuk efisiensi komputasi, diharapkan turunannya mudah dikomputasi.

Salah satu fungsi aktivasi yang paling umum adalah fungsi sigmoid bipolar, yang memiliki rentang (-1, 1) dan didefinisikan sebagai

fungsi aktivasi yang paling umum adalah fungsi sigmoid bipolar , yang memiliki rentang (-1, 1) dan
1.4 Algoritma pelatihan Salah satu fungsi aktivasi yang didefinisikan di bagian sebelumnya dapat digunakan dalam

1.4 Algoritma pelatihan

Salah satu fungsi aktivasi yang didefinisikan di bagian sebelumnya dapat digunakan dalam algoritma backpropagation standar yang diberikan di sini. Bentuk data (terutama nilai target) merupakan faktor penting dalam memilih fungsi yang sesuai.

Algoritemanya adalah sebagai berikut:

Step 0 : Inisialisai Bobot

Random

Nguyen-Widrow

Step 1 : Selama kondisi stopping FALSE, lakukan Step 2-9

Step 2 : Untuk setiap pasangan pelatihan, lakukan Step 3-8

Proses Feedforward :

Step 3 : Setiap unit input (Xi, i = 1,…,n) :

menerima input xi

mengirimkannya ke semua unit layer diatasnya (Hidden layer).

Step 4 : Setiap unit hidden (Zj, j = 1,…,p)

menghitung semua sinyal input dengan bobotnya :

z_inj = voj + Σ xi vij

menghitung nilai aktivasi setiap unit hidden sebagai output unit hidden :

zj = f(z_inj)

mengirim nilai aktivasi sebagai input untuk unit output.

Step 5 : Setiap unit output (Yk, k = 1,…,m)

menghitung semua sinyal inputnya dengan bobotnya :

y_ink = wok + Σ zj wjk

menghitung nilai aktivasi setiap unit output sebagai output jaringan.

yk = f(y_ink)

Backpropagation of error :

Step 6 : Setiap unit output (Yk, k = 1,…,m) :

menerima pola target yang bersesuaian dengan pola input

menghitung informasi error :

δk = (tk - yk) f’(y_ink)

menghitung besarnya koreksi bobot unit output :

Δwjk = α ∂E(wjkj)/∂wjk= α δk zj

menghitung besarnya koreksi bias output :

Δw0k = α δk

mengirimkan δk ke unit-unit yang ada pada layer di bawahnya.

Step 7 : Setiap unit hidden (Zj, j = 1,…,p) :

menghitung semua koreksi error :

δ_inj = Σ δk wjk

menghitung nilai aktivasi koreksi error :

δj = δ_inj f’(z_inj)

menghitung koreksi bobot unit hidden :

menghitung koreksi error bias unit hidden :

Δv0j = α δj

Step 8 : Setiap unit output (Yk, k = 1,…,m) :

o meng-update bobot dan biasnya (j = 0,…,p) :

wjk(baru) = wjk(lama) + Δwjk

w0k(baru) = w0k(lama) + Δw0k

Setiap unit hidden (Zj, j = 1,…,p)

o meng-update bobot dan biasnya (i = 0,…,n) :

vij(baru) = vij(lama) + Δvij

v0j(baru) = v0j(lama) + Δv0j

Step 9 : Kondisi stopping ( Toleransi error )

Beberapa faktor yang mempengaruhi keberhasilan algoritme propagasi balik, antara lain:

1. Inisialisasi bobot

Bobot awal menentukan apakah jaringan akan mencapai global minima atau local minima kesalahan, dan seberapa cepat jaringan akan konvergen. Inisialisasi acak merupakan cara yang paling sering digunakan dalam inisialisasi bobot. Untuk mempercepat proses pelatihan, suatu modifikasi dari inisialisasi acak diperkenalkan oleh Nguyen dan Widrow.

a. Metode Inisialisasi Acak:

Prosedur yang umum adalah menginisialisasi bobot (dan bias) ke acak nilai antara -0,5 dan 0,5 (atau antara -1 dan 1 atau beberapa lainnya yang sesuai selang).

b. Metode Inisialisasi Nguyen Widrom :

Menentukan faktor skala :

β : faktor skala

n

: jumlah unit input

p

: jumlah unit hidden

Algoritma Inisialisasi Nguyen Widrom:

Untuk setiap unit hidden (j=1,

, p) :

• Inisialisasi bobot secara random

vij = bilangan acak antara -0.5 sampai 0.5

secara random vij = bilangan acak antara -0.5 sampai 0.5 • Hitung : • Update bobot

• Hitung :

• Update bobot vij =

• Set bias v0j : bilangan acak antara - β sampai β

2. Laju pembelajaran

Merupakan parameter jaringan dalam mengendalikan proses penyesuaian bobot. Nilai laju pembelajaran yang optimal bergantung pada kasus yang dihadapi. Laju pembelajaran yang terlalu kecil menyebabkan konvergensi jaringan menjadi lebih lambat, sedang laju pembelajaran yang terlalu besar dapat menyebabkan ketidakstabilan pada jaringan.

3. Momentum

Momentum digunakan untuk mempercepat pelatihan jaringan. Metode momentum melibatkan penyesuaian bobot ditambah dengan faktor tertentu dari penyesuaian sebelumnya. Penyesuaian ini dinyatakan sebagai berikut

sebelumnya. Penyesuaian ini dinyatakan sebagai berikut di mana parameter momentum miu dibatasi berada dalam kisaran

di mana parameter momentum miu dibatasi berada dalam kisaran dari 0 hingga 1, eksklusif dari titik akhir.

2. CARA KERJA

Pada pembuatan model terdapat beberapa tahap dengan penjelasan singkat, diantaranya :

NN ID (Plant) Menggunakan NN sebagai metode untuk memodelkan suatu plan berdasar karakteristik input dan outputnya. Output bisa dipengeruhi oleh output sebelumnya, maka digunakan delay, yaitu berupa keluaran sebelumnya. Delay digunakan untuk memperbanyak variable tidak linear.

Mode pembelajaran, error akan digunakan untuk merubah bobot dan bias (backpropagation).

Mode pengujian, tidak ada penyesuaian bobot/bias dan output NN akan di komparasi dengan data sebenarnya dan dirata2 untuk mencari MSE (mean square error).

NN INV (Control) Menggunakan NN sebagai metode untuk memodelkan suatu pengendali atau inverter pada plan berdasarkan karakteristik input dan outputnya. Berkebalikan dengan NN ID, input NN berupa output dari plan begitu juga sebaliknya pada output NN yaitu berupa input plan. Data input di delay karena output pertama belum ada saat input pertama dimasukkan ke plan.

Mode Pembelajaran, output NN di bandingkan dengan input plan sebelumnya, nilai error untuk merubah bobot dan bias.

Mode Pengujian, tidak merubah bobot dan nilai langsung dibandingkan dan dirata2 untuk mencari MSE.

NN Direct (Non Feedback) Menggabungkan kedua NN untuk membuat suatu permodelan dari pengendalian pada plan. Tidak menggunakan feedback dari output NN melainkan menggunakan data saja.

Pengujian langsung menggunakan output dari NN INV untuk menjadi masukan NN ID kemudian output NN ID dibandingkan dengan input NN INV.

NN Open Loop (Feedback) Menggabungkan kedua NN untuk membuat suatu permodelan dari pengendalian pada plan. Dengan menggunakan feedback dari output masing-masing NN. Pada program, pembelajaran plan dapat digunakan dari hasil pembelajaran masing-masing NN yaitu nilai bobot dan biasnya (inisialisasi tidak nguyen-widrow, random atau nol) Mode Pengujian input berupa data r(k) yaitu reference value berupa output dari data. dan menghasilkan output u(k) (estimasi input data) kemudian menjadi input untuk selanjutnya dengan output y(k+1) (estimasi output data setelahnya) kemudian di komparasi dari input data reference (input data)

NN Open Loop dengan Fine Tuning Seperti open loop namun dengan tambahan Menggunakan NN pengendali tambahan untuk merubah bobot dan bias keduanya sebagai tuner. Mode pembelajaran yaitu dengan menggunakan kembali output open loop sebagai input kemudian output berupa data input dari plan yang dibandingkan dengan input pada plan dari NN ID, Nilai error kemudian digunakan untuk merubah nilai bobot dan bias untuk kedua pengendali.

Pelaksanaan

Tahapan pertama untuk melakukan pengendalian adalah membuat neural network untuk pengganti plant yang akan dikendalikan yaitu dengan meniru karakteristik output dari input sebuah plant. Untuk melakukan pembelajaran maka dibutuhkan input dan output suatu plant. Neural ini kemudan akan disebut sebagai Neural Network Identifier (NN ID). Berikut ini adalah bagan dari pembelajaran untuk mereplikasi sebuah plant dengan neural network.

(b) (a) (c) Gambar 2. (a)Bagan cara kerja Neural Network Identifier (NN ID) (b) Diagram
(b) (a) (c) Gambar 2. (a)Bagan cara kerja Neural Network Identifier (NN ID) (b) Diagram

(b)

(a)

(b) (a) (c) Gambar 2. (a)Bagan cara kerja Neural Network Identifier (NN ID) (b) Diagram blok

(c)

Gambar 2. (a)Bagan cara kerja Neural Network Identifier (NN ID) (b) Diagram blok saat Testing (c) Diagram blok saat Training

Input yang digunakan pada neural network adalah input yang digunakan pada plant yang kemudian

hasilnya akan dibandingkan dengan output pada plant. Error yang dihasilkan pada perbandingan

ini kemudian akan digunakan untuk merubah nilai bobot dan bias pada neural network model.

Pada skema pengujian, tidak ada proses penrubahaan nilai bobot dan bias (backpropagation)

sehingga nilai error akan aktual sesuai data yang ada apakah model sudah mirip seperti plant atau

tidak.

Kebalikan dengan neural network untuk pengganti pengendali, neural network kendali atau

inverter menggunakan output pada plant input kendali neural untuk pengganti pengendali plant

menggunakan output pada plant dan keluarannya merupakan input pada plant dengan memberikan

delay agar sesuai dengan keadaan plant sebenarnya.

(a) (b) (c) Gambar 3. (a) Bagan cara kerja neural network kendali/inverter (NN INV) (b)

(a)

(a) (b) (c) Gambar 3. (a) Bagan cara kerja neural network kendali/inverter (NN INV) (b) Diagram

(b)

(a) (b) (c) Gambar 3. (a) Bagan cara kerja neural network kendali/inverter (NN INV) (b) Diagram

(c)

Gambar 3. (a) Bagan cara kerja neural network kendali/inverter (NN INV) (b) Diagram blok saat Pelatihan (c) Diagram blok saat Pengujian.

Untuk menguji sistem yang sudah dimodelkan dengan neural netwirk baik itu neural network identifier sebagai pengganti plant dan neural network inverter sebagai pengganti pengendali maka dapat digabungkan seperti berikut agar terlihat seberapa besar error yang dihasilkan dari model.

terlihat seberapa besar error yang dihasilkan dari model. Gambar 4. Diagram Blok Pengujian Model Penggendali (INV)

Gambar 4. Diagram Blok Pengujian Model Penggendali (INV) dan Plant (ID) dengan neural network (NN DIC) open loop tanpa feedback

Gambar 5. Diagram Blok Pengujian Model Penggendali (INV) dan Plant (ID) dengan neural network (NN

Gambar 5. Diagram Blok Pengujian Model Penggendali (INV) dan Plant (ID) dengan neural network (NN DIC) open loop dengan feedback

Input berupa output referensi (data dari plant) sebagai input daru neural network kendali (inverted) kemudian output akan digunakan kembali sebagai input neural network model (identifier)

Pada fine tuning data yang dihasilkan dari openloop dengan feedback kemudian dibandingkan dengan data sebenernya dari plan untuk menentukan error suatu model yang kemudian akan digunakan untuk merubah bobot dan bias dari model neural network tersebut untuk mengurangi nilai error yang akan datang. Model ini kemudian diuji dengan metode yang sama sebelumnya yaitu direct open loop dengan feedback.

yang sama sebelumnya yaitu direct open loop dengan feedback. Gambar 5. Diagram Blok Fine Tuning Model

Gambar 5. Diagram Blok Fine Tuning Model Penggendali (INV) dan Plant (ID) dengan tambahan Pengendali sebagai tuner

3. HASIL

Berdasarkan program Backpropagation Neural Network yang telah dibuat, maka dilakukan training dan testing dengan merubah sebuah variabelnya. Pada percobaan ini variabel yang diubah adalah variabel epoch dan jumlah delay input untuk mengetahui pengaruh perubahan variabel tersebut terhadap training maupun testing, sehingga menghasilkan data sebagai berikut.

a.

Variable

No

Variabel

Value

1

Alpha

0.7

2

Miu (η)

0.4

3

Hidden

12

4

Jumlah Data Learning

5000

5

Jumlah Data Testing

5000

6

Delay Input

4

7

Delay Output

2

8

Max Epoch

200

1. NN ID

Learning Input Parameter

X_Data = xlsread('PPR.xlsx','A1:A5000');

T_Data = xlsread('PPR.xlsx’,’B1:B5000');

alpha = 0.7; miu = 0.4; m_in = 4; n_in = 2; hidden = 2*(m_in+n_in);
alpha = 0.7;
miu = 0.4;
m_in = 4;
n_in = 2;
hidden = 2*(m_in+n_in);

max_epoch = 200;

Learning Input Command

Dengan menjalankan tahap pembelajaran maka akan menghasilkan :

menjalankan tahap pembelajaran maka akan menghasilkan : Selanjutnya pengujian model, Testing Input Command

Selanjutnya pengujian model,

Testing Input Command

NN_IDtest(hidden,m_in,n_in,X_data,T_data)

maka dihasilkan :

Testing Input Command NN_IDtest(hidden,m_in,n_in,X_data,T_data) maka dihasilkan : Error Training terkecil = 1.1521e-04

2.

NN INV

Menggunakan parameter input sebelumnya

Learn Input Command

NN_INV(hidden,epoch,alpha,miu,m_in,n_in, Y_data,T_data)

Testing Input Command

NN_INVtest(hidden,m_in,n_in,Y_data,T_data)

maka dihasilkan :

NN_INVtest(hidden,m_in,n_in,Y_data,T_data) maka dihasilkan : Error terkecil = 0.0019 3. NN Direct (No Feedback)

Error terkecil = 0.0019

3. NN Direct (No Feedback)

Menggunakan parameter input dengan menentukan nilai target dan testing penulis mengambil rasio 1:1 antara jumlah data learning dan data testing, dan menggunakan bobot dan bias NN ID dan NN INV yang sudah didapat sebelumnnya

Input Parameter

targetX = xlsread('PPR.xlsx','A1:A2500');

testX = xlsread('PPR.xlsx','A2501:A5000');

testY = xlsread('PPR.xlsx','B2501:B5000');

targetY = xlsread('PPR.xlsx','B1:B2500’);

Input Command

NN_INV(hidden,epoch,alpha,miu,m_in,n_in,targetY,targetX)

NN_INVtest(hidden,m_in,n_in,testY,testX)

NN_ID(hidden,epoch,alpha,miu,m_in,n_in,targetX,targetY)

NN_Direct(hidden,m_in,n_in,testY)

Maka dihasilkan hasil sbb :

Maka dihasilkan hasil sbb : Error Training terkecil = 0.0043 4. NN Direct Openloop

Error Training terkecil = 0.0043

4. NN Direct Openloop dengan Feedback Menggunakan parameter yang sama dengan sebelumnya

Input Command

NN_INV(hidden,epoch,alpha,miu,m_in,n_in,targetY,targetX)

NN_INV_FB(hidden,m_in,n_in,testY,testX)

NN_ID(hidden,epoch,alpha,miu,m_in,n_in,targetX,targetY)

NN_DirectFB(hidden,m_in,n_in,testY)

Maka dihasilkan sbb :

NN_DirectFB(hidden,m_in,n_in,testY) Maka dihasilkan sbb : Error Training terkecil = 0.0064 5. NN Openloop dengan Fine

Error Training terkecil = 0.0064

5. NN Openloop dengan Fine Tuning

Pada fine tuning maka seluruh tahapan diatas akan digunakan kembali

Input Command

NN_ID(hidden,epoch,alpha,miu,m_in,n_in,targetX,targetY)

NN_ID_FT(hidden,m_in,n_in,targetY)

load('output_inv_testFB.mat')

load('output_ID_FT.mat')

NN_INV_FT2(hidden,epoch,alpha,miu,m_in,n_in,output_ID_FT(m_in:

end,1),output_inv_testFB((m_in+m_in-1):end,1))

load('output_ft2.mat')

NN_INV_FT1(hidden,epoch,alpha,miu,m_in,n_in,targetY((m_in+m_in

-1):end,1),output_ft2)

NN_INV_FTtest(hidden,m_in,n_in,testY,testX)

NN_DirectFT(hidden,m_in,n_in,testY)

Maka dihasilkan sbb:

NN_DirectFT(hidden,m_in,n_in,testY) Maka dihasilkan sbb: Error Training terkecil = 0.0038 Maka untuk memudahkan

Error Training terkecil = 0.0038

Maka untuk memudahkan perhatikan table di bawah ini :

b. Pengujian Pengaruh Delay pada NN DIC No Variabel Value 1 Alpha 0.8 2 Miu
b. Pengujian Pengaruh Delay pada NN DIC No Variabel Value 1 Alpha 0.8 2 Miu

b. Pengujian Pengaruh Delay pada NN DIC

No

Variabel

Value

1

Alpha

0.8

2

Miu (η)

0.7

3

Hidden

10

4

Jumlah Data Input

5000

5

Jumlah Data Output

5000

Case 1 : Pengujian 100 epoch dengan delay input sebesar 2 kali (x-2)

Input 5000 5 Jumlah Data Output 5000 Case 1 : Pengujian 100 epoch dengan delay input

Gambar Grafik nilai Error dengan nilai Error terkecil = 3.0950e-04

Case 2 : Pengujian 50 epoch dengan delay input sebesar 2 kali (x-2)

: Pengujian 50 epoch dengan delay input sebesar 2 kali (x-2) Gambar Grafik nilai Error dengan

Gambar Grafik nilai Error dengan nilai Error terkecil = 3.1459e-04

Dengan perubahan pada jumlah epoch nilai error pembelajaran bertambah. Yaitu dari sebesari 3.0950e-04 menjadi 3.1459e-04

Case 3 : Pengujian 100 epoch dengan delay input sebesar 4 kali (x-2)

Gambar Grafik nilai Error dengan nilai Error terkecil = 9.9442e-05 Dengan perubahan pada jumlah delay

Gambar Grafik nilai Error dengan nilai Error terkecil = 9.9442e-05

Dengan perubahan pada jumlah delay nilai error pembelajaran berkurang secara signifikan. Yaitu dari sebesari 3.0950e-04 menjadi 9.9442e-05

Pengujian model neural network dengan 2 keadaan yaitu .

Pengujian model neural network dengan 2 keadaan yaitu . Gambar Grafik perbandingan nilai output dengan nilai

Gambar Grafik perbandingan nilai output dengan nilai hasil model neural network dengan 2 kali delay input dengan nilai Error = 0.0016

Gambar Grafik perbandingan nilai output dengan nilai hasil model neural network dengan 4 kali delay

Gambar Grafik perbandingan nilai output dengan nilai hasil model neural network dengan 4 kali delay input dengan nilai Error = 7.5166e-04

Nilai error yang dihasilkan dengan angka sebenarnya menunjukkan hasil yang signifikan terlihat dari hasil pengujian dengan jumlah delay yang lebih banyak yaitu 4 akan menghasilkan error sebesar 7.5166e-04 dibandingkan dengan hanya 2 delay input dengan menghasilkan error sebesar

0.0016

4. KESIMPULAN

Berdasarkan hasil Pembelajaran dan Pengujian dengan merubah variable jumlah epoch dan delay iput. Perubahan yang diakibatkan pada perubahan nilai epoch yaitu dari sebesar 100 menjadi hanya 50 mengakibatkan kenaikan jumlah error pembelajaran dari sebesar 3.0950e-04 menjadi 3.1459e-04, diakibatkan masa pembelajaran yang tidak banyak sehingga tidak cukup efisien dalam mengurangi error. Pada perubahan jumlah delay input, dengan perubahan dari 2 input delay menjadi 4 input delay maka pengaruh signifikan dihasilkan pada pengurangan error yaitu 3.0950e-04 menjadi 9.9442e-05. Diakibatkan banyak variable yang merubah ketidak linearitasan suatu karakteristik pada model neural network sebagai pengganti dari plan sebenarnya. Pada Pengujian jumlah error yang dihasilkan dengan jumlah variable delay yang lebih banyak juga menghasilkan jumlah error yang lebih sedikit pada prediksi output pada plant yaitu 7.5166e-04 dibandingkan dengan hanya 2 delay input dengan menghasilkan error sebesar 0.0016. sehinggan meningkatkan nilai delay input dapat menekan error lebih efesien.

Berdasarkan hasil metode pengujian model Metode NN terbaik untuk menyerupai suatu sistem kendali suatu plan adalah Open Loop dengan Fine tuning dengan nilai error terkecil. Menambahkan Delay tidak selalu menghasilkan error yang lebih kecil, untuk beberapa sistem yang sederhana terlalu banyak delay input akan menyebabkan terlalu banyak titik menyebabkan error ketidaklinearan semakin besar.

LAMPIRAN PROGRAM

1. NN ID

function NN_ID(hidden,max_epoch,alpha,miu,m_in,n_in,X_data,T_data) disp('NN_ID')

epoch=1;

stopping = 0; req_error = 0.00001; time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %X_data = xlsread(filename,'A:A'); %T_data = xlsread(filename,'B:B');

%Normalisasi Input input_norm(:,1) = (((X_data(:,1)-min(X_data(:,1)))*(max_new -

min_new))/(max(X_data(:,1))-min(X_data(:,1))))+min_new;

X_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_xdata,col_xdata] = size(X_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_xdata+m_in-i,i) = X_data;

end

if (i==m_in)

input_data(1:row_xdata,i) = X_data;

end

end

if(n_in>0)

for i=1:n_in input_target(1:n_in+1-i,i) = zeros; input_target(n_in+2-i:row_tdata+n_in+1-i,i) = T_data;

end input =

[input_data(1:row_xdata,1:m_in),input_target(1:row_xdata,1:n_in)];

end if(n_in == 0) input = input_data(1:row_xdata,1:m_in);

end target = T_data;

%INISIALISASI [row_in,col_in] = size(input); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Untuk momentum deltaWjk_old = zeros(hidden,col_t); deltaVij_old = zeros(col_in,hidden);

%NGUYEN WIDROW beta = 0.7*(hidden)^(1/col_in); %hidden = jumlah unit hidden %col_in = jumlah unit input

%inisialisasi bobot Vij = rand(col_in,hidden)-0.5; Wjk = rand(hidden,col_t)-0.5;

%Summing Sigma Vj_mag = sqrt(sum(Vij.^2)); Wk_mag = sqrt(sum(Wjk.^2));

%Update Bobot for i=1:col_in Vij(i,:) = beta*Vij(i,:)./Vj_mag;

end for j=1:hidden Wjk(j,:) = beta*Wjk(j,:)./Wk_mag;

end

%Bias V0j = (beta-(-beta)).*rand(1,hidden) - beta; W0k = (beta-(-beta)).*rand(1,col_t) - beta;

if(m_in > (n_in+1)) start = m_in elseif(m_in <= (n_in+1)) start = n_in+1

end

%Step 1 while stopping == 0 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j + X(n,:)*Vij; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k + Zj*Wjk; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink))); output(n,epoch) = Yk;

%BACKPROPAGATION %Step 6 %Menghitung informasi error do_k = (T(n,:)-Yk).*(2*(exp(-Y_ink))./((1+exp(-Y_ink)).^2)); %Menghitung besarnya koreksi bobot unit output deltaWjk = alpha*Zj'*do_k;%Zj ditranspose 1Xhidden -> hiddenX1 * do_k(1Xoutput) = hiddenXoutput = ukuran matrix Wjk %Menghitung besarnya koreksi bias output deltaW0k = alpha*do_k;%deltaW0k = matrix 1Xoutput = ukuran matrix W0k

%Step 7 %Menghitung semua koreksi error do_inj = do_k*Wjk'; %Menghitung nilai aktivasi koreksi error do_j = do_inj.*(2*(exp(-Z_inj))./((1+exp(-Z_inj)).^2)); %Menghitung koreksi bobot unit hidden deltaVij = alpha*X(n,:)'*do_j; %Menghitung kroeksi error bias unit hidden deltaV0j = alpha*do_j;

%Step 8 %Mengupdate bobot dan bias hidden->output Wjk_new = Wjk + deltaWjk + (miu*deltaWjk_old); W0k_new = W0k + deltaW0k; %Mengupdate bobot dan bias input->hidden Vij_new = Vij + deltaVij + (miu*deltaVij_old); V0j_new = V0j + deltaV0j; %Untuk momentum

deltaWjk_old = deltaWjk; deltaVij_old = deltaVij;

Wjk = Wjk_new; W0k = W0k_new; Vij = Vij_new; V0j = V0j_new; %Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err(1,epoch) = sum(E(1,start:n))/(n-start+1); if(epoch == max_epoch || Err(1,epoch) < req_error) stopping = 1;

end epoch = epoch + 1;

end

V0j;

Vij;

W0k;

Wjk; figure('Name','NN_ID Error') plot(Err) disp('alpha =') disp(alpha) disp('Epoch =')

disp(epoch-1)

disp('Error terakhir =')

disp(Err(epoch-1))

disp('Error terkecil =') disp(min(Err)) save('bobot_mom.mat','Vij','Wjk')

save('bias_mom.mat','V0j','W0k')

save('input_nilai.mat','input')

save('output_nilai.mat','output')

end

2. NN INV

function NN_INV(hidden,max_epoch,alpha,miu,m_in,n_in,Y_data,T_data) disp('NN_INV')

epoch=1;

stopping = 0; req_error = 0.00001; time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %T_data = xlsread(filename,'A:A'); %Y_data = xlsread(filename,'B:B');

%Normalisasi Input input_norm(:,1) = (((Y_data(:,1)-min(Y_data(:,1)))*(max_new -

min_new))/(max(Y_data(:,1))-min(Y_data(:,1))))+min_new;

Y_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_ydata,col_ydata] = size(Y_data); [row_tdata,col_tdata] = size(T_data); target_data(1:1,1) = zeros; target_data(2:row_tdata+1,1) = T_data; T_data = target_data; [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_ydata+m_in-i,i) = Y_data;

end if (i==m_in) input_data(1:row_ydata,i) = Y_data;

end

end

if(n_in>0)

for i=1:n_in input_target(1:n_in+1-i,i) = zeros; input_target(n_in+2-i:row_tdata+n_in+1-i,i) = T_data;

end input_inv =

[input_data(1:row_ydata,1:m_in),input_target(1:row_ydata,1:n_in)];

end if(n_in == 0) input_inv = input_data(1:row_ydata,1:m_in);

end target = T_data;

%INISIALISASI [row_in,col_in] = size(input_inv); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Untuk momentum deltaWjk_inv_old = zeros(hidden,col_t); deltaVij_inv_old = zeros(col_in,hidden);

%NGUYEN WIDROW beta = 0.7*(hidden)^(1/col_in); %hidden = jumlah unit hidden %col_in = jumlah unit input

%inisialisasi bobot Vij_inv = rand(col_in,hidden)-0.5; Wjk_inv = rand(hidden,col_t)-0.5;

%Summing Sigma Vj_mag = sqrt(sum(Vij_inv.^2)); Wk_mag = sqrt(sum(Wjk_inv.^2));

%Update Bobot for i=1:col_in Vij_inv(i,:) = beta*Vij_inv(i,:)./Vj_mag;

end for j=1:hidden Wjk_inv(j,:) = beta*Wjk_inv(j,:)./Wk_mag;

end

%Bias V0j_inv = (beta-(-beta)).*rand(1,hidden) - beta; W0k_inv = (beta-(-beta)).*rand(1,col_t) - beta;

if(m_in > (n_in+1)) start = m_in elseif(m_in <= (n_in+2)) start = n_in+2 elseif(m_in == 1 && n_in == 0) start = 2

end

%Step 1 while stopping == 0 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3

X(n,:) = input_inv(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j_inv + X(n,:)*Vij_inv; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k_inv + Zj*Wjk_inv; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink))); output_inv(n,epoch) = Yk;

%BACKPROPAGATION %Step 6 %Menghitung informasi error do_k = (T(n,:)-Yk).*(2*(exp(-Y_ink))./((1+exp(-Y_ink)).^2)); %Menghitung besarnya koreksi bobot unit output deltaWjk_inv = alpha*Zj'*do_k;%Zj ditranspose 1Xhidden -> hiddenX1 * do_k(1Xoutput) = hiddenXoutput = ukuran matrix Wjk_inv %Menghitung besarnya koreksi bias output deltaW0k_inv = alpha*do_k;%deltaW0k_inv = matrix 1Xoutput = ukuran matrix W0k_inv

%Step 7 %Menghitung semua koreksi error do_inj = do_k*Wjk_inv'; %Menghitung nilai aktivasi koreksi error do_j = do_inj.*(2*(exp(-Z_inj))./((1+exp(-Z_inj)).^2)); %Menghitung koreksi bobot unit hidden deltaVij_inv = alpha*X(n,:)'*do_j; %Menghitung kroeksi error bias unit hidden

deltaV0j_inv = alpha*do_j;

%Step 8 %Mengupdate bobot dan bias hidden->output Wjk_inv_new = Wjk_inv + deltaWjk_inv + (miu*deltaWjk_inv_old); W0k_inv_new = W0k_inv + deltaW0k_inv; %Mengupdate bobot dan bias input->hidden Vij_inv_new = Vij_inv + deltaVij_inv + (miu*deltaVij_inv_old); V0j_inv_new = V0j_inv + deltaV0j_inv; %Untuk momentum deltaWjk_inv_old = deltaWjk_inv; deltaVij_inv_old = deltaVij_inv;

Wjk_inv = Wjk_inv_new; W0k_inv = W0k_inv_new; Vij_inv = Vij_inv_new; V0j_inv = V0j_inv_new; %Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err(1,epoch) = sum(E(1,start:n))/(n-start+1); if(epoch == max_epoch || Err(1,epoch) < req_error) stopping = 1;

end epoch = epoch + 1;

end

V0j_inv;

Vij_inv;

W0k_inv;

Wjk_inv; figure('Name','NN_INV Error') plot(Err) disp('alpha =')

disp(alpha) disp('Epoch =')

disp(epoch-1)

disp('Error terakhir =')

disp(Err(epoch-1))

disp('Error terkecil =') disp(min(Err)) save('bobot_inv.mat','Vij_inv','Wjk_inv')

save('bias_inv.mat','V0j_inv','W0k_inv')

save('input_inv.mat','input_inv')

save('output_inv.mat','output_inv')

end

3. NN IDtest

function NN_IDtest(hidden,m_in,n_in,X_data,T_data) disp('NN_IDtest') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %X_data = xlsread(filename,'A:A'); %T_data = xlsread(filename,'B:B'); load('bobot_mom.mat','Vij'); load('bobot_mom.mat','Wjk');

load('bias_mom.mat','V0j');

load('bias_mom.mat','W0k');

%Normalisasi Input input_norm(:,1) = (((X_data(:,1)-min(X_data(:,1)))*(max_new -

min_new))/(max(X_data(:,1))-min(X_data(:,1))))+min_new;

X_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_xdata,col_xdata] = size(X_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_xdata+m_in-i,i) = X_data;

end if (i==m_in) input_data(1:row_xdata,i) = X_data;

end

end

if(n_in>0)

for i=1:n_in input_target(1:n_in+1-i,i) = zeros; input_target(n_in+2-i:row_tdata+n_in+1-i,i) = T_data;

end input =

[input_data(1:row_xdata,1:m_in),input_target(1:row_xdata,1:n_in)];

end if(n_in == 0) input = input_data(1:row_xdata,1:m_in);

end target = T_data;

if(m_in > (n_in+1)) start = m_in elseif(m_in <= (n_in+1)) start = n_in+1

end

%INISIALISASI [row_in,col_in] = size(input); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Step 1 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j + X(n,:)*Vij; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k + Zj*Wjk; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink))); output(n,1) = Yk;

%Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_test = output; figure('Name','NN_IDtest')

subplot(2,1,1)

plot(output(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E')

title('Error')

save('output_test.mat','output_test')

4. NN INV test

function NN_INVtest(hidden,m_in,n_in,Y_data,T_data) disp('NN_INVtest') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %T_data = xlsread(filename,'A:A'); %Y_data = xlsread(filename,'B:B'); load('bobot_inv.mat','Vij_inv'); load('bobot_inv.mat','Wjk_inv');

load('bias_inv.mat','V0j_inv');

load('bias_inv.mat','W0k_inv');

%Normalisasi Input input_norm(:,1) = (((Y_data(:,1)-min(Y_data(:,1)))*(max_new -

min_new))/(max(Y_data(:,1))-min(Y_data(:,1))))+min_new;

Y_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_ydata,col_ydata] = size(Y_data); [row_tdata,col_tdata] = size(T_data); target_data(1:1,1) = zeros; target_data(2:row_tdata+1,1) = T_data; T_data = target_data; [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_ydata+m_in-i,i) = Y_data;

end

if (i==m_in) input_data(1:row_ydata,i) = Y_data;

end

end

if(n_in>0)

for i=1:n_in input_target(1:n_in+1-i,i) = zeros; input_target(n_in+2-i:row_tdata+n_in+1-i,i) = T_data;

end input_inv =

[input_data(1:row_ydata,1:m_in),input_target(1:row_ydata,1:n_in)];

end if(n_in == 0) input_inv = input_data(1:row_ydata,1:m_in);

end target = T_data;

%INISIALISASI [row_in,col_in] = size(input_inv); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

if(m_in > (n_in+1)) start = m_in elseif(m_in <= (n_in+2)) start = n_in+2 elseif(m_in == 1 && n_in == 0) start = 2

end

%Step 1 n = start; E(1,n) = 0; for n=start:row_in

%FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input_inv(n,:); T(n,:) = target(n,:); %Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j_inv + X(n,:)*Vij_inv; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj))); %Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k_inv + Zj*Wjk_inv; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink))); output_inv(n,1) = Yk;

%Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_inv_test = [output_inv,E']; figure('Name','NN_INVtest')

subplot(2,1,1)

plot(output_inv(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E') title('Error') save('output_inv_test.mat','output_inv_test') input_idtest(1:row_in-start+1,1) = output_inv_test(start:row_in,1); save('input_idtest.mat','input_idtest') save('input_inv.mat','input_inv') end

5. NN Direct

function NN_Direct(hidden,m_in,n_in,T_data) disp('NN_Direct') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

load('input_idtest.mat','input_idtest'); %filename = 'PPR.xlsx'; X_data = input_idtest; %T_data = xlsread(filename,'B:B'); load('bobot_mom.mat','Vij'); load('bobot_mom.mat','Wjk');

load('bias_mom.mat','V0j');

load('bias_mom.mat','W0k');

%Normalisasi Input %input_norm(:,1) = (((X_data(:,1)-min(X_data(:,1)))*(max_new -

min_new))/(max(X_data(:,1))-min(X_data(:,1))))+min_new;

%X_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_xdata,col_xdata] = size(X_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_xdata+m_in-i,i) = X_data;

end if (i==m_in) input_data(1:row_xdata,i) = X_data;

end

end

if(n_in>0)

for i=1:n_in input_target(1:n_in+1-i,i) = zeros; input_target(n_in+2-i:row_tdata+n_in+1-i,i) = T_data;

end input_direct =

[input_data(1:row_xdata,1:m_in),input_target(1:row_xdata,1:n_in)];

end if(n_in == 0) input_direct = input_data(1:row_xdata,1:m_in);

end target = T_data;

if(m_in > (n_in+1)) start = m_in elseif(m_in <= (n_in+1)) start = n_in+1

end

%INISIALISASI [row_in,col_in] = size(input_direct); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Step 1 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input_direct(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j + X(n,:)*Vij; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k + Zj*Wjk; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink))); output(n,1) = Yk;

%Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_direct = [output,E']; figure('Name','NN_INV_Direct')

subplot(2,1,1)

plot(output(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E')

title('Error')

save('output_direct.mat','output_direct')

save('input_direct.mat','input_direct')

6. NN Direct FeedBack

function NN_DirectFB(hidden,m_in,n_in,T_data) disp('NN_DirectFB') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

load('input_idtestFB.mat','input_idtestFB'); %filename = 'PPR.xlsx'; X_data = input_idtestFB; %T_data = xlsread(filename,'B:B'); load('bobot_mom.mat','Vij'); load('bobot_mom.mat','Wjk');

load('bias_mom.mat','V0j');

load('bias_mom.mat','W0k');

%Normalisasi Input %input_norm(:,1) = (((X_data(:,1)-min(X_data(:,1)))*(max_new -

min_new))/(max(X_data(:,1))-min(X_data(:,1))))+min_new;

%X_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_xdata,col_xdata] = size(X_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_xdata+m_in-i,i) = X_data;

end if (i==m_in) input_data(1:row_xdata,i) = X_data;

end

end

if(n_in>0)

input_feedback(1:row_xdata,i) = zeros; input_directFB =

[input_data(1:row_xdata,1:m_in),input_feedback(1:row_xdata,1:n_in)];

end if(n_in == 0) input_directFB = input_data(1:row_xdata,1:m_in);

end target = T_data;

start = m_in

%INISIALISASI [row_in,col_in] = size(input_directFB); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Step 1 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input_directFB(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j + X(n,:)*Vij; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k + Zj*Wjk; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink)));

if(n_in>0)

for i=1:n_in input_directFB(n+i,m_in+n_in+1-i) = Yk; end

end output(n,1) = Yk; %Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_directFB = output; figure('Name','NN_DirectFB')

subplot(2,1,1)

plot(output(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E')

title('Error')

save('output_directFB.mat','output_directFB')

7. NN ID FT

function NN_ID_FT(hidden,m_in,n_in,T_data) disp('NN_ID_FT') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %X_data = xlsread(filename,'A:A'); %T_data = xlsread(filename,'B:B'); load('bobot_mom.mat','Vij'); load('bobot_mom.mat','Wjk');

load('bias_mom.mat','V0j');

load('bias_mom.mat','W0k');

load('input_idtestFB.mat','input_idtestFB'); %filename = 'PPR.xlsx'; X_data = input_idtestFB; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_xdata,col_xdata] = size(X_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_xdata+m_in-i,i) = X_data;

end if (i==m_in) input_data(1:row_xdata,i) = X_data;

end

end

if(n_in>0)

for i=1:n_in input_target(1:n_in+1-i,i) = zeros; input_target(n_in+2-i:row_tdata+n_in+1-i,i) = T_data;

end input =

[input_data(1:row_xdata,1:m_in),input_target(1:row_xdata,1:n_in)];

end if(n_in == 0) input = input_data(1:row_xdata,1:m_in);

end target = T_data;

if(m_in > (n_in+1)) start = m_in elseif(m_in <= (n_in+1)) start = n_in+1

end

%INISIALISASI [row_in,col_in] = size(input); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Step 1 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j + X(n,:)*Vij; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k + Zj*Wjk; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink))); output(n,1) = Yk;

%Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_ID_FT = output; figure('Name','NN_ID_FT')

subplot(2,1,1)

plot(output(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E')

title('Error')

save('output_ID_FT.mat','output_ID_FT')

8. NN INV FT1

function NN_INV_FT1(hidden,max_epoch,alpha,miu,m_in,n_in,Y_data,T_data)

disp('NN_INV_FT1')

epoch=1;

stopping = 0; req_error = 0.00001; time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %T_data = xlsread(filename,'A:A'); %Y_data = xlsread(filename,'B:B'); load('bobot_inv.mat','Vij_inv'); load('bobot_inv.mat','Wjk_inv');

load('bias_inv.mat','V0j_inv');

load('bias_inv.mat','W0k_inv');

Wjk_inv_ft1 = Wjk_inv; W0k_inv_ft1 = W0k_inv; Vij_inv_ft1 = Vij_inv; V0j_inv_ft1 = V0j_inv;

%Normalisasi Input input_norm(:,1) = (((Y_data(:,1)-min(Y_data(:,1)))*(max_new -

min_new))/(max(Y_data(:,1))-min(Y_data(:,1))))+min_new;

Y_data = input_norm; %Normalisasi Target %target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

%T_data = target_norm;

%Membuat matrix baru [row_ydata,col_ydata] = size(Y_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in)

input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_ydata+m_in-i,i) = Y_data;

end if (i==m_in) input_data(1:row_ydata,i) = Y_data;

end

end

if(n_in>0)

input_feedback(1:row_ydata,i) = zeros; input_inv_ft1 =

[input_data(1:row_ydata,1:m_in),input_feedback(1:row_ydata,1:n_in)];

end if(n_in == 0) input_inv_ft1 = input_data(1:row_ydata,1:m_in);

end target = T_data;

%INISIALISASI [row_in,col_in] = size(input_inv_ft1); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Untuk momentum deltaWjk_inv_old = zeros(hidden,col_t); deltaVij_inv_old = zeros(col_in,hidden);

start = m_in

%Step 1 while stopping == 0 n = start; E(1,n) = 0; for n=start:row_t %FEEDFORWARD

%Step 2 : Feedforward %Step 3 X(n,:) = input_inv_ft1(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j_inv_ft1 + X(n,:)*Vij_inv_ft1; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k_inv_ft1 + Zj*Wjk_inv_ft1; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink)));

if(n_in>0)

for i=1:n_in input_inv_ft1(n+i,m_in+n_in+1-i) = Yk; end

end output_inv_ft1(n,epoch) = Yk;

%BACKPROPAGATION %Step 6 %Menghitung informasi error do_k = (T(n,:)-Yk).*(2*(exp(-Y_ink))./((1+exp(-Y_ink)).^2)); %Menghitung besarnya koreksi bobot unit output deltaWjk_inv = alpha*Zj'*do_k;%Zj ditranspose 1Xhidden -> hiddenX1 * do_k(1Xoutput) = hiddenXoutput = ukuran matrix Wjk_inv %Menghitung besarnya koreksi bias output deltaW0k_inv = alpha*do_k;%deltaW0k_inv = matrix 1Xoutput = ukuran matrix W0k_inv

%Step 7 %Menghitung semua koreksi error do_inj = do_k*Wjk_inv_ft1';

%Menghitung nilai aktivasi koreksi error do_j = do_inj.*(2*(exp(-Z_inj))./((1+exp(-Z_inj)).^2)); %Menghitung koreksi bobot unit hidden deltaVij_inv = alpha*X(n,:)'*do_j; %Menghitung kroeksi error bias unit hidden deltaV0j_inv = alpha*do_j;

%Step 8 %Mengupdate bobot dan bias hidden->output Wjk_inv_new = Wjk_inv_ft1 + deltaWjk_inv + (miu*deltaWjk_inv_old); W0k_inv_new = W0k_inv_ft1 + deltaW0k_inv; %Mengupdate bobot dan bias input->hidden Vij_inv_new = Vij_inv_ft1 + deltaVij_inv + (miu*deltaVij_inv_old); V0j_inv_new = V0j_inv_ft1 + deltaV0j_inv; %Untuk momentum deltaWjk_inv_old = deltaWjk_inv; deltaVij_inv_old = deltaVij_inv;

Wjk_inv_ft1 = Wjk_inv_new; W0k_inv_ft1 = W0k_inv_new; Vij_inv_ft1 = Vij_inv_new; V0j_inv_ft1 = V0j_inv_new; %Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err(1,epoch) = sum(E(1,start:n))/(n-start+1); if(epoch == max_epoch || Err(1,epoch) < req_error) stopping = 1;

end epoch = epoch + 1;

end

V0j_inv_ft1;

Vij_inv_ft1;

W0k_inv_ft1;

Wjk_inv_ft1;

figure('Name','NN_INV_FT1 Error') plot(Err)

disp('alpha =') disp(alpha) disp('Epoch =')

disp(epoch-1)

disp('Error terakhir =')

disp(Err(epoch-1))

disp('Error terkecil =') disp(min(Err)) output_ft1 = output_inv_ft1(1:end,epoch-1);

save('bobot_inv_ft1.mat','Vij_inv_ft1','Wjk_inv_ft1')

save('bias_inv_ft1.mat','V0j_inv_ft1','W0k_inv_ft1')

save('input_inv_ft1.mat','input_inv_ft1')

save('output_ft1.mat','output_ft1')

end

9. NN INV FT2

function NN_INV_FT2(hidden,max_epoch,alpha,miu,m_in,n_in,Y_data,T_data)

disp('NN_INV_FT2')

epoch=1;

stopping = 0; req_error = 0.00001; time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %T_data = xlsread(filename,'A:A'); %Y_data = xlsread(filename,'B:B'); load('bobot_inv.mat','Vij_inv'); load('bobot_inv.mat','Wjk_inv');

load('bias_inv.mat','V0j_inv');

load('bias_inv.mat','W0k_inv');

Wjk_inv_ft2 = Wjk_inv; W0k_inv_ft2 = W0k_inv; Vij_inv_ft2 = Vij_inv; V0j_inv_ft2 = V0j_inv;

%Normalisasi Input input_norm(:,1) = (((Y_data(:,1)-min(Y_data(:,1)))*(max_new -

min_new))/(max(Y_data(:,1))-min(Y_data(:,1))))+min_new;

Y_data = input_norm; %Normalisasi Target %target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

%T_data = target_norm;

%Membuat matrix baru [row_ydata,col_ydata] = size(Y_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in)

input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_ydata+m_in-i,i) = Y_data;

end if (i==m_in) input_data(1:row_ydata,i) = Y_data;

end

end

if(n_in>0)

input_feedback(1:row_ydata,i) = zeros; input_inv_ft2 =

[input_data(1:row_ydata,1:m_in),input_feedback(1:row_ydata,1:n_in)];

end if(n_in == 0) input_inv_ft2 = input_data(1:row_ydata,1:m_in);

end target = T_data;

%INISIALISASI [row_in,col_in] = size(input_inv_ft2); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Untuk momentum deltaWjk_inv_old = zeros(hidden,col_t); deltaVij_inv_old = zeros(col_in,hidden);

start = m_in

%Step 1 while stopping == 0 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD

%Step 2 : Feedforward %Step 3 X(n,:) = input_inv_ft2(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j_inv_ft2 + X(n,:)*Vij_inv_ft2; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k_inv_ft2 + Zj*Wjk_inv_ft2; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink)));

if(n_in>0)

for i=1:n_in input_inv_ft2(n+i,m_in+n_in+1-i) = Yk; end

end output_inv_ft2(n,epoch) = Yk;

%BACKPROPAGATION %Step 6 %Menghitung informasi error do_k = (T(n,:)-Yk).*(2*(exp(-Y_ink))./((1+exp(-Y_ink)).^2)); %Menghitung besarnya koreksi bobot unit output deltaWjk_inv = alpha*Zj'*do_k;%Zj ditranspose 1Xhidden -> hiddenX1 * do_k(1Xoutput) = hiddenXoutput = ukuran matrix Wjk_inv %Menghitung besarnya koreksi bias output deltaW0k_inv = alpha*do_k;%deltaW0k_inv = matrix 1Xoutput = ukuran matrix W0k_inv

%Step 7 %Menghitung semua koreksi error do_inj = do_k*Wjk_inv_ft2';

%Menghitung nilai aktivasi koreksi error do_j = do_inj.*(2*(exp(-Z_inj))./((1+exp(-Z_inj)).^2)); %Menghitung koreksi bobot unit hidden deltaVij_inv = alpha*X(n,:)'*do_j; %Menghitung kroeksi error bias unit hidden deltaV0j_inv = alpha*do_j;

%Step 8 %Mengupdate bobot dan bias hidden->output Wjk_inv_new = Wjk_inv_ft2 + deltaWjk_inv + (miu*deltaWjk_inv_old); W0k_inv_new = W0k_inv_ft2 + deltaW0k_inv; %Mengupdate bobot dan bias input->hidden Vij_inv_new = Vij_inv_ft2 + deltaVij_inv + (miu*deltaVij_inv_old); V0j_inv_new = V0j_inv_ft2 + deltaV0j_inv; %Untuk momentum deltaWjk_inv_old = deltaWjk_inv; deltaVij_inv_old = deltaVij_inv;

Wjk_inv_ft2 = Wjk_inv_new; W0k_inv_ft2 = W0k_inv_new; Vij_inv_ft2 = Vij_inv_new; V0j_inv_ft2 = V0j_inv_new; %Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err(1,epoch) = sum(E(1,start:n))/(n-start+1); if(epoch == max_epoch || Err(1,epoch) < req_error) stopping = 1;

end epoch = epoch + 1;

end

V0j_inv_ft2;

Vij_inv_ft2;

W0k_inv_ft2;

Wjk_inv_ft2;

figure('Name','NN_INV_FT2 Error') plot(Err)

disp('alpha =') disp(alpha) disp('Epoch =')

disp(epoch-1)

disp('Error terakhir =')

disp(Err(epoch-1))

disp('Error terkecil =') disp(min(Err)) output_ft2 = output_inv_ft2(1:end,epoch-1);

save('bobot_inv_ft2.mat','Vij_inv_ft2','Wjk_inv_ft2')

save('bias_inv_ft2.mat','V0j_inv_ft2','W0k_inv_ft2')

save('input_inv_ft2.mat','input_inv_ft2')

save('output_ft2.mat','output_ft2')

end

10. NN INV FTtest

function NN_INV_FB(hidden,m_in,n_in,Y_data,T_data) disp('NN_INV_FTtest') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

%filename = 'PPR.xlsx'; %T_data = xlsread(filename,'A:A'); %Y_data = xlsread(filename,'B:B');

load('bobot_inv_ft1.mat','Vij_inv_ft1');

load('bobot_inv_ft1.mat','Wjk_inv_ft1');

load('bias_inv_ft1.mat','V0j_inv_ft1');

load('bias_inv_ft1.mat','W0k_inv_ft1');

Vij_inv = Vij_inv_ft1; Wjk_inv = Wjk_inv_ft1; V0j_inv = V0j_inv_ft1; W0k_inv = W0k_inv_ft1;

%Normalisasi Input input_norm(:,1) = (((Y_data(:,1)-min(Y_data(:,1)))*(max_new -

min_new))/(max(Y_data(:,1))-min(Y_data(:,1))))+min_new;

Y_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_ydata,col_ydata] = size(Y_data); [row_tdata,col_tdata] = size(T_data); target_data(1:1,1) = zeros; target_data(2:row_tdata+1,1) = T_data; T_data = target_data; [row_tdata,col_tdata] = size(T_data);

for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_ydata+m_in-i,i) = Y_data;

end if (i==m_in) input_data(1:row_ydata,i) = Y_data;

end

end

if(n_in>0)

input_feedback(1:row_ydata,i) = zeros; input_inv_FTtest =

[input_data(1:row_ydata,1:m_in),input_feedback(1:row_ydata,1:n_in)];

end if(n_in == 0) input_inv_FTtest = input_data(1:row_ydata,1:m_in);

end target = T_data;

%INISIALISASI [row_in,col_in] = size(input_inv_FTtest); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

start=m_in;

%Step 1 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input_inv_FTtest(n,:);

T(n,:) = target(n,:); %Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j_inv + X(n,:)*Vij_inv; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj))); %Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k_inv + Zj*Wjk_inv; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink)));

if(n_in>0)

for i=1:n_in input_inv_FTtest(n+i,m_in+n_in+1-i) = Yk; end

end output_inv_FT(n,1) = Yk; %Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_inv_testFT = [output_inv_FT,E']; figure('Name','NN_INV_FTtest')

subplot(2,1,1)

plot(output_inv_FT(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E') title('Error') save('output_inv_testFT.mat','output_inv_testFT') input_idtestFT(1:row_in-start+1,1) = output_inv_testFT(start:row_in,1); save('input_idtestFT.mat','input_idtestFT') save('input_inv_FTtest.mat','input_inv_FTtest') end

11. NN Direct FineTuning

function NN_DirectFT(hidden,m_in,n_in,T_data) disp('NN_DirectFT') time = 1; %Untuk normalisasi max_new = 1; min_new = -1;

load('input_idtestFT.mat','input_idtestFT'); %filename = 'PPR.xlsx'; X_data = input_idtestFT; %T_data = xlsread(filename,'B:B'); load('bobot_mom.mat','Vij'); load('bobot_mom.mat','Wjk');

load('bias_mom.mat','V0j');

load('bias_mom.mat','W0k');

%Normalisasi Input %input_norm(:,1) = (((X_data(:,1)-min(X_data(:,1)))*(max_new -

min_new))/(max(X_data(:,1))-min(X_data(:,1))))+min_new;

%X_data = input_norm; %Normalisasi Target target_norm(:,1) = (((T_data(:,1)-min(T_data(:,1)))*(max_new -

min_new))/(max(T_data(:,1))-min(T_data(:,1))))+min_new;

T_data = target_norm;

%Membuat matrix baru [row_xdata,col_xdata] = size(X_data); [row_tdata,col_tdata] = size(T_data); for i=1:m_in if (i<m_in) input_data(1:m_in-i,i) = zeros; input_data(m_in-i+1:row_xdata+m_in-i,i) = X_data;

end if (i==m_in) input_data(1:row_xdata,i) = X_data;

end

end

if(n_in>0)

input_feedback(1:row_xdata,i) = zeros; input_directFT =

[input_data(1:row_xdata,1:m_in),input_feedback(1:row_xdata,1:n_in)];

end if(n_in == 0) input_directFT = input_data(1:row_xdata,1:m_in);

end target = T_data;

start = m_in

%INISIALISASI [row_in,col_in] = size(input_directFT); %row_in = jumlah baris input (vektor) %col_in = jumlah kolom input (data input) [row_t,col_t] = size(target); %row_t = jumlah baris target (vektor) %col_t = jumlah kolom target (data target)

%Step 1 n = start; E(1,n) = 0; for n=start:row_in %FEEDFORWARD %Step 2 : Feedforward %Step 3 X(n,:) = input_directFT(n,:); T(n,:) = target(n,:);

%Step 4 %Sinyal input*bobot + bias untuk menjadi nilai hidden layer Z_inj = V0j + X(n,:)*Vij; %Fungsi aktivasi setiap unit hidden Zj = -1+(2./(1 + exp(-Z_inj)));

%Step 5 %Sinyal input(dari output hidden layer)*bobot + bias untuk menjadi nilai output layer Y_ink = W0k + Zj*Wjk; %Fungsi aktivasi setiap unit hidden Yk = -1+(2./(1 + exp(-Y_ink)));

if(n_in>0)

for i=1:n_in input_directFT(n+i,m_in+n_in+1-i) = Yk; end

end output(n,1) = Yk;

%Step 9 %Toleransi Error E(1,n) = (0.5)*sum((T(n,:) - Yk).^2);

end Err = sum(E(1,start:n))/(n-start+1) output_directFT = output; figure('Name','NN_DirectFT')

subplot(2,1,1)

plot(output(start:row_in)) hold on plot(target(start:row_in)) title('Output vs Target')

subplot(2,1,2)

plot(E')

title('Error')

save('output_directFT.mat','output_directFT')