KECERDASAN BUATAN

Rabu, 02 Juni 2010

fuzzy logic control untuk aplikasi khusus, buat dengan menggunakan matlab

Untuk menunjukkan capabilites kontrol logika fuzzy dari MATLAB kita akan mensimulasikan contoh yang sebelumnya bekerja melalui. Kami akan menggunakan input yang sama dan fungsi keanggotaan keluaran; A1, A2, B1 dan B2. Untuk memulai, kita akan mendefinisikan sebuah model Simulink yang akan digunakan untuk menjalankan program simulasi. Buka Matlab dan Simulink dan membuat file baru. Tambah masukan ramp, Lingkup, dan Fuzzy Logic Controller dengan Ruleviewer ke file seperti yang ditunjukkan. Fuzzy Logic Controller dengan blok Ruleviewer dapat ditemukan dalam logika fuzzy toolbox atau dengan mengetikkan nama di kotak pencarian dari Browser Perpustakaan.

Setelah file simulink Anda telah diciptakan seperti yang ditunjukkan di atas simpan file tersebut, untuk contoh ini nama file yang digunakan adalah tut1. Sekarang bahwa sistem secara keseluruhan telah didefinisikan kontroler fuzzy perlu dirancang. Untuk melakukan ini Fuzzy Inference System (FIS) editor akan digunakan. Untuk membuka file baru FIS dengan editor FIS, ketik berikut ke dalam MATLAB:

> fuzzy
Jendela berikut akan terbuka; itu adalah Fuzzy Inference System editor. Dengan FIS editor input dan output fungsi keanggotaan dapat didefinisikan, basis aturan didefinisikan, dan operator fuzzy ditetapkan.

Sistem default memiliki satu input dan satu output dan menggunakan inferensi Mamdani dan metode agregasi. editor ini juga menggambarkan tiga aspek dari contoller fuzzy; fuzzifikasi, inferensi, dan defuzzifikasi. Untuk memulai, mari kita mendefinisikan fungsi keanggotaan. Klik dua kali pada kotak masukan kuning dan Anda akan dibawa ke editor fungsi keanggotaan.

Secara default ada tiga fungsi keanggotaan, mf1, mf2, dan mf3. Kami akan mengubah mf1 dan mf2 sebagai A1 dan A2 dan menghapus mf3. Untuk menghapus keanggotaan fungsi cukup klik di atasnya, dan ketika disorot dalam warna merah, menghapus tekan. Untuk memanipulasi fungsi keanggotaan cukup klik pada mereka dan menyeret mereka. Klik pada baris sendiri untuk memindahkan fungsi dan klik pada kotak di sudut-sudut dan tarik untuk mengubah bentuk. Jika Anda tahu bentuk sudah, Anda juga dapat memilih fungsi dan masukkan dalam kotak bentuk params. Nama juga dapat diubah dengan menggunakan kotak Nama. Rentang ini dapat didefinisikan ulang juga, untuk input yang ingin kita rentang menjadi 0-3 sehingga kami akan menaruh [0 3] di kotak Range. Untuk A1 yang paramaters adalah [0 1 2] memberikan segitiga yang dimulai pada 0, puncak dari 1, dan berakhir pada 2. The paramaters untuk A2 adalah [1 2 3]. Setelah ini telah memasuki fungsi keanggotaan editor akan terlihat seperti ini:

Sementara masih dalam editor fungsi keanggotaan output fungsi keanggotaan dapat didefinisikan. Di kiri atas, di bawah FIS Variabel, klik pada kotak output1 biru. Ini akan membawa Anda ke dalam editor fungsi keanggotaan keluaran. Sekali lagi, mf3 perlu dihapus dan mf1 dan mf2 perlu didefinisikan ulang pertandingan B1 dan B2. The paramaters untuk B1 adalah [0 8 12] dan B2 adalah [4 10 15]. Rentang ini [0 15]. Setelah ini telah diperbarui bahwa fungsi keanggotaan output akan terlihat seperti ini:

Editor fungsi keanggotaan sekarang dapat ditutup untuk kembali ke editor FIS. FIS sekarang perlu memiliki aturan yang ditetapkan. Untuk melakukan hal ini klik dua kali pada kotak putih di antara input dan output fungsi keanggotaan. Ini akan memunculkan Editor Aturan, ini adalah mana aturan-aturan inferensi linguistik dimasukkan. Peraturan-peraturan ini didefinisikan dengan menggunakan fungsi keanggotaan fuzzy label A1, A2, B1, dan B2. Untuk memasukkan aturan yang diinginkan pilih pilihan 'jika' dan 'lalu' pilihan dan klik 'tambahkan aturan' di bagian bawah. Kami akan menggunakan dua aturan untuk sistem ini: 1. Jika A1 maka B1, serta 2.If A2 kemudian B2. Setelah aturan ini dimasukkan Peraturan editor akan terlihat seperti ini:

Jendela ini dapat ditutup dan sekarang FIS selesai, hanya perlu diekspor ke model Simulink. Untuk melakukan hal ini dari editor FIS, di bawah File Ekspor dan kemudian Untuk Workspace ... dan masukkan nama model Simulink di bidang Workspace Variabel, untuk kasus ini adalah 'tut1'. Sekarang, di Simulink, klik dua kali pada Fuzzy logic controller dan mengatur FIS matriks tut1 dan mengubah refresh rate ke 0,01. Sekarang simulasi dapat dijalankan selama 3 detik. Sementara simulasi berjalan jendela Peraturan Viewer akan muncul:

Jendela Peraturan Viewer menunjukkan masukan yang relevan dan output fungsi keanggotaan untuk setiap aturan. Peraturan 1 melibatkan A1 dan B1, sehingga mereka yang ditampilkan, dan aturan 2 melibatkan A2 dan B2. Untuk masukan yang diberikan fungsi keanggotaan output diubah ditampilkan dalam warna biru solid. Ini adalah mereka dikumpulkan dan ditampilkan dalam fungsi keanggotaan kanan bawah. Ini adalah hasil fuzzified. Untuk masukan dari 1,25 kedua peraturan menembak dan fungsi keanggotaan agregat (bawah kanan) adalah sama dengan yang telah ditentukan sebelumnya. Proses defuzzifikasi default adalah metode centroid dan garis merah menunjukkan dimana pusat massa itu dan demikian juga apa output

JST Pola

//==============================================================
//********** THIS IS THE MAIN PROGRAM **************************
//==============================================================

public static void main(String[] args)
{

//initiate the weights
initWeights();

//load in the data
initData();

//train the network
for(int j = 0;j <= numEpochs;j++)
{

for(int i = 0;i {

//select a pattern at random
patNum = (int)((Math.random()*numPatterns)-0.001);

//calculate the current network output
//and error for this pattern
calcNet();

//change network weights
WeightChangesHO();
WeightChangesIH();
}

//display the overall network error
//after each epoch
calcOverallError();
System.out.println("epoch = " + j + " RMS Error = " + RMSerror);

}

//training has finished
//display the results
displayResults();

}

//============================================================
//********** END OF THE MAIN PROGRAM **************************
//=============================================================

//************************************
public static void calcNet()
{
//calculate the outputs of the hidden neurons
//the hidden neurons are tanh
for(int i = 0;i {
hiddenVal[i] = 0.0;

for(int j = 0;j hiddenVal[i] = hiddenVal[i] + (trainInputs[patNum][j] * weightsIH[j][i]);

hiddenVal[i] = tanh(hiddenVal[i]);
}

//calculate the output of the network
//the output neuron is linear
outPred = 0.0;

for(int i = 0;i outPred = outPred + hiddenVal[i] * weightsHO[i];

//calculate the error
errThisPat = outPred - trainOutput[patNum];
}

//************************************
public static void WeightChangesHO()
//adjust the weights hidden-output
{
for(int k = 0;k {
double weightChange = LR_HO * errThisPat * hiddenVal[k];
weightsHO[k] = weightsHO[k] - weightChange;

//regularisation on the output weights
if (weightsHO[k] < -5)
weightsHO[k] = -5;
else if (weightsHO[k] > 5)
weightsHO[k] = 5;
}
}

//************************************
public static void WeightChangesIH()
//adjust the weights input-hidden
{
for(int i = 0;i {
for(int k = 0;k {
double x = 1 - (hiddenVal[i] * hiddenVal[i]);
x = x * weightsHO[i] * errThisPat * LR_IH;
x = x * trainInputs[patNum][k];
double weightChange = x;
weightsIH[k][i] = weightsIH[k][i] - weightChange;
}
}
}

//************************************
public static void initWeights()
{

for(int j = 0;j {
weightsHO[j] = (Math.random() - 0.5)/2;
for(int i = 0;i weightsIH[i][j] = (Math.random() - 0.5)/5;
}

}

//************************************
public static void initData()
{

System.out.println("initialising data");

// the data here is the XOR data
// it has been rescaled to the range
// [-1][1]
// an extra input valued 1 is also added
// to act as the bias

trainInputs[0][0] = 1;
trainInputs[0][1] = -1;
trainInputs[0][2] = 1;//bias
trainOutput[0] = 1;

trainInputs[1][0] = -1;
trainInputs[1][1] = 1;
trainInputs[1][2] = 1;//bias
trainOutput[1] = 1;

trainInputs[2][0] = 1;
trainInputs[2][1] = 1;
trainInputs[2][2] = 1;//bias
trainOutput[2] = -1;

trainInputs[3][0] = -1;
trainInputs[3][1] = -1;
trainInputs[3][2] = 1;//bias
trainOutput[3] = -1;

}

//************************************
public static double tanh(double x)
{
if (x > 20)
return 1;
else if (x < -20)
return -1;
else
{
double a = Math.exp(x);
double b = Math.exp(-x);
return (a-b)/(a+b);
}
}

//************************************
public static void displayResults()
{
for(int i = 0;i {
patNum = i;
calcNet();
System.out.println("pat = " + (patNum+1) + " actual = " + trainOutput[patNum] + " neural model = " + outPred);
}
}

//************************************
public static void calcOverallError()
{
RMSerror = 0.0;
for(int i = 0;i {
patNum = i;
calcNet();
RMSerror = RMSerror + (errThisPat * errThisPat);
}
RMSerror = RMSerror/numPatterns;
RMSerror = java.lang.Math.sqrt(RMSerror);
}

}

Jumat, 28 Mei 2010

JST Memprediksi

Tugas	Tanggal Tugas	Tanggal Selesai
3	25- 03- 2010	30-03- 2010

NAMA	NPM	TUGAS	NILAI
Agus Zulhendri	0855 031 003	Mengauplod ke blog
Sigiara Sinaga	0815 031 091	Menyeleksi file uploadan
Arya wiguna b	0815 031 0	Mengedit postingan blog
Ayub Luhung	0815 031 0	Mencari data dan upload file
Ferdinand	0815 031 0	Mencari data dan upload file

Metode Ranfis adalah suatu metode yang dalam melakukan penyetelan aturan digunakan algoritma pembelajaran terhadap sekumpulan data yang memungkinkan juga aturan-aturan untuk beradaptasi. Sistem ini menggunakan sinergi metode dari neuro dan fuzzy, dengan menambahkan dimensi lain pada kombinasinya yaitu Rough Set yang berdasarkan prinsip klasifikasi dalam suatu rangkaian hybrid. Rangkaian Jaringan Syaraf Tiruan berbasis neuron rough memiliki kemampuan learning berdasarkan data-data masukan, dan membantu sistem fuzzy dalam menentukan rule yang terbaik dalam memprediksi data, sedangkan rough set sendiri akan mengklasifikasikan data acak yang melewatinya. Metode RANFIS ini digunakan untuk menemukan suatu pola perubahan tertentu, dan akan selalu belajar dari kesalahan atau error sebelumnya, sehingga akan didapatkan nilai akurasi yang sangat baik.

Arsitektur jaringan RANFIS yang menggunakan 5 layer dan 15 neuron.

Pada bagian analisa sistem, paper ini menyajikan analisa data dengan proses peramalan menggunakan input data saham secara time series yang tersimpan pada file *.xls, yang kemudian diubah menjadi matriks inputan.

rancangan sistem dan jaringan ranfis yang digunakan seperti diagram blok di bawah ini.

Data yang dinormalisasi digunakan sebagai neuron inputan pada layer masukan dan sebagai neuron output pada layer keluaran. Paper ini menggunakan arsitektur rough adaptive neuro-fuzzy inference system yang terdiri dari input layer, hidden layer (3 layer) dan output layer. Inputnya berupa data time series yaitu harga penutupan indeks harga saham. Sedangkan targetnya adalah harga penutupan besok (t+1). Arsitektur sistem ini terdiri dari 5 layer : MF neuron (membership function) pada input layer, neuron rough yang melakukan proses AND, normalisasi dan agregasi pada hidden layer, dan neuron penjumlahan pada output layer.

Untuk menghasilkan jaringan RANFIS yang optimal dilakukan proses training yaitu forward dan backward training.

Data yang digunakan adalah data harga penutupan saham harian Dow Jones & Company (terdaftar pada New York Stock Exchange) dengan acuan waktu senin-jumat, dari tahun 1985 hingga 2002, yang diperoleh dari http://lib.stat.cmu.edu/datasets/. Data untuk training dari 2 Januari 1985 s/d 7 Maret 2000 sebanyak 3836 record. Training menggunakan jumlah epoch 300, target error 0 dan fungsi keanggotaan segitiga, trapesium, gauss dan bell yang masing-masing akan dibandingkan performansinya.

Hasil analisis training dan testingmenunjukkan bahwa jenis fungsi keanggotaan sangat mempengaruhi hasil peramalan, karena turutmengubah jaringan RANFIS. Pemberian parameterepoch juga mempengaruhi nilai error dan hasilperamalan. Semakin banyak epoch yang dilakukan maka error yang dihasilkan akan berkurang ataupun tetap pada angka tertentu. Untuk perubahan error target berpengaruh pada performansi jaringan, nilai

error yang dihasilkan akan naik dengan nilai <>
Kesimpulan dari ini:
Hasil yang diperoleh dari penelitian berdasarkan pada pengujian yang telah dilakukan dengan algoritma RANFIS untuk memprediksi nilai saham. Fungsi keanggotaan Fuzzy dapat mengakomodasi sinyal JST dalam proses training dengan menggunakan fungsi keanggotaan tersebut sebagai fungsi aktivasi yang melakukan proses FIS pada tiap layernya. Perhitungan rough set secara perumusan dapat mengurangi nilai sinyal acak. Jaringan RANFIS yang melibatkan JST, sistem fuzzy dan Rough Set, mampu membangun suatu sistem peramalan yang baik dengan performansi yang dihasilkan dalam RMSE yaitu 0.9836.

Program code

//#include
#include
#include
#include
#include

//// Data dependent settings ////
#define numInputs 3
#define numPatterns 4

//// User defineable settings ////
#define numHidden 4
const int numEpochs = 500;
const double LR_IH = 0.7;
const double LR_HO = 0.07;

//// functions ////
void initWeights();
void initData();
void calcNet();
void WeightChangesHO();
void WeightChangesIH();
void calcOverallError();
void displayResults();
double getRand();

//// variables ////
int patNum = 0;
double errThisPat = 0.0;
double outPred = 0.0;
double RMSerror = 0.0;

// the outputs of the hidden neurons
double hiddenVal[numHidden];

// the weights
double weightsIH[numInputs][numHidden];
double weightsHO[numHidden];

// the data
int trainInputs[numPatterns][numInputs];
int trainOutput[numPatterns];

//==============================================================
//************** function definitions **************************
//==============================================================

//***********************************
// calculates the network output
void calcNet(void)
{
//calculate the outputs of the hidden neurons
//the hidden neurons are tanh
int i = 0;
for(i = 0;i< -5) { weightsHO[k] = -5; } else if (weightsHO[k] > 5)
{
weightsHO[k] = 5;
}
}

}

//************************************
// adjust the weights input-hidden
void WeightChangesIH(void)
{

for(int i = 0;i<= numEpochs;j++) { for(int i = 0;i

Aplikasi fuzzy logic (Literatur internet)

Tugas	Tanggal Tugas	Tanggal Selesai
8	29- 04- 2010	10-05- 2010

NAMA	NPM	TUGAS	NILAI
Agus Zulhendri	0855 031 003	Mengauplod ke blog
Sigiara Sinaga	0815 031 091	Menyeleksi file uploadan
Arya wiguna b	0815 031 0	Mengedit postingan blog
Ayub Luhung	0815 031 0	Mencari data dan upload file
Ferdinand	0815 031 0	Mencari data dan upload file

Abstrak

Makalah ini menyajikan sebuah sistem pengembangan kendali fuzzy logic(PetraFuz, Petra Fuzzy Development System) yang dikembangkan oleh laboratorium Sistem Kontrol, Jurusan Teknik Elektro, Universitas Kristen Petra Surabaya. Sistem ini terdiri dari perangkat keras sistem mikrokontroler MCS51 dan perangkat lunak pendukung yang berjalan pada PC. Sistem PetraFuz digunakan untuk mengembangkan sistem berbasis fuzzy logic utamanya pada bidang kendali. Kemampuan sistem meliputi pengembangan pada fase perancangan kendali, evaluasi kendali, pembentukan program bahasa assembly MCS51 dan proses downloading program menuju target sistem mikrokontroler MCS51 untuk dieksekusi melakukan kendali pada plant yang nyata. Aksi kendali dapat diakuisi oleh program PC melalui komunikasi serial RS232 sehingga respon kendali dapat digambarkan pada layar monitor untuk dilakukan analisis lebih lanjut yang diperlukan pada proses tuning if-then fuzzy rules. Penggunaan tools PetraFuz, sangat membantu proses rancang bangun sistem kendali fuzzy terutama bagi praktisi/akademisi yang berminat menekuni teknik kendali yang relatif baru ini. Sistem PetraFuz diharapkan dapat memberikan kontribusi positip bagi masyarakat sistem kendali untuk mengembangkan berbagai aplikasi kendali berbasis fuzzy logic.

(file asli disini )

Kamis, 27 Mei 2010

FUZZy LOGIC

Tugas	Tanggal Tugas	Tanggal Selesai
6	- 04- 2010	10-05- 2010

NAMA	NPM	TUGAS	NILAI
Agus Zulhendri	0855 031 003	Mengauplod ke blog
Sigiara Sinaga	0815 031 091	Menyeleksi file uploadan
Arya wiguna b	0815 031 0	Mengedit postingan blog
Ayub Luhung	0815 031 0	Mencari data dan upload file
Ferdinand	0815 031 0	Mencari data dan upload file

Pada teknik digital, dikenal dua macam logika yaitu 0 dan 1 serta tiga operasi dasar yaitu NOT, AND dan OR. Logika semacam ini disebut dengan crisp logic. Logika sering dipergunakan untuk mengelompokan sesuatu himpunan. Sebagai contoh, akan dikelompokkan beberapa macam hewan, yaitu ‘hiu’, ‘kakap’, ‘pari’, ‘kucing’, ‘kambing’, ‘ayam’ ke dalam himpunan ikan. Sangat jelas bahwa hiu, kakap dan pari adalah anggota himpunan ikan sedangkan kucing, kambing, ayam adalah bukan anggotanya

Download makalah

Jaringan Sararf Tiruan

Tugas	Tanggal Tugas	Tanggal Selesai
5	29- 04- 2010	02-05- 2010

NAMA	NPM	TUGAS	NILAI
Agus Zulhendri	0855 031 003	Mengauplod ke blog
Sigiara Sinaga	0815 031 091	Menyeleksi file uploadan
Arya wiguna b	0815 031 0	Mengedit postingan blog
Ayub Luhung	0815 031 0	Mencari data dan upload file
Ferdinand	0815 031 0	Mencari data dan upload file

Jaringan saraf tiruan (JST) (Bahasa Inggris: artificial neural network (ANN), atau juga disebut simulated neural network (SNN), atau umumnya hanya disebut neural network (NN)), adalah jaringan dari sekelompok unit pemroses kecil yang dimodelkan berdasarkan jaringan saraf manusia. JST merupakan sistem adaptif yang dapat merubah strukturnya untuk memecahkan masalah berdasarkan informasi eksternal maupun internal yang mengalir melalui jaringan tersebut.

Secara sederhana, JST adalah sebuah alat pemodelan data statistik non-linier. JST dapat digunakan untuk memodelkan hubungan yang kompleks antara input dan output untuk menemukan pola-pola pada data.

Download makalah

Kamis, 25 Maret 2010

Pertemuan 2

Logika Berpikir

Pertemuan ke 2

Kecerdasan Buatan

Review

1. Kecerdasan buatan adalah cabang ilmu

pengetahuan berhubungan dengan komputer/

mesin yang digunakan sebagai alat bantu

dalam suatu sistem agar dapat melakukan

pekerjaan sebagaimana manusia.

2. Beberapa bidang yang termasuk artificial

intelligent (ai) atau kecerdasan buatan antara

lain: sistem pakar (expert system), genetic

algoritm, fuzzy logic, jaringan syaraf tiruan

(neural network), robotika.