Contoh Program Penerapan ANFIS Dengan C C

(1)

-Contoh Program Source Code /

Penerapan ANFIS

Dengan C/C++



Posted on 09.24

Penerapan ANFIS dng C/C++

Penerapan ANFIS dng C/C++ @ Neuro-fuzzy adalah gabungan dr dua

sistem yaitu sistem logika fuzzy & jaringan syaraf tiruan. Sistem

neuro-fuzzy berdasar pd sistem inferensi neuro-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

GIVE YOUR SUPPORT

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

Suka

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

▸ Baca selengkapnya: contoh model c pppk

(2)

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

(3)

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

Contoh

Contoh Kode

Contoh Penerapan

contoh program

Contoh Soal

CRC

Cyclic Redundancy

Code

DCPChiper

Deteksi Mata

Deteksi Wajah

Digital Signal

Processing (DSP)

Digital Signature

Dijkstra

Discrete Cosine

Transform (DCT)

Discrete Wavelet

Transform

Djikstra

DTW

Dynamic Source

Routing

ECDSA

Eigenface

Enterprise Resource

Planning

ERP

Euclid

Expectation

Maximization

Face Detection

Face Extractor

Face Recognition

Facebook

FCFS

FCM

Filterbank

First Come First Server

Fisherface

Forecasting

Forward Chaining

FP-Growth

Fuzzy

Fuzzy ART

Fuzzy C-Means

Gauss-Jordan

Gaussian

Generate & Test

Genetika

Graph Coloring

greedy

Green Computing

Hash

Hash Satu Arah

Hidden Markov Model

(HMM)

Histogram Equalization

Hopfield

Huffman

image processing

Implementasi

Iris Recognition

IS Strategic Planning

Jaringan

Jaringan Saraf Tiruan

jaringan syaraf tiruan

Jaringan Syaraf Tiruan

(JST)

Josephus Problem

JST

K-means

knowledge

management

Kohonen

konsultan tesis

informatika

kriptografi

Kruskal

Latent Semantic

Indexing

Least Significant Bit

(LSB)

Linear Programming

Linked List

/*

* Adaptive‐Network‐Based Fuzzy Inference System ANFIS * Network ADT

*/

#include <stdlib.h> #include <stdio.h> #include <string.h> #include <assert.h> #include <math.h> #include <float.h>

#include <gsl/gsl_multifit.h> #include <gsl/gsl_linalg.h> #include <gsl/gsl_blas.h> #include <gsl/gsl_errno.h> #include <omp.h>

#include "anfis.h"

/ ** CATATAN <Heuristic untuk modifikasi etha>

** 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 <<8

(4)

Linked List

list judul informatika

Logika Fuzzy

LOKI

LOOK

Low Bit Coding

LSB

LSI

Mac

Maksimum Likelihood

Mamdani

MANET

MDF

Metode Fisherface

Metode Grafik

metode LSB

Metode Mamdani

Metode Penelitian

Metode Secant

MFCC

Minimum Spanning

Tree

mobile

Mobile Ad hoc Network

Modified Direction

Feature

MTVRP

Naive Bayes

Naive Bayes Classifier

negascout

Neural Network

One Way Hash

Online Learning

Open Shortest Path

First

Open System

Interconnection

Parity Coding

Pattern Recognition

PCA

Pemrograman Linear

Pencarian Akar

Pencarian Linear

Pencocokan

Pencocokan Sidik Jari

Pengenalan Iris Mata

Pengenalan Objeck

Pengenalan Pola

Pengenalan Suara

Pengenalan Ucapan

Pengenalan Wajah

Pengolahan Citra

Digital

Pengukuran

Garis-Garis Telapak Tangan

Penjadwalan

Penjadwalan CPU

Peramalan

Perataan Histogram

Perceptron

Persamaan Linier

Pewarnaan Graf

Pewarnaan Simpul

Graph

Pohon Huffman

Prim

Principal Component

Analisys

Project Graduate

Quantum

Random Waypoint

real time tracking

Recognition

Recurrent Neural

Network

Recursive Large First

Recursive Largest First

Rijndael

Risk Management

#define MIN x,y x < y ? x : y

#define _byte_size << #define LSB 0

#define MSB _byte_size*sizeof long ‐

#define int_val x x & ~ unsigned long << MSB

/ *

Debugging Fungsi pencetakan * /

#ifdef _DEBUG

#define handle_error_ err if err != ANFIS_OK return err; #define handle_error_ arr if arr == NULL return ANFIS_ERR; #define handle_error_ arr if arr == NULL return NULL; #define debug s,... fprintf stderr, s, ##__VA_ARGS__ #define dfor s for s

#else

#define handle_error_ err #define handle_error_ arr #define debug s,... #define dfor s #endif

/**###################### STRUKTUR & STUFF ############################*/

/ * Sebuah cabang jaringan tunggal. yg meliputi: ... * / typedef struct {

MF_t *MF; / * ... Fungsi keanggotaan n total * / gsl_vector *P; / * ... Koefisien konsekuen n + total * / } branch;

/ * Struktur internal Jaringan * /

struct _anfis_s {

long n; / * # Input * /

double old_err ;/ * Belajar kesalahan dari epochs sebelumnya * / double old_err ;/ * Error belajar dari dua epochs sebelumnya * /

int trend; / * Negara etha heuristik: 0 = penurunan; = peningkatan * / int trend_st; /* trend state */

};

/ * TAD internal untuk menghitung update parameter tempat

* Yaitu: parameter internal yg MF dengan menggunakan metode gradient descent * /

typedef struct {

MF_t *mf_ij; / * MF yg parameter harus diperbarui * /

t_sample *s; / * Contoh pelatihan yg ditetapkan untuk zaman ini * /

gsl_vector *MF_val; / * Nilai MF untuk semua masukan P dalam sampel yg diberikan * / gsl_vector *b_tau; / * Nilai dilarang tau di cabang MF ini dari sampel * / gsl_vector *p_sub; / * Parameter konsekuen di cabang MF ini * /

gsl_vector *f_out; / * Jaringan nilai output untuk diberikan sampel * / } mfu_t;

/ * Untuk printing * /

char MF_kinds[MAX_FUNC][MAX_NLEN] = { "triang",

"trap", "gauss", "bell" };

double triangular double a, double b, double c, double x ;

double triangular double a, double b, double c, double x { return MAX 0.0, MIN x‐a / b‐a , c‐x / c‐b ; }

double trapezoidal double a, double b, double c, double d, double x ;

double trapezoidal double a, double b, double c, double d, double x { return MAX 0.0, MIN MIN x‐a / b‐a , d‐x / d‐c , .0 ; }

double gaussian double a, double sigma, double x ;

double gaussian double a, double sigma, double x { return exp ‐ .0 * pow x‐a /sigma , .0 ; }

double belly double a, double b, double c, double x ;

double belly double a, double b, double c, double x { return .0 / .0 + pow fabs x‐c /a , .0*b ; }

(5)

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

net = anfis_t malloc sizeof struct _anfis_s ; assert net != NULL ;

net‐>n = int_val n ; net‐>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 < t ; i++ {

net‐>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 < t*n ; i++ {

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 { 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; }

anfis_print_branch anfis_t net, unsigned int i {

int j = 0;

assert net != NULL ;

assert i < unsigned long net‐>t ;

printf "\nBranch # %d\n", i ;

for j=0 ; j < net‐>n ; j++ {

printf "MF[%d] kind: %s\nParamaters: ", j, MF_kinds[net‐>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;

(6)

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 <= net‐>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;

printf "# of inputs: N = %ld\n# of branches: T = %ld", net‐>n, net‐>t ;

for i=0 ; i < net‐>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 <jaringan # cabang * J <dimensi masukan jaringan *

* POS: Hasil == ANFIS_OK && MF [i] [j] data telah disalin dalam 'mf' * atau

* Hasil == ANFIS_ERR * /

int

anfis_get_MF anfis_t net, unsigned int i, unsigned int j, MF_t *mf {

int l = 0;

assert net != NULL ; assert mf != NULL ;

assert i < unsigned long net‐>t ; assert j < unsigned long net‐>n ;

mf‐>k = net‐>b[i].MF[j].k; for l=0 ; l < MAX_PARAM ; l++ { mf‐>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 <jaringan # cabang

* J <dimensi masukan jaringan

*

* POS: Hasil == ANFIS_OK && MF [i] [j] telah diganti dengan 'mf' * atau

* Hasil == ANFIS_ERR

* /

int

anfis_set_MF anfis_t net, unsigned int i, unsigned int j, MF_t mf

{

int l = 0;

assert i < unsigned long net‐>t ; assert j < unsigned long net‐>n ;

net‐>b[i].MF[j].k = mf.k; for l=0 ; l < MAX_PARAM ; l++ { net‐>b[i].MF[j].p[l] = mf.p[l]; }

return ANFIS_OK; }

(7)

* yg harus dibebaskan menggunakan glibc standar bebas rutin *

* PRE: net = NULL * I <jaringan # cabang

*

* POS: Hasil = NULL && hasil berisi koefisien p [i] * atau

* Hasil == NULL

* /

double *

anfis_get_P anfis_t net, unsigned int i {

int j = 0; double *p = NULL;

p = double * malloc net‐>n+ * sizeof double ; if p != NULL {

for j=0 ; j < net‐>n+ ; j++ {

p[j] = gsl_vector_get net‐>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 <jaringan # cabang

*

* POS: Hasil == ANFIS_OK && koefisien di p [i] telah diganti * Dengan orang‐orang di 'new_p'

* atau

int

anfis_set_P anfis_t net, unsigned int i, const double *new_p {

int j = 0;

assert net != NULL ; assert new_p != NULL ;

for j=0 ; j < net‐>n+ ; j++ {

gsl_vector_set net‐>b[i].P, j, new_p[j] ; }

return ANFIS_OK; }

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

/ * Mengevaluasi fungsi keanggotaan ditentukan dalam 'x' nilai yg diberikan * /

static double

eval_MF MF_t mf, double x {

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

(8)

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 < t*n ; i++ {

value = eval_MF net‐>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

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 < t ; i++ {

tau[i] = .0;

for j=0 ; j < n ; j++ {

tau[i] *= gsl_vector_get MF_k, i*n+j ; }

assert tau[i] >= 0.0 ; }

/ * Sekarang kita menghitung b_taus * / tau_sum = 0.0;

#pragma omp parallel for shared tau reduction +:tau_sum for i=0 ; i < t ; i++ {

tau_sum += tau[i]; }

#pragma omp parallel for default shared private i for i=0 ; i < t ; i++ {

if tau_sum != 0.0 {

gsl_vector_set b_tau_k, i, tau[i] / tau_sum ; } else {

gsl_vector_set b_tau_k, i, 0.0 ; }

}

tau = NULL;

return ANFIS_OK; }

/* Snew = S * A_i * At_i * S */

static void

calc_num const gsl_matrix *S, const gsl_vector *A_i, gsl_matrix *Snew, gsl_matrix *m_aux, gsl_vector *v_aux, size_t M

{

int i = 0;

double value = 0.0;

/* v_aux = S * A_i */

gsl_blas_dgemv CblasNoTrans, .0, S, A_i, 0.0, v_aux ;

/* m_aux = v_aux * At_i */

#pragma omp parallel for default shared private i,value for i=0 ; i < M*M ; i++ {

value = gsl_vector_get v_aux, i/M * gsl_vector_get A_i, i%M ; gsl_matrix_set m_aux, i/M, i%M, value ;

}

/* Snew = m_aux * S */

(9)

return; }

/* Nilai kembalian: At_i * S * A_i */

static double

calc_den const gsl_matrix *S, const gsl_vector *A_i, gsl_vector *v_aux {

double res = 0.0;

/* v_aux = S * A_i */

gsl_blas_dgemv CblasNoTrans, .0, S, A_i, 0.0, v_aux ;

/* res = At_i * v_aux */

gsl_blas_ddot A_i, v_aux, &res ;

return res; }

/ * Melakukan LSE parameter konsekuen untuk semua cabang dalam jaringan *

* PARAMETER: A ‐‐‐> variabel prediktor matriks

* Y ‐‐‐> hasil yg diharapkan untuk sampel set ini P total *

* PRE: A = NULL * Y! = NULL *

* POS: Hasil = NULL && paling cocok parameter konsekuen vektor kembali! * atau

* Hasil == NULL * /

static gsl_vector *

anfis_fit_linear const gsl_matrix *A, const gsl_vector *y, size_t P, size_t M {

gsl_matrix *S = NULL, / * Kovarian matriks * / *Snew = NULL,

*Saux = NULL;

gsl_vector *X = NULL, / * Future parameter paling cocok * / *Xnew = NULL;

unsigned int i = 0;

double den = 0.0, factor = 0.0;

assert A != NULL ; assert y != NULL ;

/ * Membangkitkan diperlukan ruang kerja * / S = gsl_matrix_calloc M,M ;

if S == NULL

goto exit_point; Snew = gsl_matrix_calloc M,M ; if Snew == NULL

goto exit_point; Saux = gsl_matrix_calloc M,M ; if Saux == NULL

goto exit_point; Xnew = gsl_vector_alloc M ; if Xnew == NULL

goto exit_point; X = gsl_vector_alloc M ; if X == NULL

goto exit_point;

/ * S =? * Id, where? adalah angka besar * / gsl_matrix_set_identity S ;

gsl_matrix_scale S, _gamma ;

/ * Melakukan Least Square Estimasi * / for i=0 ; i < P ; i++ {

/ * Matrix Sederet‐i baris At_i + dalam makalah Jang * / gsl_vector_const_view A_i = gsl_matrix_const_row A, i ;

/* Snew = S i * A_i+ * At_i+ * S i */ calc_num S, & A_i.vector , Snew, Saux, Xnew, M ; /* scale = At_i+ * S i * A_i+ */

den = calc_den S, & A_i.vector , Xnew ; /* Snew = Snew / +scale */

gsl_matrix_scale Snew, .0 / .0+den ; /* S i+ = S i ‐ Snew */

gsl_matrix_sub S, Snew ;

/* factor = At_i+ * X i */

gsl_blas_ddot & A_i.vector , X, &factor ; /* factor = yt_i+ ‐ factor */

factor = gsl_vector_get y, i ‐ factor; /* Xnew = S i+ * A_i+ */

gsl_blas_dgemv CblasNoTrans, .0, S, & A_i.vector , 0.0, Xnew ; /* Xnew = Xnew * factor */

gsl_vector_scale Xnew, factor ; /* X i+ = X i + Xnew */ gsl_vector_add X, Xnew ; }

exit_point:

if S != NULL { gsl_matrix_free S ; S = NULL;} if Snew != NULL { gsl_matrix_free Snew ; Snew = NULL;} if Saux != NULL { gsl_matrix_free Saux ; Saux = NULL;} if Xnew != NULL { gsl_vector_free Xnew ; Xnew = NULL;}

return X; }

/ * Melakukan estimasi least square alias LSE untuk sampel yg diberikan ukuran P * Untuk menemukan nilai‐nilai terbaik untuk parameter konsekuen jaringan

*

(10)

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 :

* Sebagai vektor panjang jaringan # cabang * input jaringan dimensi +

* Untuk memudahkan perhitungan lebih lanjut. Hasil gratis menggunakan gsl_vector_free *

* PRE: net = NULL

* A! = NULL

* S! = NULL

*

* PENGGUNAAN: new_params = anfis_lse *

* POS: new_params = NULL && konsekuen parameter dihitung & disimpan * Di net. Salinan nilai‐nilai baru dikembalikan

* atau

* New_params == NULL

* /

static gsl_vector *

anfis_lse anfis_t net, const gsl_matrix *A, const t_sample *s, unsigned int P {

size_t M = 0;

gsl_vector *y = NULL, / * Contoh hasil P total * / *X = NULL; / * Perkiraan parameter M total * / unsigned int i = 0, j = 0;

static size_t calls = 0;

assert net != NULL ; assert A != NULL ; assert s != NULL ;

M = size_t net‐>t * size_t net‐>n + ;

/ * Menyimpan hasil yg diinginkan dalam vektor 'y' * / y = gsl_vector_alloc P ;

handle_error_ y ; for i=0 ; i < P ; i++ {

gsl_vector_set y, i, s[i].out ; }

X = anfis_fit_linear A, y, P, M ;

if X != NULL {

/ * Menyimpan diperkirakan parameter dalam jaringan * / /* debug "LSE parameters estimation call # %lu :\n", ++calls ;

*/ for i=0 ; i < net‐>t ; i++ {

/ * P_sub referensi‐i cabang konsekuen param. * Estimasi, awalnya disimpan dalam vektor X * / gsl_vector_view p_sub;

p_sub = gsl_vector_subvector X, i*net‐>n+ , net‐>n+ ; gsl_vector_memcpy net‐>b[i].P, & p_sub.vector ;

/* dfor j=0 ; j <= net‐>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 */

(11)

POSTING LEBIH BARU POSTING LAMA

Name:

EMail: *

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

M e t o d e A l g o r i t m a | C o n t o h P r o g r a m S o u r c e C o d e

Te m pl a t e D e s i gn e d by P r o j e c t G P r o u dl y po w e r e d by B l o gge r | D M C A P r o t e c t e d | C o py r i gh t P o l i c y | S i t e M a p