Contoh Program Penerapan ANFIS Dengan C C

-

Contoh Program Source Code   /

Penerapan ANFIS
Dengan C/C++
 Posted on 09.24

Penerapan ANFIS dng C/C++

GIVE YOUR SUPPORT

Penerapan ANFIS dng C/C++ @ Neuro-fuzzy adalah gabungan dr dua
sistem yaitu sistem logika fuzzy & jaringan syaraf tiruan. Sistem neuro-

Suka 4.047 orang menyukai ini. Daftar untuk
mengetahui apa yang disukai teman

fuzzy berdasar pd sistem inferensi fuzzyyang dilatih menggunakan
algoritma pembelajaran yg diturunkan dr sistem jaringan syaraf tiruan.
dng demikian, sistem neuro-fuzzy memiliki semua kelebihan yg dimiliki

oleh sistem inferensi fuzzy & sistem jaringan syaraf tiruan. dr
kemampuannya untuk belajar maka sistem neuro-fuzzy sering disebut
sebagai ANFIS (adaptive neuro fuzzy inference systems)

Struktur ANFIS
Salah satu bentuk struktur yg sudah sangat dikenal adalah seperti
terlihat pd Gambar 1. Dalam struktur ini, sistem inferensi fuzzy yg
diterapkan adalah inferensi fuzzy model Takagi-Sugeno-Kang.
Metode adaptive neuro fuzzy inference system (ANFIS) adalah metode
yg menggunakan jaringan syaraf tiruan untuk mengimplementasikan
system inferensi fuzzy. Keunggulan system inference fuzzy adalah dapat
menerjemahkan pengetahuan dr pakar dalam bentuk aturan-aturan,
namun biasanya dibutuhkan waktu yg lama untuk menetapkan fungsi
keanggotaannya. Oleh sebab itu dibutuhkan teknik pembelajaran dr
jaringan syaraf tiruan untuk mengotomatisasi proses tersebut sehingga
dapat mengurangi waktu pencarian, hal tersebut menyebabkan metoda
ANFIS sangat baik diterapkan dalam berbagai bidang.

Logika Fuzzy
Logika fuzzy adalah peningkatan dr logika Boolean yg berhadapan dng

konsep kebenaran sebagian. Di mana logika klasik menyatakan bahwa

ARTIKEL TERKAIT

Penerapan Logika
Fuzzy Dengan C/C++
Fuzzy Metode
Tsukamoto Dengan C#
Konsep Dasar Logika
Fuzzy
Logika Fuzzy Metode
Mamdani Dengan C#
Pengenal Ucapan
Algoritma MFCC dan
ANFIS di MATLAB
ANFIS Dengan
MATLAB
Fuzzy Inference System
(ANFIS) Dengan C++
Penerapan ANFIS

Dengan C/C++
Logika Fuzzy Metode
Tsukamoto

.

segala hal dapat diekspresikan dalam istilah binary (0 / 1, hitam / putih,
ya / tidak), logika fuzzy menggantikan kebenaran boolean dng tingkat
kebenaran. Logika Fuzzy memungkinkan nilai keanggotaan antara 0 &
1, tingkat keabuan & juga hitam & putih, & dalam bentuk linguistik,
konsep tidak pasti seperti "sedikit", "lumayan", & "sangat".
Logika Fuzzy dikatakan sebagai logika baru yg lama, sebab ilmu tentang
logika fuzzy modern & metodis baru ditemukan beberapa tahun yg lalu,
padahal sebenarnya konsep tentang logika fuzzy itu sendiri sudah ada
sejak lama (Sri kusumadewi & Hari Purnomo, 2004, ”Aplikasi Logika
Fuzzy untuk pendukung keputusan”, hal.1). Konsep logika Fuzzy yg
sangat sistematis pertama kali diusulkan oleh Dr. Lotfi A. Zadeh,
seorang bidang ilmu komputer dr University Of California, Berkeley,
Amerika Serikat. pd bulan Juni tahun 1965, profesor Zadeh
mempublikasikan makalah / paper pertama yg membahas “Fuzzy Sets ”

pd jurnal Information and Control [Suyanto,ST,MSc., 2008, “Soft
Computing: membangun mesin ber-IQ Tinggi”,hal.2].
Logika fuzzy adalah suatu cara yg tepat untuk memetakan suatu ruang
input ke dalam suatu ruang output, sebagai contoh :
1. Manajer pergudangan mengatakan pd manajer produksi seberapa
banyak persediaan barang pd akhir minggu ini, kemudian manajer
produksi akan menetapkan jumlah barang yg harus diproduksi esok hari.
2. Pelayan restoran memberikan pelayanan kepada tamu, kemudian
tamu akan memberikan tip yg sesuai atas baik tidaknya pelayanan yg
diberikan.
3. kalian mengatakan kepada saya seberapa sejuk ruangan yg kalian
inginkan, kemudian saya akan mengatur putaran kipas yg ada pd
ruangan ini.
[Sri kusumadewi & Hari Purnomo, 2004, ”Aplikasi Logika Fuzzy untuk
pendukung keputusan”, hal.1-2].

Neuro Fuzzy
Neuro fuzzy adalah gabungan / integrasi antara 2 metode yaitu, Jaringan
syarat tiruan dng sistem fuzzy, dimana 2 metode tersebut memiliki
karakteristik yg bertolak belakang akan tetapi apabila digabungkan akan

menjadi suatu metode yg lebih baik. Jaringan syaraf tiruan (JST)
memiliki kemampuan Learning , tetapi tidak bisa menjelaskan proses
penalaran yg dilakukan karena pengetahuan yg dimilikinya hanyta
berupa bobot-bobot sinapsis yg biasanya bernilai real. JST tidak
memiliki aturan-aturan IF – THEN sama sekali, sebaliknya sistem fuzzy
tidak memiliki kemampuan learning, tetapi bisa menjelaskan proses
penalaran yg dilakukannya berdasarkan aturan-aturan (rules) dalam
basis pengetahuan yg dimilikinya.

Jaringan syaraf tiruan
Jaringan saraf tiruan (JST) (Bahasa Inggris: artificial neural network
(ANN), / juga disebut simulated neural network (SNN), / umumnya

LIST TUTORIAL

- Android
- Apple
- AppleScript
- Assembly
- C#

- C/C++
- Clipper
- ColdFusion
- Delphi
- FoxPro
- iOS
- Java
- Javascript
- Lingo
- Linux
- Lisp
- Matlab
- Me
- Objective C
- OpenCV
- Pascal
- Perl
- PHP
- Python
- Ruby

- Smalltalk
- SQL
- Swift
- Symbian
- Unix shell
- Visual Basic
- Windows Phone
- XQuery
3 Variabel
3D
ACO
Adaptive Resonance
Theory
Advanced Encryption
Standard
AES
AHP
Algoritma
Analytical Hierarchy
Process

Android
ANFIS
ANN
Annealing
Ant Colony
Optimization
Aplikasi n-Tier
ARIMA (Box-Jenkins)
Aritmetika Modulo
ART
Artificial Neural
Network
B-Tree
Backpropagation
Bi-Polar Slope One
Biometrik
Bit- Plane Complexity
Bit-Plane Complexity
Blowfish
BPCS

Brute Force
Buble Sort
Burrows Wheeler
Transformation
BWT
C-Means
Caesar
Case Based Reasoning
CBR
Certainty Factor (CF)
Cipher
CISM
Clonal Selection
CLONALG
Clustering
COBIT
Contoh

hanya disebut neural network (NN)), adalah jaringan dr sekelompok unit
pemroses kecil yg dimodelkan berdasarkan jaringan saraf manusia. JST

adalah sistem adaptif yg dapat merubah strukturnya untuk memecahkan
masalah berdasarkan informasi eksternal maupun internal yg mengalir
melalui jaringan tersebut. Secara sederhana, JST adalah sebuah alat
pemodelan data statistik non-linier. JST dapat digunakan untuk
memodelkan hubungan yg kompleks antara input & output untuk
menemukan pola-pola pd data (id.wikipedia.org).

ANFIS
Adaptive Neuro-Fuzzy Inference System (ANFIS) adalah penggabungan
mekanisme fuzzy inference system yg digambarkan dalam arsitektur
jaringan syaraf. Sistem inferensi fuzzy yg digunakan adalah sistem
inferensi fuzzy model Tagaki-Sugeno-Kang (TSK) orde satu dng
pertimbangan kesederhanaan & kemudahan komputasi.
Untuk menjelaskan arsitektut ANFIS, disini siasumsikan fuzzy inference
sistem (FIS) hanya punya dua input, x & y, serta satu output yg
dilambangkan z. pd model sugeno orde satu, himpunan aturan
menggunakan kombinasi linier dr input-input yg ada, dapat
diekspresikan sebagai berikut :
IF x is A1 AND y is B1 THEN f1 = p1x + q1y + r1
IF x is A2 AND y is B2 THEN f2= p2x + q2y + r2

Source Code Penerapan ANFIS
dng C
/*
 * Adaptive‐Network‐Based Fuzzy Inference System  ANFIS
 * Network ADT
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "anfis.h"
/ ** CATATAN 
  ** A  jika kita memiliki INC_H minimizations kesalahan berturut ‐> etha meningkat
  ** B  jika kita memiliki DEC_H succesions dari   sampai,   bawah ‐‐‐‐‐‐‐> penurunan etha
#define  _gamma         

t    = int_val t ;
        net‐>etha = INIT_ETHA;
        net‐>old_err  = 0.0;
        net‐>old_err  = 0.0;
        net‐>trend    = FIXED;
        net‐>trend_st = 0;
        
        net‐>b =  branch *  malloc  t * sizeof  branch ;
        assert  net‐>b != NULL ;
        
        for  i=0 ; i b[i].MF =  MF_t *  malloc  n * sizeof  MF_t ;
                assert  net‐>b[i].MF != NULL ;
                
                net‐>b[i].P = gsl_vector_alloc  n+ ;
                assert  net‐>b[i].P != NULL ;
        }
        
        #pragma omp parallel for default shared  private i,j
        for  i=0 ; i b[i/n] . MF[i%n] . k = mf[i].k;
                for  j=0 ; j b[i/n] . MF[i%n] . p[j] = mf[i].p[j];
                }
        }
        
        net‐>tau =  double *  malloc  net‐>t * sizeof  double ;
        assert  net‐>tau != NULL ;
        
        return net;
}

/ * Menghancurkan ADT & membebaskan sumber daya memori
  * PRE: net = NULL
  * PENGGUNAAN: net = anfis_destroy  bersih ;
  * /
anfis_t
anfis_destroy  anfis_t net
{
        int i = 0;
        
        assert  net != NULL ;
        
        for  i=0 ; i t ; i++  {
                free  net‐>b[i].MF ;
                net‐>b[i].MF = NULL;
                gsl_vector_free  net‐>b[i].P ;
                net‐>b[i].P  = NULL;
        }
        free  net‐>b ;          net‐>b     = NULL;
        free  net‐>tau ;        net‐>tau   = NULL;
        free  net ;             net        = NULL;
        
        return net;
}

/**#####################    Accesor / pengamat   #########################*/
/ * Mencetak ke STDOUT keadaan internal jaringan‐i cabang
  * PRE: net = NULL
  * I b[i].MF[j].k] ;
        
                switch  net‐>b[i].MF[j].k  {
                
                case  triang :
                        printf  "a = %. f, b = %. f, c = %. f\n", 
                                net‐>b[i].MF[j].p[0],
                                net‐>b[i].MF[j].p[ ],
                                net‐>b[i].MF[j].p[ ]  ;
                        break;
                        
                case  trap :
                        printf  "a = %. f, b = %. f, c = %. f, d = %. f\n", 
                                net‐>b[i].MF[j].p[0],
                                net‐>b[i].MF[j].p[ ],
                                net‐>b[i].MF[j].p[ ],
                                net‐>b[i].MF[j].p[ ]  ;
                        break;
                        
                case  gauss :
                        printf  "a = %. f, s = %. f\n", 
                                net‐>b[i].MF[j].p[0],
                                net‐>b[i].MF[j].p[ ]  ;
                        break;
                        

Risk Management
RLF
RMSE
RNN
Root Mean square Error
RSA
RWP
Sandi
Secant
Self Organizing Map
(SOM)
Semut
SHA (Secure Hash
Algorithm)
SHA-256
Sidik Jari
Simulated Annealing
SISP
Sistem Biometrika
Sistem Verifikasi
Biometrik
Slope One
Slope One predictors
sorting
Source Code
Spanning Tree
Speech
Speech Recognition
Steganografi
Steganography
Stream Cipher
Struktur Data
Tabu Search
Tanda Tangan Digital
Technopreneurship
Teorema Bayes
Thresholding
Transformasi Burrows
Wheeler
Transformasi Fourier
Transformasi Wavelet
Diskrit
Transformasi Wavelet
Kontinu
Traveling Salesman
Problem
Travelling Salesman
(TSP)
Travelling Salesman
problem
TSP
Tsukamoto
Tutorial
Video Watermarking
Voice Recognition
Watermaking
Watermarking
WDM
Web Service
Weighted Slope One
Welch dan Powell
Welsh Powell
WMS

.

                case  bell :
                        printf  "a = %. f, b = %. f, c = %. f\n", 
                                net‐>b[i].MF[j].p[0],
                                net‐>b[i].MF[j].p[ ],
                                net‐>b[i].MF[j].p[ ]  ;
                        break;
                        
                default:
                        printf  "Error: unknown membership function\n" ;
                        break;
                }
        }
        
        printf  "Consequent parameters:\n" ;
        for  j=0 ; j n ; j++  {
                printf  "p[%d][%d] = %. f\t", i, j,
                        gsl_vector_get  net‐>b[i].P, j ;
        }
}

/ * Mencetak di STDOUT keadaan internal jaringan
  * PRE: net = NULL
  * /
void
anfis_print  anfis_t net
{
        int i = 0;
        
        assert  net != NULL ;
        
        printf  "# of inputs:   N = %ld\n# of branches: T = %ld", net‐>n, net‐>t ;
        
        for  i=0 ; i t ; i++  {
                printf  "\n" ;
                anfis_print_branch  net, i ;
        }
        printf  "\n\n" ;
        
        return;
}

/ * Salinan menjadi 'mf' ke‐i fungsi keanggotaan baris jaringan,
  * yg mengevaluasi input komponen‐j  aka: MF [i] [j]
  *
  * PRE: net = NULL
  * Mf! = NULL
  * I b[i].MF[j].k;
        for  l=0 ; l p[l] = net‐>b[i].MF[j].p[l];
        }
        
        return ANFIS_OK;
}

/ * Set 'mf' sebagai fungsi keanggotaan jaringan baru di‐i baris,
  * yg mengevaluasi input komponen‐j  aka: MF [i] [j]
  *
  * PRE: net = NULL
  * I b[i].P, j ;
                }
        }
        
        return p;
}

/ * Set 'new_p' sebagai jaringan baru‐i baris parameter konsekuen  aka: p [i]
  *
  * PRE: net = NULL
  * New_p! = NULL
  * Length_of  new_p  == input jaringan dimensi + 
  * I b[i].P, j, new_p[j] ;
        }
        
        return ANFIS_OK;
}

/**#######################    dinamika NETWORK    ############################*/

HOME

/ * Mengevaluasi fungsi keanggotaan ditentukan dalam 'x' nilai yg diberikan * /
static double
eval_MF  MF_t mf, double x
{
LAYANAN JASA PAKET & HARGA PROSES KERJASAMA ORDER TEKNOLOGI ABOUT
        switch  mf.k  {
        
        case  triang :
                return triangular  mf.p[0], mf.p[ ], mf.p[ ], x ;
                break;
                
        case  trap :
                return trapezoidal  mf.p[0], mf.p[ ], mf.p[ ], mf.p[ ], x ;
                break;
                
        case  gauss :
                return gaussian  mf.p[0], mf.p[ ], x ;
                break;
                
        case  bell :
                return belly  mf.p[0], mf.p[ ], mf.p[ ], x ;
                break;
                
        default:
                fprintf  stderr, "anfis.c: eval_MF: ERROR: unknown MF\n" ;
                return 0.0;
                break;
        }
}

/ * Mengevaluasi fungsi keanggotaan jaringan di masukan yg diberikan
  * Nilai keanggotaan Meraih disimpan dalam vektor MF_k
  *
  * PRE: net = NULL
  * Masukan! = NULL
  * MF_k! = NULL
  * Length_of  input  == dimensi input jaringan
  *
  * POS: Hasil == nilai keanggotaan ANFIS_OK && disimpan di MF
  * atau
  * Hasil == ANFIS_ERR
  * /

SEARCH : TUTORIAL + SOURCE CODE

static int
anfis_compute_membership  const anfis_t net, gsl_vector *input, gsl_vector *MF_k
{
        int i = 0, n = 0, t = 0;
        double value = 0.0;
        
        assert  net   != NULL ;
        assert  input != NULL ;
        assert  MF_k  != NULL ;
        
        t = net‐>t;
        n = net‐>n;
        
        #pragma omp parallel for shared MF_k,input  private value
        for  i=0 ; i b[i/n].MF[i%n],
                                 gsl_vector_get  input, i%n ;
                assert  value >= 0.0 ;
                gsl_vector_set  MF_k, i, value ;
        }
        
        return ANFIS_OK;
}

/ * Melakukan propagasi maju sebagian dari masukan yg diberikan untuk menghitung
  * yg dilarang‐Taus, yg kemudian disimpan dalam b_tau_k
  *
  * MF_k harus mengandung nilai‐nilai keanggotaan jaringan untuk masukan ini
  *
  * PRE: net = NULL
  * Masukan! = NULL
  * MF_k! = NULL
  * B_tau_k! = NULL
  * Length_of  input  == dimensi input jaringan
  *
  * POS: Hasil == ANFIS_OK && nilai b_tau_k di net diperbarui
  * atau
  * Hasil == ANFIS_ERR
  * /

static int
anfis_partial_fwd_prop  anfis_t net, gsl_vector *input, const gsl_vector *MF_k,
                        gsl_vector *b_tau_k
{
        int i = 0, j = 0, t = 0, n = 0;
        double *tau = NULL, tau_sum = 0.0;
        
        assert  net     != NULL ;
        assert  input   != NULL ;
        assert  MF_k    != NULL ;
        assert  b_tau_k != NULL ;
        
        t   = net‐>t;
        n   = net‐>n;
        tau = net‐>tau;
        
       / * Taus Pertama dihitung * /
        #pragma omp parallel for default shared  private i,j
        for  i=0 ; i n+
                        gsl_vector_memcpy  net‐>b[i].P, & p_sub.vector ;
                        
/*                      dfor  j=0 ; j n ; j++  {
                                debug  "p[%u][%u] = %. f\n", i, j,
                                gsl_vector_get  X, i* net‐>n+  + j ;
                        }
*/              }
/*              debug  "Sum of residual squares: ?² = %f\n\n", chisq ;
*/              j=j;calls=calls;
        }
        
        return X;
}

/* & SETERUSNYA ;  source code lengkapnya bisa menghubungi kami 
 */

}

Jika Anda perlu source code terkait dengan artikel di atas atau ada yang
ingin di tanyakan anda bisa melakukan konsultasi gratis kepada kami,
melalui form di bawah. Hasil konsultasi akan di kirimkan ke email Anda.
Kami mohon supportnya dengan mengklik beberapa tombol berikut :

;

Name: 

E­Mail: * 

Subject: 

Message: * 

Saya bukan robot

reCAPTCHA
Privasi - Persyaratan

Send message!
All fields marked with * are required.

Informasi Penting Untuk
Mahasiswa !
Kami menawarkan layanan jasa konsultan
bimbingan pembuatan program untuk Tesis
Skripsi dan Tugas Akhir Informatika, Komputer,
Elektro dan Teknik lainnya yang bidang minatnya
mengarah ke teknologi informasi. BASED
PROJECT :Mobile Development (Java, Adobe,
AS3, Android, BB, iOS, WPhone dll), Web &
Desktop Development (.Net, C#, MATLAB, PHP,
Delphi, Visual Basic dll). BONUS : Di bimbing
untuk penguasaan materi dan coding dan revisi.

Label: - C/C++, ANFIS, Fuzzy, Logika Fuzzy

POSTING LEBIH BARU

POSTING LAMA

Metode Algoritma | Contoh Program ­ Source Code
Tem plat e Design ed by Project ­G ­ Prou dly pow ered by Blogger | DMCA Prot ect ed | Copyrigh t  Policy | Sit e Map 
Copyrigh t  ©  2 0 1 4  Project ­G All Righ t s Reserved