programer skripsi tesis tugas akhir

Metode Huffman Statis Dengan Java

Contoh Program Metode Huffman Statis Dengan Java

Metode Huffman Statis dengan Java

Huffman code 

Huffman code adl salah satu teknik dlm kompresi data yg menggunakan struktur data binary tree. Hal ini dilakukan dg tujuan mengurangi penggunaan diskspace & network traffic. Algortima Huffman / huffman code adl salah satu algoritma kompresi data yg cukup terekenal & populer, hal ini dikarenakan algortima huffman cukup efektif untuk kompresi data.  Dalam encoding sebuah character dg binary code biasa sebuah character akan memakan memory secara static 8 bit, atau 1 byte.

Hasil gambar untuk Java
Metode Huffman Statis Dengan Java

Algoritma Huffman Statik

Algoritma Huffman Statik menggunakan kemungkinan kemunculan dr setiap karakter yg telah ditetapkan pada awal pengkodean & kemungkinan kemunculan karakter tersebut juga dapat diketahui baik oleh enkoder maupun dekoder. Cara kerja dr algoritma Huffman Statik untuk mengkompresi data yaitu dg cara sebagai berikut:

a. Hitung jumlah karakter yg muncul di dlm file, sehingga masing-masing karakter yg ada akan memiliki bobot sesuai dg banyaknya karakter tersebut didalam file. Kemudian susunlah suatu pohon biner yg dibangun berdasarkan bobot karakter yg ada. Inti dr pembangunan pohon biner adl menggabungkan dua buah karakter dg tingkat kemunculan (bobot) yg lebih kecil, kemudian membangkitkan satu buah node parent yg memiliki bobot gabungan dr kedua karakter tersebut.

b. Lakukan pengkodean (encoding) karakter yg ada didalam file menjadi suatu representasi bit sesuai dg urutan pada pohon biner yg telah dibangun.

Contoh Program Metode Huffman Statis dg Java

Proyek ini adl implementasi Huffman coding dg bahas pemrograman Java. Kode ini dimaksudkan untuk digunakan untuk belajar, & sebagai dasar yg kokoh untuk modifikasi & perpanjangan. dg demikian, itu dioptimalkan untuk logika yg jelas & kompleksitas rendah, tidak kecepatan / memori / kinerja.

Ikhtisar

Huffman encoding mengambil urutan (stream) dr simbol sebagai masukan & memberikan urutan bit sebagai output. Tujuannya adl untuk menghasilkan output pendek untuk masukan yg diberikan. Setiap masukan menghasilkan output yg berbeda, sehingga proses dapat terbalik, & output dapat diterjemahkan untuk memberikan kembali input asli.

Dalam software ini, simbol adl bilangan bulat non-negatif. Batas simbol satu ditambah simbol diperbolehkan tertinggi. Misalnya, batas simbol 4 berarti bahwa himpunan simbol diizinkan adl {0, 1, 2, 3}.

Contoh Aplikasi

Dua pasang program baris perintah sepenuhnya menunjukkan bagaimana paket perangkat lunak ini dapat digunakan untuk encode & decode data menggunakan Huffman coding. Sepasang program adl kelas HuffmanCompress & HuffmanDecompress, yg mengimplementasikan statis Huffman coding. Pasangan lain dr program adl kelas AdaptiveHuffmanCompress & AdaptiveHuffmanDecompress, yg mengimplementasikan adaptif / dinamis Huffman coding.

Encoder / decoder

Kelas HuffmanEncoder & HuffmanDecoder menerapkan algoritma dasar untuk encoding & decoding aliran Huffman-kode. Pohon kode harus diatur sebelum encoding atau decoding. Pohon kode dapat diubah setelah encoding atau decoding setiap simbol, selama encoder & decoder memiliki pohon kode yg sama pada posisi yg sama dlm aliran simbol. Pada setiap saat, encoder tidak harus mencoba untuk mengkodekan simbol yg tidak di pohon kode.

Kelas Huffman CodeTree

Kelas CodeTree, bersama dg Node, InternalNode, & daun, mewakili kode pohon Huffman. Daun adl simbol. Jalan menuju daun mewakili string bit kode Huffman nya.

Kelas FrequencyTable

Kelas FrequencyTable adl array integer pembungkus sederhana yg penting frekuensi simbol. Hal ini juga bertanggung jawab untuk menghasilkan pohon kode Huffman yg optimal untuk array saat ini frekuensi (tetapi tidak harus kanonik).

Kelas CanonicalCode 

Kelas CanonicalCode mengkonversi sebuah CodeTree sewenang-wenang untuk kode kanonik. Hal ini kemudian dapat menghasilkan CodeTree untuk kode kanonik.

Kelas BitInputStream & BitOutputStream

Kelas BitInputStream & BitOutputStream yg berorientasi bit I / O stream, analog dg bytewise standar I / O stream. Namun, karena mereka menggunakan bytewise mendasari I / O stream, panjang total aliran bit ini selalu kelipatan dr 8 bit.

Keterbatasan

Semua kode Huffman terkait hanya bekerja dg huruf sampai dg Integer.MAX_VALUE - 1 (yaitu 231-2) simbol.

FrequencyTable hanya bisa melacak frekuensi setiap simbol yg hingga Integer.MAX_VALUE. Mencoba untuk kenaikan frekuensi simbol melampaui batas ini menimbulkan pengecualian. Namun, dg menggunakan frekuensi lebih besar dr 231 harus langka dlm praktek.

Kode ini dioptimalkan untuk dimengerti, bukan kinerja. Salah satu konsekuensi adl bahwa CodeTree menggunakan memori terlalu tidak efisien untuk menyimpan string bit kode untuk setiap simbol. Menggunakan ArrayList <Integer> dg biaya minimal 4 byte per diwakili bit, bukan kemasan bit menjadi terpisahkan tipe array primitif seperti byte [].

CodeTree, FrequencyTable, & CanonicalCode eksplisit mengambil batas simbol sebagai parameter. Hal ini tidak sepenuhnya diperlukan, tetapi alternatif adl dg menggunakan tabel jarang, yg lebih sulit untuk memahami.

Beberapa metode menggunakan rekursi untuk melintasi pohon kode secara keseluruhan. Bila menggunakan metode seperti di pohon dalam, StackOverflowError dapat dibuang.

Contoh Program / Source Code

Contoh Program Metode Huffman Statis Dengan Java

HuffmanEncoder.java


package project-graduate.huffmancoding;
import java.io.IOException; import java.util.List; public final class HuffmanEncoder { private BitOutputStream output; // Hasus di inisialisasi sebelum memanggil write(). // Pohon kode dapat berubah setelah setiap simbol dikodekan, // selama encoder & decoder memiliki pohon kode // yg sama pada waktu yg sama. public CodeTree codeTree; public HuffmanEncoder(BitOutputStream out) { if (out == null) throw new NullPointerException("Argument is null"); output = out; } public void write(int symbol) throws IOException { if (codeTree == null) throw new NullPointerException("Code tree is null"); List<Integer> bits = codeTree.getCode(symbol); for (int b : bits) output.write(b); } }

HuffmanDecoder.java


packagex project-graduate.huffmancoding;
import java.io.IOException;
public final class HuffmanDecoder {
 
 private BitInputStream input;
 
 // Harus diinisialisasi sebelum memanggil read().
 // Pohon kode dapat berubah setelah setiap simbol diterjemahkan, 
 // selama encoder & decoder memiliki pohon kode yg sama 
 // pada waktu yg sama.
 
 public CodeTree codeTree;
 
 public HuffmanDecoder(BitInputStream in) {
  if (in == null)
   throw new NullPointerException("Argument is null");
  input = in;
 }
 
 public int read() throws IOException {
  if (codeTree == null)
   throw new NullPointerException("Code tree is null");
  
  InternalNode currentNode = codeTree.root;
  while (true) {
   int temp = input.readNoEof();
   Node nextNode;
   if      (temp == 0) nextNode = currentNode.leftChild;
   else if (temp == 1) nextNode = currentNode.rightChild;
   else throw new AssertionError();
   
   if (nextNode instanceof Leaf)
    return ((Leaf)nextNode).symbol;
   else if (nextNode instanceof InternalNode)
    currentNode = (InternalNode)nextNode;
   else
    throw new AssertionError();
  }
 }
 
}

AdaptiveHuffmanCompress.java


packagex project-graduate.huffmancoding;
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; public final class AdaptiveHuffmanCompress { public static void main(String[] args) throws IOException { // Tampilkan apa argumen baris perintah untuk menggunakan if (args.length == 0) { System.err.println("Usage: java AdaptiveHuffmanCompress InputFile OutputFile"); System.exit(1); return; } // Jika tidak, kompres File inputFile = new File(args[0]); File outputFile = new File(args[1]); InputStream in = new BufferedInputStream(new FileInputStream(inputFile)); BitOutputStream out = new BitOutputStream(new BufferedOutputStream(new FileOutputStream(outputFile))); try { compress(in, out); } finally { out.close(); in.close(); } } static void compress(InputStream in, BitOutputStream out) throws IOException { int[] initFreqs = new int[257]; Arrays.fill(initFreqs, 1); FrequencyTable freqTable = new FrequencyTable(initFreqs); HuffmanEncoder enc = new HuffmanEncoder(out); enc.codeTree = freqTable.buildCodeTree(); // Kita tidak perlu membuat kode kanonik karena kita tidak mengirimkan pohon kode int count = 0; while (true) { int b = in.read(); if (b == -1) break; enc.write(b); freqTable.increment(b); count++; if (count < 262144 && isPowerOf2(count) || count % 262144 == 0) // Update code tree enc.codeTree = freqTable.buildCodeTree(); if (count % 262144 == 0) // Reset frequency table freqTable = new FrequencyTable(initFreqs); } enc.write(256); // EOF } private static boolean isPowerOf2(int x) { return x > 0 && (x & -x) == x; } }

AdaptiveHuffmanDecompress.java


packagex project-graduate.huffmancoding;
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.util.Arrays; public final class AdaptiveHuffmanDecompress { public static void main(String[] args) throws IOException { // Show what command line arguments to use if (args.length == 0) { System.err.println("Usage: java AdaptiveHuffmanDecompress InputFile OutputFile"); System.exit(1); return; } // Otherwise, decompress File inputFile = new File(args[0]); File outputFile = new File(args[1]); BitInputStream in = new BitInputStream(new BufferedInputStream(new FileInputStream(inputFile))); OutputStream out = new BufferedOutputStream(new FileOutputStream(outputFile)); try { decompress(in, out); } finally { out.close(); in.close(); } } static void decompress(BitInputStream in, OutputStream out) throws IOException { int[] initFreqs = new int[257]; Arrays.fill(initFreqs, 1); FrequencyTable freqTable = new FrequencyTable(initFreqs); HuffmanDecoder dec = new HuffmanDecoder(in); dec.codeTree = freqTable.buildCodeTree(); int count = 0; while (true) { int symbol = dec.read(); if (symbol == 256) // EOF symbol break; out.write(symbol); freqTable.increment(symbol); count++; if (count < 262144 && isPowerOf2(count) || count % 262144 == 0) // Update code tree dec.codeTree = freqTable.buildCodeTree(); if (count % 262144 == 0) // Reset frequency table freqTable = new FrequencyTable(initFreqs); } } private static boolean isPowerOf2(int x) { return x > 0 && (x & -x) == x; } }

Pengenalan Wajah JST Backpropagation di C/C++

Contoh Program Pengenalan Wajah JST Backpropagation di C/C++

Pengenalan Wajah JST Backpropagation di C/C++

Sebuah algoritma pembelajaran jaringan saraf tiruan yang disebut Backpropagation adalah salah satu pendekatan yang paling efektif untuk pembelajaran ketika data yang akan diproses berupa masukan sensorik yang kompleks seperti berupa gambar. Tulisan ini menyediakan implementasi dari algoritma Backpropagation untuk pengenalan wajah menggunakan Jaringan Syaraf Tiruan.

Dokumentasi

Dokumentasi ini adalah dalam bentuk proyek C/C++ (tersedia juga dalam bahasa pemrograman Java, Visual Basic, C# dan lainnya yang bisa anda temukan dibeberapa tulisan lainnya mengenai Backpropagation di situs ini). Dokumentasi lengkap akan menyediakan langkah-demi-langkah pengenalan kode dan data, dan petunjuk sederhana tentang cara menjalankan program nya.

Contoh Progam / Source Code

Contoh penerapan program Pengenalan Wajah JST Backpropagation di C/C++

backprop.c




#include <stdio.h>
#include <backprop.h>
#include <math.h>

#define ABS(x)          (((x) > 0.0) ? (x) : (-(x)))

#define fastcopy(to,from,len)\
{\
  register char *_to,*_from;\
  register int _i,_l;\
  _to = (char *)(to);\
  _from = (char *)(from);\
  _l = (len);\
  for (_i = 0; _i < _l; _i++) *_to++ = *_from++;\
}

//  Kembali nomor acak antara 0,0 dan 1,0 
double drnd()
{
  return ((double) random() / (double) BIGRND);
}

//  Kembali nomor acak antara -1.0 dan 1.0 
double dpn1()
{
  return ((drnd() * 2.0) - 1.0);
}

//  Fungsi squashing. Saat ini, itu sigmoid a. 

double squash(x)
double x;
{
  return (1.0 / (1.0 + exp(-x)));
}


//  Alokasikan array 1d ganda 

double *alloc_1d_dbl(n)
int n;
{
  double *new;

  new = (double *) malloc ((unsigned) (n * sizeof (double)));
  if (new == NULL) {
    printf("ALLOC_1D_DBL: Couldn't allocate array of doubles\n");
    return (NULL);
  }
  return (new);
}


//  Alokasikan array 2d ganda 

double **alloc_2d_dbl(m, n)
int m, n;
{
  int i;
  double **new;

  new = (double **) malloc ((unsigned) (m * sizeof (double *)));
  if (new == NULL) {
    printf("ALLOC_2D_DBL: Tidak bisa mengalokasikan array dbl ptrs\n");
    return (NULL);
  }

  for (i = 0; i < m; i++) {
    new[i] = alloc_1d_dbl(n);
  }

  return (new);
}


bpnn_randomize_weights(w, m, n)
double **w;
int m, n;
{
  int i, j;

  for (i = 0; i <= m; i++) {
    for (j = 0; j <= n; j++) {
      w[i][j] = dpn1();
    }
  }
}


bpnn_zero_weights(w, m, n)
double **w;
int m, n;
{
  int i, j;

  for (i = 0; i <= m; i++) {
    for (j = 0; j <= n; j++) {
      w[i][j] = 0.0;
    }
  }
}


void bpnn_initialize(seed)
{
  printf("Nomor acak seed generator: %d\n", seed);
  srandom(seed);
}


BPNN *bpnn_internal_create(n_in, n_hidden, n_out)
int n_in, n_hidden, n_out;
{
  BPNN *newnet;

  newnet = (BPNN *) malloc (sizeof (BPNN));
  if (newnet == NULL) {
    printf("BPNN_CREATE: Tidak bisa mengalokasikan jaringan saraf\n");
    return (NULL);
  }

  newnet->input_n = n_in;
  newnet->hidden_n = n_hidden;
  newnet->output_n = n_out;
  newnet->input_units = alloc_1d_dbl(n_in + 1);
  newnet->hidden_units = alloc_1d_dbl(n_hidden + 1);
  newnet->output_units = alloc_1d_dbl(n_out + 1);

  newnet->hidden_delta = alloc_1d_dbl(n_hidden + 1);
  newnet->output_delta = alloc_1d_dbl(n_out + 1);
  newnet->target = alloc_1d_dbl(n_out + 1);

  newnet->input_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
  newnet->hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);

  newnet->input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
  newnet->hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);

  return (newnet);
}


void bpnn_free(net)
BPNN *net;
{
  int n1, n2, i;

  n1 = net->input_n;
  n2 = net->hidden_n;

  free((char *) net->input_units);
  free((char *) net->hidden_units);
  free((char *) net->output_units);

  free((char *) net->hidden_delta);
  free((char *) net->output_delta);
  free((char *) net->target);

  for (i = 0; i <= n1; i++) {
    free((char *) net->input_weights[i]);
    free((char *) net->input_prev_weights[i]);
  }
  free((char *) net->input_weights);
  free((char *) net->input_prev_weights);

  for (i = 0; i <= n2; i++) {
    free((char *) net->hidden_weights[i]);
    free((char *) net->hidden_prev_weights[i]);
  }
  free((char *) net->hidden_weights);
  free((char *) net->hidden_prev_weights);

  free((char *) net);
}


/*** Menciptakan jaringan sepenuhnya terhubung baru dari awal ***/

BPNN *bpnn_create(n_in, n_hidden, n_out)
int n_in, n_hidden, n_out;
{

  BPNN *newnet;

  newnet = bpnn_internal_create(n_in, n_hidden, n_out);

#ifdef INITZERO
  bpnn_zero_weights(newnet->input_weights, n_in, n_hidden);
#else
  bpnn_randomize_weights(newnet->input_weights, n_in, n_hidden);
#endif
  bpnn_randomize_weights(newnet->hidden_weights, n_hidden, n_out);
  bpnn_zero_weights(newnet->input_prev_weights, n_in, n_hidden);
  bpnn_zero_weights(newnet->hidden_prev_weights, n_hidden, n_out);

  return (newnet);
}


void bpnn_layerforward(l1, l2, conn, n1, n2)
double *l1, *l2, **conn;
int n1, n2;
{
  double sum;
  int j, k;

  //  Mengatur Unit thresholding 
  l1[0] = 1.0;

  //  Untuk setiap unit di lapisan kedua 
  for (j = 1; j <= n2; j++) {

    //  Hitung tertimbang jumlah input 
    sum = 0.0;
    for (k = 0; k <= n1; k++) {
      sum += conn[k][j] * l1[k];
    }
    l2[j] = squash(sum);
  }

}


void bpnn_output_error(delta, target, output, nj, err)
double *delta, *target, *output, *err;
int nj;
{
  int j;
  double o, t, errsum;

  errsum = 0.0;
  for (j = 1; j <= nj; j++) {
    o = output[j];
    t = target[j];
    delta[j] = o * (1.0 - o) * (t - o);
    errsum += ABS(delta[j]);
  }
  *err = errsum;
}


void bpnn_hidden_error(delta_h, nh, delta_o, no, who, hidden, err)
double *delta_h, *delta_o, *hidden, **who, *err;
int nh, no;
{
  int j, k;
  double h, sum, errsum;

  errsum = 0.0;
  for (j = 1; j <= nh; j++) {
    h = hidden[j];
    sum = 0.0;
    for (k = 1; k <= no; k++) {
      sum += delta_o[k] * who[j][k];
    }
    delta_h[j] = h * (1.0 - h) * sum;
    errsum += ABS(delta_h[j]);
  }
  *err = errsum;
}


void bpnn_adjust_weights(delta, ndelta, ly, nly, w, oldw, eta, momentum)
double *delta, *ly, **w, **oldw, eta, momentum;
{
  double new_dw;
  int k, j;

  ly[0] = 1.0;
  for (j = 1; j <= ndelta; j++) {
    for (k = 0; k <= nly; k++) {
      new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j]));
      w[k][j] += new_dw;
      oldw[k][j] = new_dw;
    }
  }
}


void bpnn_feedforward(net)
BPNN *net;
{
  int in, hid, out;

  in = net->input_n;
  hid = net->hidden_n;
  out = net->output_n;

  //  Pakan maju aktivasi input. 
  bpnn_layerforward(net->input_units, net->hidden_units,
      net->input_weights, in, hid);
  bpnn_layerforward(net->hidden_units, net->output_units,
      net->hidden_weights, hid, out);

}


void bpnn_train(net, eta, momentum, eo, eh)
BPNN *net;
double eta, momentum, *eo, *eh;
{
  int in, hid, out;
  double out_err, hid_err;

  in = net->input_n;
  hid = net->hidden_n;
  out = net->output_n;

  
  bpnn_layerforward(net->input_units, net->hidden_units,
      net->input_weights, in, hid);
  bpnn_layerforward(net->hidden_units, net->output_units,
      net->hidden_weights, hid, out);

 //  memproses error output dan unit tersembunyi. 
  bpnn_output_error(net->output_delta, net->target, net->output_units,
      out, &out_err);
  bpnn_hidden_error(net->hidden_delta, hid, net->output_delta, out,
      net->hidden_weights, net->hidden_units, &hid_err);
  *eo = out_err;
  *eh = hid_err;

  //  Mengatur input dan bobot yang tersembunyi. 
  bpnn_adjust_weights(net->output_delta, out, net->hidden_units, hid,
      net->hidden_weights, net->hidden_prev_weights, eta, momentum);
  bpnn_adjust_weights(net->hidden_delta, hid, net->input_units, in,
      net->input_weights, net->input_prev_weights, eta, momentum);

}

void bpnn_save(net, filename)
BPNN *net;
char *filename;
{
  int fd, n1, n2, n3, i, j, memcnt;
  double dvalue, **w;
  char *mem;

  if ((fd = creat(filename, 0644)) == -1) {
    printf("BPNN_SAVE: Tidak dapat membuat '%s'\n", filename);
    return;
  }

  n1 = net->input_n;  n2 = net->hidden_n;  n3 = net->output_n;
  printf("Saving %dx%dx%d network to '%s'\n", n1, n2, n3, filename);
  fflush(stdout);

  write(fd, (char *) &n1, sizeof(int));
  write(fd, (char *) &n2, sizeof(int));
  write(fd, (char *) &n3, sizeof(int));

  memcnt = 0;
  w = net->input_weights;
  mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));
  for (i = 0; i <= n1; i++) {
    for (j = 0; j <= n2; j++) {
      dvalue = w[i][j];
      fastcopy(&mem[memcnt], &dvalue, sizeof(double));
      memcnt += sizeof(double);
    }
  }
  write(fd, mem, (n1+1) * (n2+1) * sizeof(double));
  free(mem);

  memcnt = 0;
  w = net->hidden_weights;
  mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));
  for (i = 0; i <= n2; i++) {
    for (j = 0; j <= n3; j++) {
      dvalue = w[i][j];
      fastcopy(&mem[memcnt], &dvalue, sizeof(double));
      memcnt += sizeof(double);
    }
  }
  write(fd, mem, (n2+1) * (n3+1) * sizeof(double));
  free(mem);

  close(fd);
  return;
}


BPNN *bpnn_read(filename)
char *filename;
{
  char *mem;
  BPNN *new;
  int fd, n1, n2, n3, i, j, memcnt;

  if ((fd = open(filename, 0, 0644)) == -1) {
    return (NULL);
  }

  printf("Reading '%s'\n", filename);  fflush(stdout);

  read(fd, (char *) &n1, sizeof(int));
  read(fd, (char *) &n2, sizeof(int));
  read(fd, (char *) &n3, sizeof(int));
  new = bpnn_internal_create(n1, n2, n3);

  printf("'%s' contains a %dx%dx%d network\n", filename, n1, n2, n3);
  printf("Reading input weights...");  fflush(stdout);

  memcnt = 0;
  mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));
  read(fd, mem, (n1+1) * (n2+1) * sizeof(double));
  for (i = 0; i <= n1; i++) {
    for (j = 0; j <= n2; j++) {
      fastcopy(&(new->input_weights[i][j]), &mem[memcnt], sizeof(double));
      memcnt += sizeof(double);
    }
  }
  free(mem);

  printf("Selesai\nmembaca bobot tersembunyi...");  fflush(stdout);

  memcnt = 0;
  mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));
  read(fd, mem, (n2+1) * (n3+1) * sizeof(double));
  for (i = 0; i <= n2; i++) {
    for (j = 0; j <= n3; j++) {
      fastcopy(&(new->hidden_weights[i][j]), &mem[memcnt], sizeof(double));
      memcnt += sizeof(double);
    }
  }
  free(mem);
  close(fd);

  printf("Selesai\n");  fflush(stdout);

  bpnn_zero_weights(new->input_prev_weights, n1, n2);
  bpnn_zero_weights(new->hidden_prev_weights, n2, n3);

  return (new);
}


Pengenalan Wajah JST Backpropagation di C/C++




Algoritma JST Backpropagation C/C++

Contoh Program Algoritma JST Backpropagation C/C++

Algoritma JST Backpropagation C/C++

Backpropagation

Pengertian Backpropagation adl sebuah metode sistematik pd jaringan saraf tiruan dng memakai algoritma pembelajaran yg terawasi & biasanya dipakai oleh perceptron dng banyak layar lapisan unt mengubah bobot-bobot yg ada pd lapisan tersembunyinya. Backpropagation adl pelatihan jenis terkontrol dimana memakai pola penyesuaian bobot unt mencapai nilai kesalahan yg minimum antara keluaran hasil prediksi dng keluaran yg nyata.

Algoritma JST Backpropagation C/C++
Algoritma JST Backpropagation C/C++


Arsitektur algoritma backpropagation terdiri dr tiga layer, yaitu input layer, hidden layer & output layer. pd input layer tidak terjadi proses komputasi, namun terjadi pengiriman sinyal input X ke hidden layer. pd hidden & output layer terjadi proses komputasi terhadap bobot & bias & dihitung pula besarnya output dr hidden & output layer tersebut berdasarkan fungsi aktivasi tertentu. dlm algoritma backpropagation ini dipakai fungsi aktivasi sigmoid biner, sebab output yg diharapkan mempunyai nilai antara 0 sampai 1.

Beberapa faktor yg mempengaruhi keberhasilan algoritma backpropagation, antara lain:

 Inisialisasi bobot

Bobot awal menentukan apakah jaringan akan mencapai global minima atau local minima kesalahan, & seberapa cepat jaringan akan konvergen.

Laju pembelajaran

Laju pembelajaran adl parameter jaringan dlm mengendalikan proses penyesuaian bobot.  Nilai laju pembelajaran yg optimal bergantung pd kasus yg dihadapi.  Laju pembelajaran yg terlalu kecil menyebabkan konvergensi jaringan mjd lebih lambat, sedang laju pembelajaran yg terlalu besar dpt menyebabkan ketidakstabilan pd jaringan.

Momentum

Momentum dipakai unt mempercepat pelatihan jaringan.  Metode momentum melibatkan penyesuaian bobot ditambah dng faktor tertentu dr penyesuaian sebelumnya.  Penyesuaian ini dinyatakan sbg berikut:

Update bobot dng momentum dirumuskan sbg berikut :
  wjk(t+1) = wjk(t) + Dwjk  + h Dwjk(t-1)
  vij(t+1) = vij(t) + Dvij + h Dvij(t-1)        
Sesuai dng namanya, algoritma ini melakukan 2 tahap komputasi yaitu : perhitungan maju (feedforward) & perhitungan mundur (backward), dlm setiap iterasinya, jaringan akan memperbaiki nilai-nilai bobot & bias pd semua neuron yg ada di jaringan.

Algoritma Backpropagation adl salah satu algoritma yg memakai metode terawasi (supervised learning), & termasuk jaringan MLP (Multi Layer Perceptron).

Algoritma JST Backpropagation C/C++
Jaringan Multi Layer Perpceptron : Algoritma JST Backpropagation C/C++
Algoritma Pembelajaran Backpropagation : 

● Inisialisasi semua input, target, bobot awal, bias awal & target keluaran. 
● Inisialisasi Epoch. 
● Inisialisasi learning rate, maximum error. 

Feedforward: 

○ Hitung   nilai   masukan   pd   tiap   pasangan   elemen   input   pd   hidden  layer  dng  formula :


○ Jika kita memakai fungsi aktivasi sigmoid, hitung output dng : 


○ Hitung   sinyal   keluaran   dr  hidden   layer  unt   memperolah   keluaran output   layer  dng memakai persamaan :


○ Jika kita memakai fungsi aktivasi sigmoid, hitung output dng : 

○ Kemudian, keluaran jaringan dibandingkan dng target, hitung error E dng :


○ Hitung MSE (Mean Square Error) :


dng n adl jumlah input masukan.

○ pd tiap unit output, gunakan formula ini  unt memperbaiki nilai bobot & bias : 


○ Perbaiki nilai bobot & bias dng memakai formula : 


○ Hitung sinyal balik dr output layer pd tiap unit di hidden layer


○ pd tiap unit hidden layer, hitung  delta_1 unt memperbaiki nilai bobot & bias :


○ Perbaiki nilai bobot & bias dng memakai formula :


○ unt semua layer, perbaiki bobot & bias :


○ Hitung MSE (Mean Square Error) dng memakai formula : 

engan n adl jumlah input masukan. 

○ Jika (Epoch < maximum Epoch) atau (MSE < Target Error), ulangi langkah pelatihan.

Contoh Program Algoritma JST Backpropagation C/C++

Algoritma JST Backpropagation C/C++
Algoritma JST Backpropagation C/C++

Bagaimana cara menerapkan Backpropagation Neural Network dng C ++?

neuralnet.cpp:




#include "backprop.h"
#include <cstdlib>

using namespace std;

double toInt(const double& lfIn)
{
   if (lfIn > 0.5)
    return ceil(lfIn);
   else if (lfIn < 0.5)
    return floor(lfIn);
}

int main(int argc, char* argv[])
{


    // mempersiapkan XOR Data traing
    double data[][3/*4*/]={
    0,    0,    0,
    0,    1,    1,
    1,    0,    1,
    1,    1,    0 };
 
    // 0,    0,    0,    0,
    // 0,    0,    1,    1,
    // 0,    1,    0,    1,
    // 0,    1,    1,    0,
    // 1,    0,    0,    1,
    // 1,    0,    1,    0,
    // 1,    1,    0,    0,
    // 1,    1,    1,    1 };

    // Mempersiapkan data percobaan
    double testData[][2/*3*/]={
       1,    0,
       0,    0.87,
       1,    0.08,
       0.35,    1};

    // 0,      0,      0,
    // 0,      0,      1,
    // 0,      1,      0,
    // 0,      1,      1,
    // 1,      0,      0,
    // 1,      0,      1,
    // 1,      1,      0,
    //  1,      1,      1};

    
    // mendefinisikan jaring dng 4 lapisan 
 // memiliki 3,3,3, & 1 neuron masing-masing,
    // lapisan pertama adl lapisan masukan 
 // yaitu hanya pemegang unt parameter input
    // & harus mjd ukuran yg sama dng 
 // tidak ada parameter masukan, di luar contoh 3
 
    int numLayers = 4, lSz[4] = {2,2,2,1};

    
    // Learing rate - beta
    // momentum - alpha
 // Threshhold - thresh  (nilai target mse, pelatihan berhenti setelah tercapai)
 
    double beta = 0.3, alpha = 0.1, Thresh =  0.0000000001;

    
    // Jumlah maksimum iterasi selama pelatihan
    long num_iter = 2000000;
    long i;

    
    // Membuat jaringan
    CBackProp *bp = new CBackProp(numLayers, lSz, beta, alpha);
    
    cout<< endl <<  "Sekarang melatih jaringan...." << endl;    
    for (i=0; i<num_iter ; i++)
    {
        
        bp->bpgt(data[i%4/*8*/], &data[/*i%8*/i%4][/*3*/2]);

        if( bp->mse(&data[/*i%8*/i%4][/*3*/2]) < Thresh) {
            cout << endl << "Jaringan terlatih. Nilai ambang dicapai dlm " << i << " iterations." << endl;
            cout << "MSE:  " << bp->mse(&data[/*i%8*/i%4][/*3*/2]) 
                 <<  endl <<  endl;
            break;
        }
        if ( i%(num_iter/10) == 0 )
            cout<<  endl <<  "MSE:  " << bp->mse(&data[/*i%8*/i%4][/*3*/2]) 
                << "... Training..." << endl;

    }
    
    if ( i == num_iter )
        cout << endl << i << " iterasi selesai..." 
        << "MSE: " << bp->mse(&data[(i-1)/*%8*/%4][/*3*/2]) << endl;      


   // Ini bagian Mapping

    cout<< "Now using the trained network to make predctions on test data...." << endl << endl;    
    for ( i = 0 ; i < 4/*8*/ ; i++ )
    {
        bp->ffwd(testData[i]);
        cout << testData[i][0]<< "  " << testData[i][1]<< "  " /*( << testData[i][2]<< "  "*/ << /*toInt(*/bp->Out(0)/*)*/ << endl;
    }

    return 0;
}



backprop.h:





#ifndef backprop_h
#define backprop_h

#include <cassert>
#include <iostream>
#include <cstdio>
#include <cmath>


class CBackProp{

//  output dr setiap neuron

    double **out;

//  Nilai delta error unt setiap neuron
    double **delta;

//  bobot unt setiap neuron
    double ***weight;

//  Jumlah layer di jaringan
    int numl;

//  Jumlah elemen pd layer
    int *lsize;

//  learning rate
    double beta;

//  momentum parameter
    double alpha;

//  Penyimpanan unt bobot
    double ***prevDwt;

//  fungsi squashing
    double sigmoid(double in);

public:

    ~CBackProp();

//  mengalokasikan memori
    CBackProp(int nl,int *sz,double b,double a);

//  unt memproses kesalahan unt satu set input
    void bpgt(double *in,double *tgt);

//  meneruskan aktivasi unt satu set input
    void ffwd(double *in);

//  mengembalikan nilai error jaringan
    double mse(double *tgt) const;    
    
//  mengembalikan output jaringan
    double Out(int i) const;
};

#endif



backprop.cpp:




#include "backprop.h"
#include <ctime>
#include <cstdlib>


// menginisialisasi & mengalokasikan memori di heap
CBackProp::CBackProp(int nl,int *sz,double b,double a):beta(b),alpha(a)
{

    // set jumlah & ukuran layer
    numl=nl;
    lsize=new int[numl];

    for(int i=0;i<numl;i++){
        lsize[i]=sz[i];
    }

    // alokasi memory output tiap neuron
    out = new double*[numl];

    for(int i=0;i<numl;i++){
        out[i]=new double[lsize[i]];
    }

    // alokasi delta memori
    delta = new double*[numl];

    for(int i=1;i<numl;i++){
        delta[i]=new double[lsize[i]];
    }

    //  alokasi memori unt bobot
    weight = new double**[numl];

    for(int i=1;i<numl;i++){
        weight[i]=new double*[lsize[i]];
    }
    for(int i=1;i<numl;i++){
        for(int j=0;j<lsize[i];j++){
            weight[i][j]=new double[lsize[i-1]+1];
        }
    }

    //  alokasi memori unt bobot sebelumnya
    prevDwt = new double**[numl];

    for(int i=1;i<numl;i++){
        prevDwt[i]=new double*[lsize[i]];

    }
    for(int i=1;i<numl;i++){
        for(int j=0;j<lsize[i];j++){
            prevDwt[i][j]=new double[lsize[i-1]+1];
        }
    }

    //  menetapkan bobot acak
    srand((unsigned)(time(NULL)));
    for(int i=1;i<numl;i++)
        for(int j=0;j<lsize[i];j++)
            for(int k=0;k<lsize[i-1]+1;k++)
                weight[i][j][k]=(double)(rand())/(RAND_MAX/2) - 1;//32767

    // inisialisasi bobot sebelumnya unt 0 unt iterasi pertama
    for(int i=1;i<numl;i++)
        for(int j=0;j<lsize[i];j++)
            for(int k=0;k<lsize[i-1]+1;k++)
                prevDwt[i][j][k]=(double)0.0;

}



CBackProp::~CBackProp()
{
    int i;

    for(i=0;i<numl;i++)
        delete[] out[i];
    delete[] out;

    for(i=1;i<numl;i++)
        delete[] delta[i];
    delete[] delta;

    for(i=1;i<numl;i++)
        for(int j=0;j<lsize[i];j++)
            delete[] weight[i][j];
    for(i=1;i<numl;i++)
        delete[] weight[i];
    delete[] weight;

    for(i=1;i<numl;i++)
        for(int j=0;j<lsize[i];j++)
            delete[] prevDwt[i][j];
    for(i=1;i<numl;i++)
        delete[] prevDwt[i];
    delete[] prevDwt;

    delete[] lsize;
}

//  Funsi sigmoid
double CBackProp::sigmoid(double in)
{
        return (double)(1/(1+exp(-in)));
}

// mean square error
double CBackProp::mse(double *tgt) const
{
    double mse=0;
    for(int i=0;i<lsize[numl-1];i++){
        mse+=(tgt[i]-out[numl-1][i])*(tgt[i]-out[numl-1][i]);
    }
    return mse/2;
}


// mengembalikan output dr jaringan
double CBackProp::Out(int i) const
{
    return out[numl-1][i];
}


void CBackProp::ffwd(double *in)
{
    double sum;
    int i;

    // menetapkan konten unt input layer
    for(i=0;i<lsize[0];i++)
        out[0][i]=in[i];  // output_from_neuron(i,j) Jth neuron in Ith Layer

    // menetapkan keluaran (aktivasi) nilai
    // unt setiap neuron memakai fungsi sigmoid
    for(i=1;i<numl;i++){                
        for(int j=0;j<lsize[i];j++){    
            sum=0.0;
            for(int k=0;k<lsize[i-1];k++){
                sum+= out[i-1][k]*weight[i][j][k];
            }
            sum+=weight[i][j][lsize[i-1]];        
            out[i][j]=sigmoid(sum);               
        }
    }
}


// Memproses kesalahan dr lapisan output 
// sampai lapisan tersembunyi pertama
void CBackProp::bpgt(double *in,double *tgt)
{
    double sum;
    int i;

    // Update nilai output dr setiap neuron
    ffwd(in);

    // menemukan delta unt lapisan output
    for(i=0;i<lsize[numl-1];i++){
        delta[numl-1][i]=out[numl-1][i]*
        (1-out[numl-1][i])*(tgt[i]-out[numl-1][i]);
    }

    // menemukan delta unt lapisan tersembunyi  
    for(i=numl-2;i>0;i--){
        for(int j=0;j<lsize[i];j++){
            sum=0.0;
            for(int k=0;k<lsize[i+1];k++){
                sum+=delta[i+1][k]*weight[i+1][k][j];
            }
            delta[i][j]=out[i][j]*(1-out[i][j])*sum;
        }
    }

    // menerapkan momentum (tidak melakukan apa-apa jika alpha = 0)
    for(i=1;i<numl;i++){
        for(int j=0;j<lsize[i];j++){
            for(int k=0;k<lsize[i-1];k++){
                weight[i][j][k]+=alpha*prevDwt[i][j][k];
            }
            weight[i][j][lsize[i-1]]+=alpha*prevDwt[i][j][lsize[i-1]];
        }
    }

    // menyesuaikan bobot usng steepest descent
    for(i=1;i<numl;i++){
        for(int j=0;j<lsize[i];j++){
            for(int k=0;k<lsize[i-1];k++){
                prevDwt[i][j][k]=beta*delta[i][j]*out[i-1][k];
                weight[i][j][k]+=prevDwt[i][j][k];
            }
            prevDwt[i][j][lsize[i-1]]=beta*delta[i][j];
            weight[i][j][lsize[i-1]]+=prevDwt[i][j][lsize[i-1]];
        }
    }
}



Pengenal Ucapan Algoritma MFCC dan ANFIS di MATLAB

Contoh Program Pengenal Ucapan Algoritma MFCC dan ANFIS di MATLAB

Pengenal Ucapan Algoritma MFCC dan ANFIS di MATLAB

Penelitian ini mengimplementasikan bagaimana mengenali ucapan dari pembicara (speaker dependent) dengan memakai algoritma MFCC sbg ekstraksi ciri dan ANFIS untuk klasifikasinya. Untuk mengurangi jumlah aturan pada ANFIS maka digunakan Fuzzy C Mean. Penelitian ini terbilang berhasil dengan tingkat keberhasilan tinggi walau dalam masa pelatihan membutuhkan waktu.

Program Pengenal Ucapan Algoritma MFCC dan ANFIS Dengan MATLAB

Berikut ini potongan kecil dari program sebagai implementasi dari flowchart program:

Pengenal Ucapan Algoritma MFCC dan ANFIS
Pengenal Ucapan Algoritma MFCC dan ANFIS Dengan Matlab

Pengenal Ucapan Algoritma MFCC dan ANFIS
Pengenal Ucapan Algoritma MFCC dan ANFIS Dengan Matlab

ANFIS Dengan MATLAB

Contoh Program ANFIS Dengan MATLAB

ANFIS Dengan MATLAB

ANFIS

ANFIS / Adaptive Neuro Fuzzy Inference System mrp metode hasil persilangan antara metode Fuzzy dg metode Jaringan Syaraf Tiruan (JST). Oleh karenanya, ANFIS juga dikenal dg sebutan metode hibrida. ANFIS membuat rule berdasarkan data yg di training melalui mekanisme mirip dg jaringan syaraf tiruan.

Metode yg diprakarsai oleh Takagi, Sugeno & Kang (TSK) pd tahun 1985 ini bertujuan unt memperoleh rule yg berasal dari hubungan antara masukan & keluaran suatu system. Prinsip dasarnya mrp :
If x is A and y is B then z = f(x,y)
Dimana, A & B mrp set Fuzzy sedangkan z mrp fungsi dlm bentuk crisp (bukan fuzzy). Sebenarnya, prinsip kerja dari ANFIS hamper serupa dg Jaringan Syaraf Tiruan, dimana unt membentuk suatu model diperlukan data training beserta targetnya (supervised learning). Hasil pembelajaran JST mrp jaringan yg memiliki bobot (weight), sedangkan ANFIS akan menghasilkan Fuzzy Inference System yg telah memiliki rule-based. ANFIS Dengan MATLAB

Sistem Adaptif Neuro Fuzzy

Adaptive Neuro-Fuzzy Inference System (ANFIS) mrp penggabungan mekanisme sistem inferensi fuzzy yg digambarkan dlm arsitektur jaringan syaraf. Sistem adaptif neuro fuzzy berbasis inferensi fuzzy memiliki 2 parameter; yaitu parameter premis & konsekuensi. dlm pelatihan ini dilakukan 2 arah yaitu langkah maju & langkah balik.  Berikut ini ditunjukkan contoh mekanisme inferensi fuzzy Tagaki-Sugeno-Kang (TSK)  orde satu dg 2 masukan x & y (Gambar 13.6). Basis aturan dg 2 aturan fuzzy if-then sbg berikut:

Rule 1 :     if    x is A1 and y is B1      then       f1 = p1x + q1y + r1
                       premis                                        consequent
Rule 2 :     if    x is A2 and y is B2      then       f2 = p2x + q2y + r2
                       premis                                        consequent
Input : x & y.  Consequent-nya mrp f

ANFIS Dengan MATLAB
ANFIS Dengan MATLAB

Pada suatu masukan crisp (tidak fuzzy) x & y. x mrp harga variabel yg dikontrol yaitu pd saat ke t, & y pengukuran pd saat ke t+1 sedangkan f mrp nilai tegangan yg diberikan sbg sinyal kontrol. Harga x & y tsb jelas bukan fuzzy. Lalu nilai x & y tsb dipetakan pd funggsi keanggotaannya.
Tiap input dibagi jadi 2 fungsi keanggotaan, x dibagi dlm A1 & A2. A1 menyatakan small & A2 menyatakan big. Begitu juga y dibagi dlm fungsi keanggotaan B1 yg menyatakan small & B2 yg menyatakan big.

Dari pemetaan tsb x & y sudah jadi variabel fuzzy yg masing-masing punya nilai small & big tertentu. Variabel x memiliki nilai mA1 & mA2 sedangkan y punya nilai mB1 & mB2. Nilai masing-masing pasangan masukan tsb diagregasi dg operasi T-norm, misalnya operasi AND. Jadi w1 = (mA1 AND mA2) sedangkan w2 = (mB1 AND mB2). Dari basis aturan yg sudah dibuat, diketahui:
if   w  =  w1    then   f1    =   p1x + q1y + r1
if   w  =  w2    then   f2    =   p2x + q2y + r2
Jadi hasil akhirnya mrp f1 & f2, yg mrp nilai keluaran sinyal control.

Paramter p1, q1, r1, p2, q2, & r2 namanya parameter konsekuen yg ditentukan dg nilai awal tertentu & akan berubah dg pembelajaran (algoritma belajar). Selanjutnya dari nilai f1 & f2 ini kita perlu mendapatkan satu nilai tegangan sbg sinyal kontrol. Nah nilai akhir tsb dihitung dg persamaan:

ANFIS Dengan MATLAB
ANFIS Dengan MATLAB
Ini yg disebut sbg defuzzyfikasi. Rumus tsb diperoleh dari metode rata-rata tengah (centroid).

Arsitektur ANFIS

Struktur ANFIS yg menggambarkan sistem fuzzy TSK ditunjukan pd Gambar 13.7, yg dikenal sbg arsitektur jaringan syaraf feedforward seperti ini. Diagram blok terdiri dari lima lapis, & pd setiap lapis terdapat node. Terdapat 2 macam node yaitu node adaptif & node tetap.

ANFIS Dengan MATLAB
ANFIS Dengan MATLAB




Fungsi dari setiap lapis mrp sbg berikut (Widodo, Thomas Sri; 2005):

Lapis 1 :

Setiap node i pd lapis 1 ini mrp node adaptif dg fungsi node sbg berikut:
O1i = mAi(x) unt i = 1, 2 dan
O1i = mBi-2(y) unt i = 3, 4
Dengan x & y mrp masukan pd simpul i, Ai (atau Bi-2) mrp fungsi keanggotaan masing-masing simpul yg mrp label linguistik yg terkait dg node tersebut. Simpul O1,i berfungsi unt menyatakan derajat keanggotaan tiap masukan thd himpunan fuzzy A1, A2, atau B1, B2. Fungsi keanggotaan yg dipakai mrp jenis generalized bell (gbell). Parameter a, b, c, pd fungsi keanggotaan gbell dinamakan parameter premis yg adaptif. Fungsi keanggotaan fuzzy input (premis) yg digunakan mrp fungsi Generalized-Bell:

ANFIS Dengan MATLAB
ANFIS Dengan MATLAB

Fungsi Generalized-Bell akan dipakai sbg fungsi keanggotaan dari masukan, & ditentukan sekehendak sbg parameter awal a, b, c & jumlah himpunan fuzzy input. Nantinya parameter premis a,b,c akan diubah dg cara pembelajaran.

Lapis 2

Semua simpul pd lapisan ini mrp nonadaptif (parameter tetap). Fungsi simpul ini mrp mengalikan setiap sinyal masukan yg datang. Fungsi simpul:
O2i = wi = mAi(x).m Bi(y), i = 1,2                                                                
Setiap node dari lapis ini menyatakan kuat penyulutan dari aturan.

Lapis 3

Tiap keluaran simpul menyatakan derajat pengaktifan  tiap aturan fuzzy. Fungsi ini dapat diperluas apabila bagian premis memiliki lebih dari 2 himpunan fuzzy. Banyaknya simpul pd lapisan ini menunjukkan banyaknya aturan yg dibentuk. Fungsi perkalian yg digunakan mrp kata hubung and dg menggunakan operator t-norm.

Setiap simpul pd lapisan ini mrp nonadaptif yg menampilkan fungsi derajat pengaktifan ternomalisasi (normalized firing strength) yaitu rasio keluaran simpul ke-i pd lapisan sebelumnya thd seluruh keluaran lapisan sebelumnya, dg bentuk fungsi simpul:

Contoh Program ANFIS Dengan MATLAB
Contoh Program ANFIS Dengan MATLAB

Apabila dibentuk lebih dari 2 aturan, fungsi dapat diperluas dg membagi wi dg jumlah total w unt semua aturan. Keluaran lapis ini disebut kuat penyulutan ternormalisasi

Lapis 4

Setiap node pd lapis ini mrp node adaptif dg fungsi node:
O4,i = wi fi = wi(pix + qiy + ri )                                                                   
Dengan
Wi            :  kuat penyulutan ternormalisasi dari lapis 3
(pi, qi, ri ) :  himpunan parameter dari node. Parameter pd lapis ini dise-but sbg parameter konsekuensi yg adaptif.

Lapis 5

Node tunggal pd lapis ini mrp node tetap berlabel £ yg menghitung keluaran keseluruhan sbg penjumlahan semua sinyal yg datang. Fungsi simpul:

Contoh Program ANFIS Dengan MATLAB
Contoh Program ANFIS Dengan MATLAB

Jaringan adaptif dg lima lapisan tsb ekivalen dg sistem inferensi fuzzy TSK.

Langkah Percobaan ANFIS

1. Berikutnya, lakukan pembuatan program seperti berikut & kemudian jalankan.



x = (0:0.1:10); y = sin(2*x)./exp(x/5);
trnData = [x y];
numMFs = 5;
mfType = 'gbellmf';
epoch_n = 20;
in_fismat = genfis1(trnData,numMFs,mfType);
out_fismat = anfis(trnData,in_fismat,20);
plot(x,y,x,evalfis(x,out_fismat));
legend('Training Data','ANFIS Output');


jelaskan hasil tampilannya?.

Ulangi unt program berikut:



x = (0:0.1:10)';
z = 0.1*sin(200*x)           % noise
y = sin(2*x)./exp(x/5)+z;  % sinyal + noise
trnData = [x y];
numMFs = 5;
mfType = 'gbellmf';
epoch_n = 20;
in_fismat = genfis1(trnData,numMFs,mfType);
out_fismat = anfis(trnData,in_fismat,20);
plot(x,y,x,evalfis(x,out_fismat));
 legend('Training Data','ANFIS Output');




jelaskan hasil tampilannya?.

Ulangi unt program berikut:



x = (0:0.1:10);
z = 0.1*sin(200*x)            % noise
y = sin(2*x)./exp(x/5)+z;  % sinyal + noise
trnData = [x y];
numMFs = 5;
mfType = 'gbellmf';
epoch_n = 20000;
in_fismat = genfis1(trnData,numMFs,mfType);
out_fismat = anfis(trnData,in_fismat,20);
plot(x,y,x,evalfis(x,out_fismat));
legend('Training Data','ANFIS Output');


jelaskan hasil tampilannya?.

2. Berikutnya, lakukan pembuatan program seperti berikut & kemudian jalankan.



x=0:0.1:5;
mfp1 = [1 2 3];
mfp2 = mf2mf(mfp1,'gbellmf','trimf');
plot(x,gbellmf(x,mfp1),x,trimf(x,mfp2))


jelaskan hasil tampilannya?.

2. Berikutnya, lakukan pembuatan program seperti berikut & kemudian jalankan.



for t=118:1117,
Data(t-117,:)=[x(t-18) x(t-12) x(t-6) x(t) x(t+6)];
end
trnData=Data(1:500, :);chkData=Data(501:end, :);
fismat = genfis1(trnData);
subplot(2,2,1)
plotmf(fismat,' input', 1)
subplot(2,2,2)
plotmf(fismat,' input', 2)
subplot(2,2,3)
plotmf(fismat,' input', 3)
subplot(2,2,4)
plotmf(fismat,' input', 4)


jelaskan hasil tampilannya?.

3. Berikutnya sebuah program yg harus anda coba, tapi sebelumnya anda harus menyiapkan hal-hal sbg berikut:

1) buat sebuah file gambar & beri nama: 'GambarParameter.jpg' & ‘Gambar_Tunggu.jpg’, simpan   pd work dari MATLAB.
2)  Buat file data dg nama DataPelatihan1 DataPelatihan2, DataPelatihan3,  DataPelatihan4, DataTarget.
3) buat program dg nama Proses_Anfis.m, seperti ditunjukkan pd program di bawah. simpan pd work dari MATLAB.
4) Lalu buat program seperti berikut ini dg nama: Anfis_Parameter.m, & jalankan.




%--------------------------------------------------------
% Nama File : Anfis_Parameter.m
%--------------------------------------------------------

winAnfisProses=figure(...
   'unit','point','position',[230 130 410 310],...
   'color',[.8 .8 .9],'menubar','none','resize','on',...
   'numbertitle','off','name','Paramter Anfis',...
   'WindowStyle','normal');
grafikAnfis21=axes('parent',winAnfisProses,...
   'units','point','position',[0 0 410 310],...
   'xgrid','on','ygrid','on','xcolor',[.8 .8 .9 ],...
   'ycolor',[.8 .8 .9 ],'fontsize',10,...
   'color',[.8 .8 .9]),'backgroundColor',[.8 .8 .9];
editInputWav1=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[330 5 70 15],...
   'backgroundColor',[.5 .8 1],'string','JALANKAN',...
   'fontname','fixedsys','fontsize',9,'callback','Proses_Anfis');
editAnfis23=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[143 198 60 18],'Style','Text',... 
   'backgroundColor',[1 1 1],'string','numMFs',...
   'fontname','arial black','fontsize',10)
editAnfis24=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[205 198 60 17],...
   'Style','Edit','backgroundColor',[.2 .9 .2],...
   'string','2','fontname','arial black','fontsize',10);
editAnfis25=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[143 180 60 18],'Style','Text',... 
   'backgroundColor',[1 1 1],'string','mfType',...
   'fontname','arial black','fontsize',10)
editAnfis26=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[205 180 60 17],...
   'Style','Edit','backgroundColor',[.2 .9 .2],...
   'string','gbellmf','fontname','arial black','fontsize',10);
editAnfis27=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[118 163 85 17],'Style','Text',... 
   'backgroundColor',[1 1 1],'string','num_epochs',...
   'fontname','arial black','fontsize',10)
editAnfis28=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[205 163 60 17],...
   'Style','Edit','backgroundColor',[.2 .9 .2],...
   'string','500','fontname','arial black','fontsize',10);
editAnfis29=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[139 146 65 18],'Style','Text',... 
   'backgroundColor',[1 1 1],'string','err_goal',...
   'fontname','arial black','fontsize',10)
editAnfis20=uicontrol('parent',winAnfisProses,...
   'unit','point','position',[205 146 60 17],...
   'Style','Edit','backgroundColor',[.2 .9 .2],...
   'string','0.001','fontname','arial black','fontsize',10);
[a,MAP]=IMREAD('GambarParameter.jpg'); image(a); grid off;



Program ke 2 yg harus anda simpan terlebih dahulu dlm work dari MATLAB.




%-----------------------------------------------------------------------------------------
% Nama File : Proses_Anfis.m
%-----------------------------------------------------------------------------------------
Anfis1=str2num(get(editAnfis24Baru,'String')); num_mf = Anfis1;
Anfis2=get(editAnfis26Baru,'String');          mf_type= Anfis2;
Anfis3=str2num(get(editAnfis28Baru,'String')); num_epochs= Anfis3;
Anfis4=str2num(get(editAnfis20Baru,'String')); err_goal= Anfis4;
pilihanAnfisBaru=(get(editAnfis22Baru,'Value'));
load DataPelatihan1;DataLatih1=DataPelatihan1;
load DataPelatihan2;DataLatih2=DataPelatihan2;
load DataPelatihan3;DataLatih3=DataPelatihan3;
load DataPelatihan4;DataLatih4=DataPelatihan4;
load DataTarget;DataTarget=DataTarget;
t=length(DataTarget);ii=1:1:t;i=find(ii<=250);
u=DataLatih1(i);v=DataLatih2(i);w=DataLatih3(i);x=DataLatih4(i);
y=DataTarget(i);v=v(i);x=x(i);
pp=DataBaru1(i); qq=DataBaru2(i);rr=DataBaru3(i); ss=DataBaru4(i);
tt=DataCek(i)
trnData=[ u v w x y ];chkData=[ pp qq rr ss tt];
% Initialise the system matrix
close('Anfis_Parameter');
winAnfisProses1=figure('unit','point','position',[30 390 650 150],...
   'color',[.4 .8 .2],'menubar','none','resize','on',...
   'numbertitle','off','name','Data Masukan ANFIS',...
   'WindowStyle','normal');axis off;
subplot(1,4,1);plot(u,'r','linewidth',2);set(gca,'color',[.8 .6 .2]);
subplot(1,4,2);plot(v,'g','linewidth',2);set(gca,'color',[.8 .6 .2]);
subplot(1,4,3);plot(w,'b','linewidth',2);set(gca,'color',[.8 .6 .2]);
subplot(1,4,4);plot(x,'y','linewidth',2); set(gca,'color',[.8 .6 .2]);
winAnfisProses2=figure('unit','point','position',[30 200 650 150],...
   'color',[.8 .8 0],'menubar','none','resize','on',...
   'numbertitle','off','name','Fungsi Keanggotaan Awal',...
   'WindowStyle','normal');
fismat = genfis1(trnData,num_mf,mf_type);
subplot(1,4,1); plotmf(fismat, 'input', 1);set(gca,'color',[.8 .6 .6]);
subplot(1,4,2); plotmf(fismat, 'input', 2);set(gca,'color',[.8 .6 .6]);
subplot(1,4,3); plotmf(fismat, 'input', 3);set(gca,'color',[.8 .6 .6]);
subplot(1,4,4); plotmf(fismat, 'input', 4);set(gca,'color',[.8 .6 .6]);
close('Fungsi Keanggotaan Awal');
winAnfisProses3=figure('unit','point','position',[30 250 650 150],...
   'color',[.8 .8 0],'menubar','none','resize','on',...
   'numbertitle','off','name','Fungsi Keanggotaan Awal1',...
   'WindowStyle','normal');
subplot(1,4,1); plotmf(fismat, 'input', 1);set(gca,'color',[.8 .6 .6]);
subplot(1,4,2); plotmf(fismat, 'input', 2);set(gca,'color',[.8 .6 .6]);
subplot(1,4,3); plotmf(fismat, 'input', 3);set(gca,'color',[.8 .6 .6]);
subplot(1,4,4); plotmf(fismat, 'input', 4);set(gca,'color',[.8 .6 .6]);
pause(.3);close('Fungsi Keanggotaan Awal1');
winAnfisProses4=figure('unit','point','position',[30 300 650 150],...
   'color',[.8 .8 0],'menubar','none','resize','on',...
   'numbertitle','off','name','Fungsi Keanggotaan Awal2',...
   'WindowStyle','normal');
subplot(1,4,1); plotmf(fismat, 'input', 1);set(gca,'color',[.8 .6 .6]);
subplot(1,4,2); plotmf(fismat, 'input', 2);set(gca,'color',[.8 .6 .6]);
subplot(1,4,3); plotmf(fismat, 'input', 3);set(gca,'color',[.8 .6 .6]);
subplot(1,4,4); plotmf(fismat, 'input', 4);set(gca,'color',[.8 .6 .6]);
pause(.3);close('Fungsi Keanggotaan Awal2');
winAnfisProses5=figure('unit','point','position',[30 350 650 150],...
   'color',[.8 .8 0],'menubar','none','resize','on',...
   'numbertitle','off','name','Fungsi Keanggotaan Awal3',...
   'WindowStyle','normal');
subplot(1,4,1); plotmf(fismat, 'input', 1);set(gca,'color',[.8 .6 .6]);
subplot(1,4,2); plotmf(fismat, 'input', 2);set(gca,'color',[.8 .6 .6]);
subplot(1,4,3); plotmf(fismat, 'input', 3);set(gca,'color',[.8 .6 .6]);
subplot(1,4,4); plotmf(fismat, 'input', 4);set(gca,'color',[.8 .6 .6]);
pause(.5);
winAnfisProses6=figure('unit','point','position',[30 390 650 150],...
   'color',[.8 .8 0],'menubar','none','resize','on',...
   'numbertitle','off','name','Fungsi Keanggotaan Awa14',...
   'WindowStyle','normal');
subplot(1,4,1); plotmf(fismat, 'input', 1);set(gca,'color',[.8 .6 .6]);
subplot(1,4,2); plotmf(fismat, 'input', 2);set(gca,'color',[.8 .6 .6]);
subplot(1,4,3); plotmf(fismat, 'input', 3);set(gca,'color',[.8 .6 .6]);
subplot(1,4,4); plotmf(fismat, 'input', 4);set(gca,'color',[.8 .6 .6]);
close('Fungsi Keanggotaan Awal3');pause(2);
subplot(1,4,1); plotmf(fismat, 'input', 1);pause(2);set(gca,'color',[1 1 0]);
subplot(1,4,2); plotmf(fismat, 'input', 2);pause(2);set(gca,'color',[1 1 0]);
subplot(1,4,3); plotmf(fismat, 'input', 3);pause(2);set(gca,'color',[1 1 0]);
subplot(1,4,4); plotmf(fismat, 'input', 4);pause(2);set(gca,'color',[1 1 0]);
pause(.3);close('Data Masukan ANFIS');
winAnfisProses8=figure('unit','point','position',[220 200 280 150],...
   'color',[.4 .8 .2],'menubar','none','resize','on',...
   'numbertitle','off','name','Tunggu: Penentuan Keanggotaan Akhir',...
   'WindowStyle','normal');
[a,MAP]=IMREAD('gambarTunggu.jpg'); image(a); grid off;axis off;
winAnfisProses9=figure('unit','point','position',[30 200 650 150],...
   'color',[.4 .8 .2],'menubar','none','resize','on',...
   'numbertitle','off','name','Fungsi Keanggotaan Akhir',...
   'WindowStyle','normal');
[fismat1,error1,ss,fismat2,error2]=...
   anfis(trnData,fismat,[num_epochs],[],chkData);
subplot(1,4,1); plotmf(fismat2, 'input', 1);set(gca,'color',[.9 .6 .2]);
subplot(1,4,2); plotmf(fismat2, 'input', 2);set(gca,'color',[.9 .6 .2]);
subplot(1,4,3); plotmf(fismat2, 'input', 3);set(gca,'color',[.9 .6 .2]);
subplot(1,4,4); plotmf(fismat2, 'input', 4);set(gca,'color',[.9 .6 .2]);
close('Tunggu: Penentuan Keanggotaan Akhir');pause(3);
subplot(1,4,1); plotmf(fismat2, 'input', 1);pause(2);
set(gca,'color',[0 1 0]);
subplot(1,4,2); plotmf(fismat2, 'input', 2);pause(2);
set(gca,'color',[0 1 0]);
subplot(1,4,3); plotmf(fismat2, 'input', 3);pause(2);
set(gca,'color',[0 1 0]);
subplot(1,4,4); plotmf(fismat2, 'input', 4);pause(2);
set(gca,'color',[0 1 0]);
close('Fungsi Keanggotaan Akhir');close('Fungsi Keanggotaan Awa14');
winAnfisProses10=figure('unit','point','position',[220 200 280 150],...
   'color',[.4 .8 .2],'menubar','none','resize','on',...
   'numbertitle','off','name','Tunggu: Penentuan Keanggotaan Akhir',...
   'WindowStyle','normal');
[a,MAP]=IMREAD('GambarTunggu.jpg'); image(a); grid off;axis off;
winAnfisProses11=figure('unit','point','position',[30 390 650 150],...
   'color',[.8 .8 0],'menubar','none','resize','on',...
   'numbertitle','off','name','Error',...
   'WindowStyle','normal');
plot([error1 error2]);pause(2);
hold on; plot([error1 error2], 'o');set(gca,'color',[1 1 0]);
xlabel('Epochs');ylabel('RMSE (Root Mean Squared Error)');
title('Error Curves');pause(5);
anfis_output = evalfis([trnData(:,1:4); chkData(:,1:4)],fismat2,num_epochs);
x=length(anfis_output);xx=1:1:x;
winAnfisProses19=figure('unit','point','position',[30 30 650 150],...
   'color',[.4 .8 .2],'menubar','none','resize','on',...
   'numbertitle','off','name','Keluaran & Error',...
   'WindowStyle','normal');
y=[y;y];
subplot(211),
plot(xx,anfis_output);
xlabel('Time (sec)'); title('MG Time Series and ANFIS Prediction');
subplot(212),
plot(xx, y - anfis_output);
close('Tunggu: Penentuan Keanggotaan Akhir');
ErrorAnfisMak=max(y - anfis_output);ErrorAnfisMin=min(y - anfis_output);
MSE_FFT=mse(y - anfis_output)
winAnfisError=figure('unit','point','position',[220 208 280 150],...
   'color',[.4 .8 .2],'menubar','none','resize','on',...
   'numbertitle','off','name','Error Maksimum yg Terjadi',...
   'WindowStyle','normal');
editAnfisError1=uicontrol('parent',winAnfisError,...
   'unit','point','position',[0 127 110 20],'Style','Text',... 
   'backgroundColor',[.4 .8 .2],'string','Error Maksimum :',...
   'fontname','arial black','fontsize',10)
editAnfisError2=uicontrol('parent',winAnfisError,...
   'unit','point','position',[110 127 100 20],'Style','Edit',... 
   'backgroundColor',[.9 .9 0],'string','Error',...
   'fontname','arial black','fontsize',10)
set(editAnfisError2,'String',num2str(ErrorAnfisMak));
editAnfisError1=uicontrol('parent',winAnfisError,...
   'unit','point','position',[0 110 107 20],'Style','Text',... 
   'backgroundColor',[.4 .8 .2],'string','Error Manimum :',...
   'fontname','arial black','fontsize',10)
editAnfisError2=uicontrol('parent',winAnfisError,...
   'unit','point','position',[110 107 100 20],'Style','Edit',... 
   'backgroundColor',[.9 .9 0],'string','Error',...
   'fontname','arial black','fontsize',10)
set(editAnfisError2,'String',num2str(ErrorAnfisMin));
editAnfisError1=uicontrol('parent',winAnfisError,...
   'unit','point','position',[0 20 107 20],'Style','Text',... 
   'backgroundColor',[.4 .8 .2],'string','M.S.E.  :',...
   'fontname','arial black','fontsize',10)
editAnfisError2=uicontrol('parent',winAnfisError,...
   'unit','point','position',[110 20 100 20],'Style','Edit',... 
   'backgroundColor',[.9 .9 0],'string','Error',...
   'fontname','arial black','fontsize',10)
set(editAnfisError2,'String',num2str(MSE_FFT));
editAnfisError3=uicontrol('parent',winAnfisError,...
   'unit','point','position',[40 40 170 40],'Style','Text',... 
   'backgroundColor',[.4 .8 .2],'string','Error',...
   'fontname','arial black','fontsize',14)
if MSE_FFT<4 data-blogger-escaped-.5e-10="" data-blogger-escaped-close="" data-blogger-escaped-code="" data-blogger-escaped-dan="" data-blogger-escaped-editanfiserror3="" data-blogger-escaped-else="" data-blogger-escaped-eluaran="" data-blogger-escaped-end="" data-blogger-escaped-eputusan="" data-blogger-escaped-error="" data-blogger-escaped-keputusan="WHEEZING ??.. NO" data-blogger-escaped-maksimum="" data-blogger-escaped-num2str="" data-blogger-escaped-rror="" data-blogger-escaped-set="" data-blogger-escaped-terjadi="" data-blogger-escaped-tring="" data-blogger-escaped-yang="">


Algoritma Clustering K-Means di Java

Contoh Program Algoritma Clustering K-Means di Java

Algoritma Clustering K-Means di Java

Clustering adl suatu teknik data mining yg membagi-bagikan data ke dalam bbrp kelompok (grup atau cluster atau segmen) yg tiap cluster dapat ditempati bbrp anggota bersama-sama. Setiap obyek dilewatan ke grup yg paling mirip dengannya. Ini menyerupai menyusunan binatang & tumbuhan ke dalam keluarga – keluarga yg para anggotanya mempunyai kemiripan. Clustering tidak mensyaratkan pengetahuan sebelumnya dari grup yg dibentuk, juga dari para anggota yg harus mengikutinya.

Algoritma K-Means Clustering

Algoritma K-Means diperkenalkan oleh J.B. MacQueen pd tahun 1976, salah satu algoritma clustering sangat umum yg mengelompokkan data sesuai dg karakteristik atau ciri-ciri bersama yg serupa. Grup data ini dinamakan sebagai cluster. Data di dalam suatu cluster mempunyai ciri-ciri (atau fitur, karakteristik, atribut, properti) serupa & tidak serupa dg data pd cluster lain.

K-means adl salah satu algoritma clustering. Tujuan algoritma ini yaitu unt membagi data menjadi bbrp kelompok. Algoritma ini memperoleh masukan berupa data tanpa label kelas. Hal ini berbeda dg supervised learning yg memperoleh masukan berupa vektor (­x­1 , y1) , (­x­2 , y2) , …, (­x­i , yi), di mana xi adl data dari suatu data pelatihan & yi adl label kelas unt xi.

Pada algoritma pembelajaran ini, komputer mengelompokkan sendiri data-data yg menjadi masukannya tanpa mengetahui terlebih dulu target kelasnya. Pembelajaran ini termasuk dalam unsupervised learning. Masukan yg diterima adl data atau objek & k buah kelompok (cluster) yg diinginkan.  Algoritma ini akan mengelompokkan data atau objek ke dalam k buah kelompok tersebut. pd setiap cluster terdapat titik pusat (centroid) yg merepresentasikan cluster tersebut.

K-means ditemukan oleh bbrp orang yaitu Lloyd (1957, 1982), Forgey (1965) , Friedman and Rubin (1967) , and McQueen (1967). Ide dari clustering pertama kali ditemukan oleh Lloyd pd tahun 1957, namun hal tsb baru dipublikasi pd tahun 1982. pd tahun 1965, Forgey juga mempublikasi teknik yg sama sehingga terkadang dikenal sebagai Lloyd-Forgy pd bbrp sumber.

Algoritma unt melakukan K-Means clustering adl sebagai berikut :

  1. Pilih K buah titik centroid secara acak
  2. Kelompokkan data sehingga terbentuk K buah cluster dg titik centroid dari setiap cluster adl titik centroid yg telah dipilih sebelumnya
  3. Perbaharui nilai titik centroid
  4. Ulangi langkah 2 & 3 sampai nilai dari titik centroid tidak lagi berubah

Proses pengelompokkan data ke dalam suatu cluster dapat dilakukan dg cara menghitung jarak terdekat dari suatu data ke sebuah titik centroid. Perhitungan jarak Minkowski dapat digunakan unt menghitung jarak antar 2 buah data. Rumus unt menghitung jarak tsb adl

d(x_i,x_j)=(|x_{i1}-x_{j1}|^g+|x_{i2}-x_{j2}|^g+...+|x_{ip}-x_{jp}|^g)^{1/g}

Di mana:

g = 1, unt menghitung jarak Manhattan
g = 2, unt menghitung jarak Euclidean
g = ∞, unt menghitung jarak Chebychev
xi , xj adl dua buah data yg akan dihitung jaraknya
p = dimensi dari sebuah data

Pembaharuan suatu titik centroid dapat dilakukan dg rumus berikut[

\mu_k = \frac{1}{N_k} \sum_{q=1}^{N_k} x_q

Di mana:

┬Ák = titik centroid dari cluster ke-K
Nk = banyaknya data pd cluster ke-K
xq = data ke-q pd cluster ke-K

Contoh Program Algoritma Clustering K-Means di Java



//Tujuan: unt menerapkan KMeans algoritma clustering.

import java.util.*;
class k_means
{
static int count1,count2,count3;
static int d[];
static int k[][];
static int tempk[][];
static double m[];
static double diff[];
static int n,p;

// Metode ini akan menentukan cluster 
// di mana unsur pergi pd langkah tertentu.

static int cal_diff(int a) 
{
int temp1=0;
for(int i=0;i<p;++i)
{
if(a>m[i])
diff[i]=a-m[i];
else
diff[i]=m[i]-a;
}
int val=0;
double temp=diff[0];
for(int i=0;i<p;++i)
{
if(diff[i]<temp)
{
temp=diff[i];
val=i;
}
}// akhir dari loop
return val;
}

// Metode ini akan menentukan nilai rata-rata antara

static void cal_mean() 
{
for(int i=0;i<p;++i)
m[i]=0; // menginisialisasi sarana unt 0
int cnt=0;
for(int i=0;i<p;++i)
{
cnt=0;
for(int j=0;j<n-1;++j)
{
if(k[i][j]!=-1)
{
m[i]+=k[i][j];
++cnt;
}}
m[i]=m[i]/cnt;
}
}

// Ini memeriksa apakah sebelumnya k yaitu. 
// Temp & k saat ini sama. 
// Digunakan unt mengakhiri proses

static int check1() 
{
for(int i=0;i<p;++i)
for(int j=0;j<n;++j)
if(tempk[i][j]!=k[i][j])
{
return 0;
}
return 1;
}

public static void main(String args[])
{
Scanner scr=new Scanner(System.in);

/ * memperoleh jumlah elemen * /
System.out.println("Enter the number of elements ");
n=scr.nextInt();
d=new int[n];

/ * memperoleh Elemen * /
System.out.println("Enter "+n+" elements: ");
for(int i=0;i<n;++i)
d[i]=scr.nextInt();

/ * memperoleh jumlah cluster * /
System.out.println("Enter the number of clusters: ");
p=scr.nextInt();

/* inisialisasi array */
k=new int[p][n];
tempk=new int[p][n];
m=new double[p];
diff=new double[p];

/* inisialisasi m */
for(int i=0;i<p;++i)
m[i]=d[i];

int temp=0;
int flag=0;
do
{
for(int i=0;i<p;++i)
for(int j=0;j<n;++j)
{
k[i][j]=-1;
}

// Memanggil loop cal_diff (int) 
// unt setiap elemen.

for(int i=0;i<n;++i) 
{
temp=cal_diff(d[i]);
if(temp==0)
k[temp][count1++]=d[i];
else
if(temp==1)
k[temp][count2++]=d[i];
else
if(temp==2)
k[temp][count3++]=d[i]; 
}

// Memanggil metode yg akan menghitung 
// rata-rata pd langkah ini.
cal_mean(); 

// Memeriksa apakah akhir dari kondisi
flag=check1(); 
if(flag!=1)

// Ambil cadangan dari k di tempk 
// sehingga Anda dapat memeriksa 
// kesetaraan pd langkah berikutnya 

for(int i=0;i<p;++i)
for(int j=0;j<n;++j)
tempk[i][j]=k[i][j];

System.out.println("\n\nPada langkah ini");
System.out.println("\nNilai cluster");
for(int i=0;i<p;++i)
{
System.out.print("K"+(i+1)+"{ ");
for(int j=0;k[i][j]!=-1 && j<n-1;++j)
System.out.print(k[i][j]+" ");
System.out.println("}");
}

System.out.println("\nNilai m ");
for(int i=0;i<p;++i)
System.out.print("m"+(i+1)+"="+m[i]+"  ");

count1=0;count2=0;count3=0;
}
while(flag==0);

System.out.println("\n\n\nCluster akhir oleh KMeans adl sebagai berikut: ");
for(int i=0;i<p;++i)
{
System.out.print("K"+(i+1)+"{ ");
for(int j=0;k[i][j]!=-1 && j<n-1;++j)
System.out.print(k[i][j]+" ");
System.out.println("}");
}
}
}

Hasil Program 




>javac k_means.java
>java k_means

Masukan jumlah elemen
8
Memasukan 8 elemen:
2 3 6 8 12 15 18 22
masukan jumlah Cluster:
3

Pada langkah ini.
Nilai Cluster
K1{ 2 }
K2{ 3 }
K3{ 6 8 12 15 18 22 }
Nilai m
m1=2.0  m2=3.0  m3=13.5

Pada langkah ini.
Nilai Cluster
K1{ 2 }
K2{ 3 6 8 }
K3{ 12 15 18 22 }
Nilai m
m1=2.0  m2=5.666666666666667  m3=16.75

Pada langkah ini.
Nilai Cluster
K1{ 2 3 }
K2{ 6 8 }
K3{ 12 15 18 22 }
Nilai m
m1=2.5  m2=7.0  m3=16.75

Pada langkah ini.
Nilai Cluster
K1{ 2 3 }
K2{ 6 8 }
K3{ 12 15 18 22 }
Nilai m
m1=2.5  m2=7.0  m3=16.75

Cluster akhir oleh KMeans adl sebagai berikut:
K1{ 2 3 }
K2{ 6 8 }
K3{ 12 15 18 22 }


Algoritma Genetika Generik di C #

Contoh Program Algoritma Genetika Generik di C #

Algoritma Genetika Generik di C #

Algoritma Genetika

Algoritma Genetik pertama kali dikembangkan oleh John Holland pd tahun 1970-an di New York, Amerika Serikat. Dia beserta murid-murid & teman kerjanya menghasilkan buku berjudul "Adaption in Natural and Artificial Systems" pd tahun 1975.

Algoritma genetika adl algoritma yg berusaha menerapkan pemahaman mengenai evolusi alamiah pd tugas-tugas pemecahan-masalah (problem solving). Pendekatan yg diambil oleh algoritma ini adl dengan menggabungkan scr acak berbagai pilihan solusi terbaik di dalam suatu kumpulan unt mendapatkan generasi solusi terbaik berikutnya yaitu pd suatu kondisi yg memaksimalkan kecocokannya / lazim disebut fitness. Generasi ini akan merepresentasikan perbaikan-perbaikan pd populasi awalnya. Dengan melakukan proses ini scr berulang, algoritma ini diharapkan dapat mensimulasikan proses evolusioner. pd akhirnya, akan didapatkan solusi-solusi yg paling tepat bagi permasalahan yg dihadapi.

Untuk memakai algoritma genetika, solusi permasalahan direpresentasikan sbg khromosom. Tiga aspek yg penting unt pemakaian algoritma genetika:

1. Definisi fitness function
2. Definisi & implementasi representasi genetika
3. Definisi & implementasi operasi genetika

Operasi genetika terdiri atas mutasi & crossover. Jika ketiga aspek di atas telah didefinisikan, algoritma genetika generik akan bekerja dengan baik. Algoritma Genetik khususnya diterapkan sbg simulasi komputer dimana sebuah populasi representasi abstrak (disebut kromosom) dari solusi-solusi calon (disebut individual) pd sebuah masalah optimisasi akan berkembang menjadi solusi-solusi yg lebih baik. scr tradisional, solusi-solusi dilambangkan dalam biner sbg string '0' & '1', walaupun dimungkinkan juga pemakaian penyandian (encoding) yg berbeda.

Algoritma Genetika Generik di C #
Algoritma Genetika Generik di C #

Evolusi dimulai dari sebuah populasi individual acak yg lengkap & terjadi dalam generasi-generasi. Dalam tiap generasi, kemampuan keseluruhan populasi dievaluasi, kemudian multiple individuals dipilih dari populasi sekarang (current) tersebut scr stochastic (berdasarkan kemampuan mereka), lalu dimodifikasi (melalui mutasi / rekombinasi) menjadi bentuk populasi baru yg menjadi populasi sekarang (current) pd iterasi berikutnya dari algoritma.

Kelas generik sebenarnya adl kelas GeneticPopulation, yg anggota didefinisikan oleh antarmuka IGeneticIndividual. Kelas GeneticPopulation memiliki metode generik unt menghasilkan generasi baru, menciptakan populasi awal, serta sifat mendefinisikan sifat dari populasi, seperti tingkat crossover & mutasi. Diagram kelas menguraikan kelas ini, di mana T adl obyek yg implementss antarmuka IGeneticIndividual.

Fungsi Fitness

Tujuan utama dari algoritma ini adl unt menemukan 'kecocokan' individu atas beberapa model fitness. Fitness bagi seorang individu merupakan fungsi dari kromosom individu & lingkungan. unt mempermudah pengertian, fungsi fitness akan mengembalikan bilangan real antara 0 & 1, dimana 0 adl yg paling rendah & 1 adl yg paling cocok / tinggi. sbg contoh dari fungsi fitness unt pelari Olimpiade akan menjadi fungsi dari kecepatan; 0 kebugaran akan menjadi pelari yg tinggal di garis start sampai akhir & sprinter dengan 1 kebugaran akan lebih cepat ke garis finish dengan instan, perlu diingat fungsi tidak perlu linear.

Operator Genetika

Untuk menciptakan generasi baru dari individu yg lebih fit, serangkaian operator harus diterapkan unt generasi individu. Operator ini mencerminkan fungsi dalam reproduksi seksual biologis. unt penjelasan rinci dari operator genetika dapat membaca di wikipedia.org / beberapa artikel lainnya mengenai algoritma yg sudah kami tulis di blog ini.

Seleksi

Pustaka ini memakai roulette / kebugaran seleksi proporsional unt memilih individu yg akan diberi kesempatan unt bereproduksi. sbg contoh sederhana mempertimbangkan populasi genetik dengan tiga orang A, B, & C dengan skor kebugaran .2, .8, & 0,5 masing-masing. Rata kebugaran total tiga individu adl 1,5, sehingga skor proporsional mereka unt A, B, & C adl 0,13, 0,53, & 0,33 masing-masing, perhatikan ini nilai baru berjumlah 1,0. Setiap individu diberikan interval di kisaran 0,0-1,0 yg sama dengan nilai proporsional. Sebuah nomor acak dipilih antara 0,0 & 1,0 jika nomor jatuh dalam interval yg individu maka individu yg sesuai dipilih unt mereproduksi dengan individu lain.

Crossover

Pertukaran Crossover bagian dari kromosom antara dua individu yg dipilih. Dalam lingkaran contoh dunia bawah, ini akan melibatkan pertukaran salah satu bilangan real yg mewakili X, Y, / nilai-nilai radius. Acara crossover ditentukan oleh probabilitas. Jika tidak ada Crossover terjadi individu menyebarkan kromosom berubah mereka ke operator genetik berikutnya, mutasi.

Mutasi

Mutasi beroperasi pd keturunan dua individu, & kemungkinan terjadi didasarkan pd beberapa kemungkinan antara 0 & 1. Umumnya ini adl perubahan kecil dalam kromosom. Dalam mutasi dunia lingkaran adl skala heterogen kecil masing-masing tiga bilangan real dalam kromosom X, Y, & jari-jari.

Interface

Algoritma Genetika Generik di C #
Algoritma Genetika Generik di C #

Interface ini memungkinkan pengembang unt memakai kelas GeneticPopulation generik. Setiap kelas yg berasal interface ini harus menentukan operator genetik crossover, mutasi, & kebugaran bagi individu itu. Kelas turunan kemudian dapat digunakan dengan kelas GeneticPopulation generik berkembang solusi berdasarkan fungsi fitness.

Contoh Aplikasi: Lingkaran Dunia

Permukaan dunia lingkaran adl persegi panjang dua dimensi berkelanjutan didefinisikan oleh hal-hal berikut (0,0), (0, Maxy), (MAXX, 0), (MAXX, Maxy). Dalam persegi panjang ada satu set lingkaran biru, setiap perjalanan bepergian dengan beberapa kecepatan (ingat, kecepatan memiliki besaran & komponen arah). Seorang individu genetik adl lingkaran stasioner, dengan kromosom yg terdiri dari XY koordinat dalam ruang persegi panjang, & radius semua bilangan real. Fungsi fitness di dunia ini diukur dalam dua langkah, pertama ditemukan jika individu tersebut berpotongan salah satu lingkaran bergerak, jika tidak itu menghitung kebugaran berdasarkan pd ukuran jari-jari individu. Tujuannya adl unt menemukan lingkaran terbesar yg tidak berpotongan salah satu lingkaran bepergian. Dalam video di bawah lingkaran hitam adl yg paling cocok individu, & lingkaran hijau adl anggota lain dari populasi. Kutipan dari fungsi kebugaran ditampilkan di bawah.




Contoh Program Algoritma Genetika Generik di C #

Lingkaran Dunia: Fungsi Fitness


public double Fitness(object world)
        {
            //jika mendekati layar, berikan nilai Fitness mendekati nol
            if ((m_Genome.Rad + m_Genome.X > maxX) ||
                (m_Genome.Rad + m_Genome.Y > maxY) ||
                (m_Genome.X - m_Genome.Rad < 0) ||
                (m_Genome.Y - m_Genome.Rad < 0))
            {
                fitness = .001;
                return fitness;
            }

            //Seberapa jauh batas luar adl 
   //dari batas luar lingkaran lainnya
            double intersect_val = 0;

            double dist;
            //Pastikan objek dunia diatur dengan benar
            if (world.GetType() == typeof(TestWorld))
            {

                TestWorld theWorld = (TestWorld)world;
                int count = theWorld.circles.Count;
                double offDist;
                double total = 0;

                //Persimpangan dengan lingkaran dunia 
    // menyebabkan kebugaran yg lebih rendah
                foreach (Circle circle in theWorld.circles)
                {
                    dist = Math.Sqrt(Math.Pow(m_Genome.X - circle.X, 2.0) 
     + Math.Pow(m_Genome.Y - circle.Y, 2.0));
                    offDist = (dist - (circle.Rad + m_Genome.Rad));

                    if (offDist < 0)                     {                         
     offDist = Math.Abs(offDist);                         
     if (offDist > circle.Rad)
                            offDist = circle.Rad;
                        intersect_val += offDist;
                        total += circle.Rad;
                    }
                }

                //Jika persimpangan dengan lingkaran dunia ada, 
    //rentang kebugaran 0,001-0,5 
    //berdasarkan magnitued dari persimpangan
    
                if (total != 0)
                {
                    intersect_val /= total;
                    intersect_val = 1.0 - intersect_val;
                    fitness = ClampDouble(intersect_val * .5,.001,.5);
                    return fitness;
                }

                //Tidak ada persimpangan dengan lingkaran dunia, 
    //berbagai fitness 0,5-1,0 berdasarkan radius

                double radVal = m_Genome.Rad / 250.0;
                radVal = ClampDouble(radVal,.001,1.0);
                fitness =  radVal * .5 + .5;
                return fitness;
            }
            fitness = .001;
            return fitness;
        }


Lingkaran Dunia: Crossover



public IGeneticIndividual CrossOver(IGeneticIndividual mate)
        {
            TestIndividual ind = new TestIndividual();
            Circle mateGenome = (Circle)mate.EncodeGenome();

            Random rand = new Random((int)DateTime.Now.Ticks);
            double rRad = rand.NextDouble();
            double rX = rand.NextDouble();
            double rY = rand.NextDouble();

            double nRad;
            double nX;
            double nY;

            #region Radius
            if (mateGenome.Rad < m_Genome.Rad)
            {nRad = CrossOverDouble(mateGenome.Rad, m_Genome.Rad, rRad, .1); }
            else
            {nRad = CrossOverDouble(m_Genome.Rad, mateGenome.Rad, rRad, .1); }
            #endregion

            #region X
            if (mateGenome.X < m_Genome.X)
            { nX = CrossOverDouble(mateGenome.X, m_Genome.X, rX, .1); }
            else
            { nX = CrossOverDouble(m_Genome.X, mateGenome.X, rX, .1); }
            #endregion

            #region Y
            if (mateGenome.Y < m_Genome.Y)
            { nY = CrossOverDouble(mateGenome.Y, m_Genome.Y, rY, .1); }
            else
            { nY = CrossOverDouble(m_Genome.Y, mateGenome.Y, rY, .1); }
            #endregion

            TestIndividual ti = new TestIndividual();
            ti.m_Genome.Rad = ClampDouble(nRad,minRad,maxRad);
            ti.m_Genome.X = ClampDouble(nX, 0, maxX);
            ti.m_Genome.Y = ClampDouble(nY,0,maxY);

            return ti;

        }

Lingkaran Dunia: Mutasi



 public IGeneticIndividual Mutate()
        {
            double randVal = NumberGenerator.Instance.RandomDouble();

            //individu scr acak
            if(randVal < .05)
                return new TestIndividual();

            TestIndividual newInd = new TestIndividual();
            //Random r = new Random((int)DateTime.Now.Ticks);
            //range .75 to 1.25
            double randVal1 = NumberGenerator.Instance.RandomDouble() / 2.0 + .75;
            double randVal2 = NumberGenerator.Instance.RandomDouble() / 2.0 + .75;
            double randVal3 = NumberGenerator.Instance.RandomDouble() / 2.0 + .75;
            int v = NumberGenerator.Instance.RandomInt(0, 2);

            double r = m_Genome.Rad;
            double x = m_Genome.X;
            double y = m_Genome.Y;

            r *= randVal1;
            x *= randVal2;
            y *= randVal3;

            newInd.m_Genome.Rad = ClampDouble(r, minRad, maxRad);
            newInd.m_Genome.X = ClampDouble(x, 0, maxX);
            newInd.m_Genome.Y = ClampDouble(y, 0, maxY);

            return newInd;
        }




Kesimpulan

Berdasarkan sifat temporal berkelanjutan lingkungan ini, aplikasi lebih lanjut akan 'berevolusi' probabilitas terbaik & atribut populasi genetik ini yg akan menghasilkan rata-rata fitness tertinggi / rata-rata tertinggi yg paling cocok setiap individu. Hal ini dapat dengan mudah dilakukan dengan memakai sifat-sifat Populasi Genetik sbg kromosom individu. Fungsi fitness memungkinkan melibatkan setiap evolusi populasi genetik unt 100 generasi. Dengan itu mudah unt melihat algoritma ini memiliki aplikasi domain yg sangat luas, & bagaimana mudahnya algoritma ini dapat diimplementasikan dengan memakai model generik & antarmuka tunggal.


Konsultasi gratis