Januari 2014 - Elang Sakti

# Hack Your Skills! to be Professional Mechatronics

PHP : Class Pengacak Kombinasi String v0.2

ElangSakti Algoritma , Informatika , PHP , String Generator Tidak ada komentar

Script ini adalah perbaikan dari class php pada artikel sebelumnya. Fungsi dari class ini adalah untuk menemukan kombinasi dari karakter yang kita tentukan. Untuk contoh kasus, akan kita bahas pada tulisan selanjutnya. :)

Berikut ini adalah kelas utamanya :

<?php
/* 
 * String Combination Generator v0.2
 * coder haripinter - hari\at/elangsakti.com
 * Created : Wed, Jan 22 - 2014, 06.00 WIB. Malang - Indonesia
 * Recoded : Sat, Jan 25 - 2014, 20.01 WIB. Malang - Indonesia
 *   Changed: - Restructuring code
 *      - Changing format from 321 to 123
 *      - Ascending result
 *      - Faster if use combine format, ex. xxx65
 * 
 * $Format : format string
 *           ex. xxx => all string will combine
 *               xx4 => all string combine except 4, 4 is default value
 *
 * $Chars : list of character to generate
 *           ex. '0123456789' or 'abcde... etc'
 * 
 * $Result : the result
 */
class SCGenerator{
 var $Result;
 var $Format;
 var $Chars;
 
 var $Len;
 var $Clean_format;
 
 function setFormat($str){
     $this->Format = $str;
 }
 
 function setChars($str){
     $this->Chars = $str;
 }
 
 function get_cleanformat(){
  $format = $this->Format;
  $this->Len = strlen($format);
  $len = $this->Len;
  
  $clean = 0;
  $format_tmp = '';
  for($a=0; $a<$len; $a++){
   if(strtolower($format[$a])=='x'){
    $clean++;
    $format_tmp .= 'x';
   }else{
    $format_tmp .= $format[$a];
   }
  }
  $this->Format = $format_tmp;
  $this->Clean_format = $clean;
  return $clean;
 }
 
    function Generate(){
  $chars = $this->Chars;
  $format = $this->Format;
  $formatlen = $this->get_cleanformat();
        $charlen = strlen($chars);
  
  if($formatlen<1 or $charlen<1){
   echo "You must define both Chars and Format first!";
   exit();
  }
  
        $pis = array();
        for($a=0; $a<$formatlen; $a++){
            $pis[$a] = 0;
        }
        
        $result = array();
        $loop = false;
        do{
            $tmp = '';
         $xyz = true;
         for($x=0; $x<$formatlen; $x++){
          if($chars[$pis[$x]]==''){
           $tmp .= $chars[0];
          }else{
           $tmp .= $chars[$pis[$x]];
          }
          $xyz = (($chars[$pis[$x]]==$chars[$charlen]) && $xyz);
          $loop = $xyz;
          if($chars[$pis[$x]]==$chars[$charlen]){
           $pis[$x+1]++;
           $pis[$x] = 0;
          }
          if($x==0){
           $pis[$x]++;
          }
         }
         if(!$xyz){
          $result[] = $this->reverse($tmp);
         }
        }while(!$loop);
  
  $this->Result = $result;
        return $this->Result;
    }
 
 function reverse($strs){
  $format = $this->Format;
  $cleanf = $this->Clean_format;
  $len = $this->Len;
  
  $tmp = '';
  for($a=$cleanf; $a>=0; $a--){
   $tmp .= $strs[$cleanf--];
  }
  
  $tmq = '';
  if($len>$cleanf){
   $x = 0;
   for($a=0; $a<$len; $a++){
    if($format[$a]=='x'){
     $tmq .= $tmp[$x]; 
     $x++;
    }else{
     $tmq .= $format[$a];
    }
   }
  }else{
   $tmq = $tmp;
  }
  return $tmq;
 }
}
?>

Berikut ini adalah contoh cara menggunakan class generator :

<?php
include_once('SCGenerator2.php');

$scg2 = new SCGenerator();

// -- number
$char = '0123456789';
$format = 'xx1';

echo "\n\nVersi 2\n";
$start = microtime(true);
$scg2->setChars($char);
$scg2->setFormat($format);
$scg2->Generate();
$stop = microtime(true);
$secs = ($stop-$start);
print_r($scg2->Result);
echo $secs." seconds\n";

$format = 'xx';

echo "\n\nVersi 2\n";
$start = microtime(true);
$scg2->setFormat($format);
$scg2->Generate();
$stop = microtime(true);
$secs = ($stop-$start);
print_r($scg2->Result);
echo $secs." seconds\n";

?>

Outputnya :

Versi 2
Array
(
    [0] => 001
    [1] => 011
    [2] => 021
    [3] => 031
    [4] => 041
    [5] => 051
    [6] => 061
    [7] => 071
    [8] => 081
    [9] => 091
    [10] => 101
    [11] => 111
    [12] => 121
    [13] => 131
    [14] => 141
    [15] => 151
    [16] => 161
    [17] => 171
    [18] => 181
    [19] => 191
    [20] => 201
    [21] => 211
    [22] => 221
    [23] => 231
    [24] => 241
    [25] => 251
    [26] => 261
    [27] => 271
    [28] => 281
    [29] => 291
    [30] => 301
    [31] => 311
    [32] => 321
    [33] => 331
    [34] => 341
    [35] => 351
    [36] => 361
    [37] => 371
    [38] => 381
    [39] => 391
    [40] => 401
    [41] => 411
    [42] => 421
    [43] => 431
    [44] => 441
    [45] => 451
    [46] => 461
    [47] => 471
    [48] => 481
    [49] => 491
    [50] => 501
    [51] => 511
    [52] => 521
    [53] => 531
    [54] => 541
    [55] => 551
    [56] => 561
    [57] => 571
    [58] => 581
    [59] => 591
    [60] => 601
    [61] => 611
    [62] => 621
    [63] => 631
    [64] => 641
    [65] => 651
    [66] => 661
    [67] => 671
    [68] => 681
    [69] => 691
    [70] => 701
    [71] => 711
    [72] => 721
    [73] => 731
    [74] => 741
    [75] => 751
    [76] => 761
    [77] => 771
    [78] => 781
    [79] => 791
    [80] => 801
    [81] => 811
    [82] => 821
    [83] => 831
    [84] => 841
    [85] => 851
    [86] => 861
    [87] => 871
    [88] => 881
    [89] => 891
    [90] => 901
    [91] => 911
    [92] => 921
    [93] => 931
    [94] => 941
    [95] => 951
    [96] => 961
    [97] => 971
    [98] => 981
    [99] => 991
)
0.0029339790344238 seconds


Versi 2
Array
(
    [0] => 00
    [1] => 01
    [2] => 02
    [3] => 03
    [4] => 04
    [5] => 05
    [6] => 06
    [7] => 07
    [8] => 08
    [9] => 09
    [10] => 10
    [11] => 11
    [12] => 12
    [13] => 13
    [14] => 14
    [15] => 15
    [16] => 16
    [17] => 17
    [18] => 18
    [19] => 19
    [20] => 20
    [21] => 21
    [22] => 22
    [23] => 23
    [24] => 24
    [25] => 25
    [26] => 26
    [27] => 27
    [28] => 28
    [29] => 29
    [30] => 30
    [31] => 31
    [32] => 32
    [33] => 33
    [34] => 34
    [35] => 35
    [36] => 36
    [37] => 37
    [38] => 38
    [39] => 39
    [40] => 40
    [41] => 41
    [42] => 42
    [43] => 43
    [44] => 44
    [45] => 45
    [46] => 46
    [47] => 47
    [48] => 48
    [49] => 49
    [50] => 50
    [51] => 51
    [52] => 52
    [53] => 53
    [54] => 54
    [55] => 55
    [56] => 56
    [57] => 57
    [58] => 58
    [59] => 59
    [60] => 60
    [61] => 61
    [62] => 62
    [63] => 63
    [64] => 64
    [65] => 65
    [66] => 66
    [67] => 67
    [68] => 68
    [69] => 69
    [70] => 70
    [71] => 71
    [72] => 72
    [73] => 73
    [74] => 74
    [75] => 75
    [76] => 76
    [77] => 77
    [78] => 78
    [79] => 79
    [80] => 80
    [81] => 81
    [82] => 82
    [83] => 83
    [84] => 84
    [85] => 85
    [86] => 86
    [87] => 87
    [88] => 88
    [89] => 89
    [90] => 90
    [91] => 91
    [92] => 92
    [93] => 93
    [94] => 94
    [95] => 95
    [96] => 96
    [97] => 97
    [98] => 98
    [99] => 99
)
0.0026800632476807 seconds

Semoga bermanfaat :)

Written by ElangSakti
PHP : Class Pengacak Kombinasi String v0.2
Bahasan: Script ini adalah perbaikan dari class php pada artikel sebelumnya . Fungsi dari class ini adalah untuk menemukan kombinasi dari karakter ...
Published at Sabtu, 25 Januari 2014, Updated at Sabtu, 25 Januari 2014
Reviewed by dr. on 2014-01-25T20:23:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

PHP : Membuat Kombinasi (Mengacak) String untuk Bruteforce

ElangSakti Bruteforce , Informatika , PHP , String Generator Tidak ada komentar

Analisis Cara Generate

Pernah berpikir untuk membuat atau meng-generate kombinasi dari string untuk keperluan menebak-nebak password (bruteforce)? Atau ingin menggenerate angka acak untuk range tertentu? Atau ingin menebak password dengan panjang string tertentu? Mari saya tunjukkan salah satu toolnya.

Engngng... algoritma untuk menggenerate string ini sekedar hasil analisis dari oret-oretan seperti gambar. Jadi tidak mengacu atau terkait dengan algoritma yang sudah dipublish pada jurnal internasional.

Berikut ini adalah script singkat dari tool yang saya maksud. Script berikut untuk mengacak atau lebih tepatnya mengkombinasikan string sesuai panjang karakter yang diiinginkan. Berikut adalah versi awal yang butuh debug sana-sini, tapi secara sepintas script ini berfungsi dengan baik. Untuk yang mau mencobanya, silakan informasikan jika ada error dlsb dari script berikut.

Berikut isi dari class SCGenerator.php

<?php
/*
 *
 * Wed, Jan 22 - 2014, 06.00 WIB. Malang - Indonesia
 * coder haripinter - hari\at/elangsakti.com
 * String Combination Generator v0.1
 * 
 * $Format : format string
 *           ex. xxx => all string will combine
 *               xx4 => all string combine except 4, 4 is default value
 *
 * $Chars : list of character to generate
 *           ex. '0123456789' or 'abcde... etc'
 * 
 * $Result : the result
 */
class SCGenerator{
 var $Result;
 var $Format;
 var $Chars;
 
 function setFormat($str){
     $this->Format = $str;
 }
 
 function setChars($str){
     $this->Chars = $str;
 }
 
    function Generate(){
  $chars = $this->Chars;
  $format = $this->Format;
  
        $formatlen = strlen($this->Format);
        $charlen = strlen($chars);
  
  if($formatlen<1 or $charlen<1){
   echo "You must define both Chars and Format first!";
   exit();
  }
  
        $pis = array();
        for($a=0; $a<$formatlen; $a++){
            $pis[$a] = 0;
        }
        
        $result = array();
        $loop = false;
        do{
            $tmp = '';
         $xyz = true;
         for($x=0; $x<$formatlen; $x++){
          if($chars[$pis[$x]]==''){
           $tmp .= $chars[0];
          }else{
           if(strtolower($format[$x])!='x'){
            $tmp .= $format[$x];
           }else{
            $tmp .= $chars[$pis[$x]];
           }
          }
          $xyz = (($chars[$pis[$x]]==$chars[$charlen]) && $xyz);
          $loop = $xyz;
          if($chars[$pis[$x]]==$chars[$charlen]){
           $pis[$x+1]++;
           $pis[$x] = 0;
          }
          if($x==0){
           $pis[$x]++;
          }
         }
         if(!$xyz){
          $result[$tmp] = $tmp;
         }
        }while(!$loop);
  
        $tmx = array();
        foreach($result as $res){
            array_push($tmx,$res);
        }
  $this->Result = $tmx;
        return $tmx;
    }
}
?>

Berikut ini adalah cara menggunakannya :

<?php
include_once('SCGenerator.php');

$scg = new SCGenerator();

// -- number
$char = 'abc';
$format = 'xxx';

$scg->setChars($char);
$scg->setFormat($format);
$scg->Generate();
print_r($scg->Result);

// -- alpabet
$char = '012';
$format = 'xx9';

$scg->setChars($char);
$scg->setFormat($format);
$scg->Generate();
$res = $scg->Result;
print_r($res);

// Trying another format
//$char = '0123456789abcdefghijklmnopqrstuvwxyz';
//$format = 'xxxxx';
?>

Berikut ini adalah contoh hasil generate dari script di atas :

Array
(
    [0] => aaa
    [1] => baa
    [2] => caa
    [3] => aba
    [4] => bba
    [5] => cba
    [6] => aca
    [7] => bca
    [8] => cca
    [9] => aab
    [10] => bab
    [11] => cab
    [12] => abb
    [13] => bbb
    [14] => cbb
    [15] => acb
    [16] => bcb
    [17] => ccb
    [18] => aac
    [19] => bac
    [20] => cac
    [21] => abc
    [22] => bbc
    [23] => cbc
    [24] => acc
    [25] => bcc
    [26] => ccc
)
Array
(
    [0] => 009
    [1] => 109
    [2] => 209
    [3] => 019
    [4] => 119
    [5] => 219
    [6] => 029
    [7] => 129
    [8] => 229
)

Semoga berguna.

Written by ElangSakti
PHP : Membuat Kombinasi (Mengacak) String untuk Bruteforce
Bahasan: Analisis Cara Generate Pernah berpikir untuk membuat atau meng-generate kombinasi dari string untuk keperluan menebak-nebak password (...
Published at Rabu, 22 Januari 2014, Updated at Rabu, 22 Januari 2014
Reviewed by dr. on 2014-01-22T06:27:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Java : Contoh Script Algoritma Constructive Backpropagation ~ Jaringan Saraf Tiruan (JST)

ElangSakti backpropagation , constructive backpropagation , Informatika , jaringan saraf tiruan , jast , momentum Tidak ada komentar

Ketiga contoh pembelaran (training) Jaringan saraf Tiruan sebelumnya, Hebb Rule, Delta Rule, Perceptron, dan Backpropagation masih memiliki banyak kekurangan. Bisa jadi karena tidak bisa 'belajar' atau terlalu lama dalam pembelajaran. Makanya, untuk algoritma pembelajaran backpropagation dikembangkan lagi sehingga muncul algoritma yang bernama Constructive Backpropagation.

Ada beberapa penerapan dalam algoritma constructive backpropagation, salah satunya adalah penambahan momentum. Pada posting kali ini saya berikan contoh contructive backpropagation dengan Momentum.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package abppn;

import java.math.BigDecimal;
import java.text.DecimalFormat;

/**
 *
 * @author x86
 */
public class BPM {
    // kondisi
    double x[][];
    // target
    double t[];
    
    int unit_input;
    int unit_hidden;
    int unit_output;
    
    // learning rate
    double alfa;
    // maximum loop
    int maxloop;
    // target error
    double ERR;
    // last error
    double ERX;
    
    // bobot input - hidden
    double v[][];
    // bobot bias - hidden 
    double v0[];
    // bobot hidden - ouput
    double w[][];
    // bobot bias - output
    double w0[];
    
    double MSE;
    double Momentum;
    int loop;
    
    double hasil_akhir;
    double hasil_mentah;
    
    void init_static(){
        //double init_x[][] = {{0,1},{1,0},{1,1},{0,0}};
        //double init_t[] = {1,1,0,0};
        //double init_x[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};
        //double init_t[] = {1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1, 1, 1, 1, 1,-1, 1, 0, 1, 1};
        double init_x[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
        double init_t[] = {1,0.5,1,0,1,0.5,1,0,1,0.5,1,0,1,0.5,1,1,1,1,1,0,1,0.5,1,1};
        int init_uinput = init_x[0].length;
        int init_uhidden = 4;
        int init_uoutput = 1;
        double init_alfa = 1;
        int init_maxloop = 10000;
        double init_ERR = 0.01;
        double Momentum = 0.6;
        //double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
        double init_v[][] = new double[init_uinput][init_uhidden];
        for(int a=0; a<init_v.length; a++){
            for(int b=0; b<init_v[0].length; b++){
                init_v[a][b] = Math.random();
            }
        }
        //double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
        double init_v0[] = new double[init_uhidden];
        for(int a=0; a<init_v0.length; a++){
            init_v0[a] = Math.random();
        }
        //double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
        double init_w[][] = new double[init_uoutput][init_uhidden];
        for(int a=0; a<init_w.length; a++){
            for(int b=0; b<init_w[0].length; b++){
                init_w[a][b] = Math.random();
            }
        }
        //double init_w0[] = {0.9505};
        double init_w0[] = new double[init_uoutput];
        for(int a=0; a<init_w0.length; a++){
            init_w0[a] = Math.random();
        }
        
        this.x = init_x;
        this.t = init_t;
        this.unit_input = init_uinput;
        this.unit_hidden = init_uhidden;
        this.unit_output = init_uoutput;
        this.alfa = init_alfa;
        this.maxloop = init_maxloop;
        this.ERR = init_ERR;
        this.v = init_v;
        this.v0 = init_v0;
        this.w = init_w;
        this.w0 = init_w0;
    }
    
    void init_dynamic(){
        //double init_x[][] = {{0,1},{1,0},{1,1},{0,0}};
        //double init_t[] = {1,1,0,0};
        //double init_x[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};
        //double init_t[] = {1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1, 1, 1, 1, 1,-1, 1, 0, 1, 1};
        double init_x[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
        double init_t[] = {1,0.5,1,0,1,0.5,1,0,1,0.5,1,0,1,0.5,1,1,1,1,1,0,1,0.5,1,1};
        int init_uinput = init_x[0].length;
        //int init_uhidden = 4;
        int init_uoutput = 1;
        /*double init_alfa = 1;
        int init_maxloop = 10000;
        double init_ERR = 0.01;
        double Momentum = 0.6;*/
        
        this.x = init_x;
        this.t = init_t;
        this.unit_input = init_uinput;
        //this.unit_hidden = init_uhidden;
        this.unit_output = init_uoutput;
        //this.alfa = init_alfa;
        //this.maxloop = init_maxloop;
        //this.ERR = init_ERR;
        
        
        //double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
        double init_v[][] = new double[this.unit_input][this.unit_hidden];
        for(int a=0; a<init_v.length; a++){
            for(int b=0; b<init_v[0].length; b++){
                init_v[a][b] = Math.random();
            }
        }
        //double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
        double init_v0[] = new double[this.unit_hidden];
        for(int a=0; a<init_v0.length; a++){
            init_v0[a] = Math.random();
        }
        //double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
        double init_w[][] = new double[this.unit_output][this.unit_hidden];
        for(int a=0; a<init_w.length; a++){
            for(int b=0; b<init_w[0].length; b++){
                init_w[a][b] = Math.random();
            }
        }
        //double init_w0[] = {0.9505};
        double init_w0[] = new double[this.unit_output];
        for(int a=0; a<init_w0.length; a++){
            init_w0[a] = Math.random();
        }
        
        
        this.v = init_v;
        this.v0 = init_v0;
        this.w = init_w;
        this.w0 = init_w0;
    }
    
    void learn_static(){
        double data[][] = this.x;
        double target[] = this.t;
        int jumlah_data = data.length;
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        // do it for learn
        int loop = 0;
        //this.maxloop = 1000;
        //System.out.println(jumlah_hidden);
        //System.out.println(this.v0.length);
        //System.exit(0);
        
        do{
            //System.out.println("Loop : "+loop);
            //System.out.println("-----------");
            // for all data
            for(int h=0; h<jumlah_data; h++){
                // hitung z_in dan z
                double z[] = new double[jumlah_hidden];
                for(int j=0; j<jumlah_hidden; j++){
                    //itung sigma xi vij
                    double z_in[] = new double[jumlah_hidden];
                    double jum_xv=0;
                    for(int i=0; i<jumlah_input; i++){
                        double tmp=x[h][i]*v[i][j];
                        jum_xv += tmp;
                    }
                    z_in[j] = v0[j]+jum_xv;
                    z[j] = aktivasi(z_in[j]);
                    //z[j] = 1/(1+(double)Math.exp(-z_in[j]));
                    //z[j] = (1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
                  //  System.out.println("z["+j+"] = "+z[j]);
                }
                
                //~ itung y_in dan y     (output)
                double y[] = new double[jumlah_output];
                for(int k=0; k<jumlah_output; k++){
                    double y_in[] = new double[y.length];
                    double jum_zw=0;
                    for(int j=0; j<jumlah_hidden; j++){
                        double tmp=z[j]*w[k][j];
                        jum_zw=jum_zw+tmp;
                    }
                    y_in[k]=w0[k]+jum_zw;
                    y[k] = aktivasi(y_in[k]);
                    //y[k]=1/(1+(double)Math.exp(-y_in[k]));
                    //y[k]=(1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
                    //System.out.println("Math.exp("+-y_in[k]+") = "+Math.exp(-y_in[k]));
                    //System.out.println("y["+k+"] = "+y[k]);
                }
                
                // hitung MSE
                double sum_e = 0;
                double Err_y[] = new double[jumlah_output];
                for(int k=0; k<jumlah_output; k++){
                    //error otput
                    //Err_y[k]=(t[h]-y[k])*y[k]*(1-y[k]);
                    Err_y[k] = t[h]-y[k];
                    sum_e += Math.pow(Err_y[k],2);
                }
                
                this.MSE = 0.5*sum_e;
                
                //ngitung delta bias dan delta bobot
                double Aw[][] = new double[this.w.length][this.w[0].length];
                double Aw0[] = new double[this.w0.length];
                for(int k=0; k<jumlah_output; k++){
                    for(int j=0; j<jumlah_hidden; j++){
                        //delta bobot hO
                        Aw[k][j] = this.alfa * Err_y[k] * y[k] * z[j];
                        //delta bias hO
                        Aw0[k] = this.alfa * Err_y[k] * y[k];
                    }
                }
                
                //ngitung error hiden dan delta bias dan delta bobot
                double Err_in[] = new double[jumlah_hidden]; 
                double Err_z[] = new double[jumlah_hidden];
                double Av[][] = new double[this.v.length][this.v[0].length];
                double Av0[] = new double[this.v0.length];
                for(int j=0; j<jumlah_hidden; j++){
                    
                    double tmp=0;
                    for(int k=0; k<jumlah_output; k++){
                        tmp += (Err_y[k] * this.w[k][j]);
                    }
                    // eror sebelum output / setelah hidden
                    Err_in[j] = tmp;
                    // eror hidden (t[h]-y[k])*y[k]*(1-y[k]);
                    Err_z[j] = Err_in[j] * (z[j]) * (1-z[j]);
                    
                    for(int i=0; i<jumlah_input; i++){
                        //delta bobot iH
                        Av[i][j] = this.alfa * Err_z[j] * this.x[h][i];
                        //Av[i][j] = this.alfa * y[k] * this.w[k][j] * z[j] * this.x[h][i];
                    }
                    //delta bias  hidden
                    Av0[j] = this.alfa * Err_z[j];
                }
                
                //update bobot dan bias
                //update bobot bias outpuut
                for(int j=0; j<jumlah_hidden; j++){
                    for(int k=0; k<jumlah_output; k++){
                        this.w[k][j] = this.w[k][j] + Aw[k][j] + (this.Momentum * Aw[k][j]);
                        //this.w[k][j]=this.w[k][j]-Aw[k][j];
                    }
                }
                for(int k=0; k<jumlah_output; k++){
                    this.w0[k] = this.w0[k] + Aw0[k] + (this.Momentum * Aw0[k]);
                    //this.w0[k]=this.w0[k]-Aw0[k];
                }

                //update bobot bias hidden
                for(int i=0; i<jumlah_input; i++){
                    for(int j=0; j<jumlah_hidden; j++){
                        this.v[i][j] = this.v[i][j] + Av[i][j] + (this.Momentum * Av[i][j]);
                        //this.v[i][j]=this.v[i][j]-Av[i][j];
                    }
                }
                for(int j=0; j<jumlah_hidden; j++){
                    this.v0[j] = this.v0[j] + Av0[j] + (this.Momentum * Av0[j]);
                    //this.v0[j]=this.v0[j]-Av0[j];
                }
            }
            loop++;
            //System.out.println("err : "+ERX);
        }while(is_stop()>this.ERR && loop<this.maxloop);
        //System.out.println("err : "+this.MSE);
        //System.out.println("loop : "+loop);
        this.loop = loop;
    }
    
    double aktivasi(double inp){
        return 1/(1+(double)Math.exp(-inp)); 
    }
    
    //penentuan berhenti atau lanjut
    double is_stop(){
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        int jumlah_data = this.x.length;
        double akumY=0;
        
        //~ itung z_in dan z
        for(int h=0; h<jumlah_data; h++){
            double z[] = new double[jumlah_hidden];
            for(int j=0; j<jumlah_hidden; j++){
                //itung sigma xi vij
                double z_in[] = new double[z.length];
                double jum_xv=0;
                for(int i=0; i<jumlah_input; i++){
                    double tmp=this.x[h][i]*this.v[i][j];
                    jum_xv=jum_xv+tmp;
                }
                z_in[j]=this.v0[j]+jum_xv;
                z[j] = aktivasi(z_in[j]);
                //z[j]=1/(1+(double)Math.exp(-z_in[j]));
                //z[j]=(1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
                //System.out.println(-z_in[j]);
            }

            //~ itung y_in dan y (output)
            double y[] = new double[jumlah_output];
            for(int k=0; k<jumlah_output; k++){
                double y_in[] = new double[y.length];
                double jum_zw=0;
                for(int j=0; j<jumlah_hidden; j++){
                    double tmp=z[j]*this.w[k][j];
                    jum_zw=jum_zw+tmp;
                }
                y_in[k]=this.w0[k]+jum_zw;
                y[k] = aktivasi(y_in[k]);
                //y[k]=1/(1+(double)Math.exp(-y_in[k]));
                //y[k]=(1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
                //System.out.println("t[]-y = "+t);
                akumY += Math.pow((t[h]-y[k]),2);
            }
        }
        this.MSE = akumY/this.x[0].length;
        
        return this.MSE;
    }
    
    void test(double data[]){
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        double outt[] = this.t;
        
        //pada hidden
        double z[] = new double[jumlah_hidden];
        for(int j=0; j<jumlah_hidden; j++){
            double z_in[] = new double[z.length];
            double tmp = 0;
            for(int i=0; i<data.length; i++){
                tmp = tmp + (data[i] * this.v[i][j]);
            }
            z_in[j] = this.v0[j] + tmp;
            z[j] = aktivasi(z_in[j]);
            //z[j] = 1/(1+(double)Math.exp(-z_in[j]));
            //z[j] = (1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
        }

        //pada ouotpr
        double y[] = new double[jumlah_output];
        for(int k=0; k<jumlah_output; k++){
            double y_in[] = new double[y.length];
            double tmp = 0;
            for(int j=0; j<jumlah_hidden; j++){
                tmp = tmp + z[j] * this.w[k][j];
            }
            y_in[k] = this.w0[k] + tmp;

            y[k] = aktivasi(y_in[k]);
            //y[k] = 1/(1+(double)Math.exp(-y_in[k]));
            //y[k] = (1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
/*
            if(y[k]<0.1){
                y[k] = -1;
            }else if(y[k]>0.1){
                y[k] = 1;
            }else{
                y[k] = 0;
            }
            /*
            if(y[k]>0)
             y[k]=1;
            else
             y[k]=0;*/
            
            double err_pad = this.MSE*this.x[0].length;
            double hazil = 0;
            if(y[k] < err_pad){
                hazil = 0;
            }else if(y[k]>(1-err_pad)){
                hazil = 1;
            }else{
                hazil = 0.5;
            }
            
            this.hasil_mentah = y[k];
            this.hasil_akhir = hazil;
            //System.out.println("Output "+y[k]);
        }
    }
    
    String kesimpulan(double h){
        String x = "";
        switch(String.valueOf(h)){
            case "0.0":
                x = "Hard Contact Lenses";
                break;
            case "0.5":
                x = "Soft Contact Lenses";
                break;
            case "1.0":
                x = "No Contact Lenses";
                break;
        }
        return x;
    }
    
    double double_format(double num, int len){
        String format = "#.";
        for(int a=0; a<len; a++){
            format += "#";
        }
        DecimalFormat change = new DecimalFormat(format);
        return Double.valueOf(change.format(num));
    }
    
    /*
    public static void main(String haripinter[]){
       BPM BP = new BPM();
       BP.init_static();
       BP.learn_static();
       /*double ax[] = {0,0};
       double bx[] = {0,1};
       double cx[] = {1,0};
       double dx[] = {1,1};
       BP.test(ax);
       BP.test(bx);
       BP.test(cx);
       BP.test(dx);*/
       
       //double xys[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};//
       /*double xys[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
       for(int a=0; a<xys.length; a++){
           double inp[] = xys[a];
           System.out.println(BP.t[a]);
           BP.test(inp);
       }
       //BigDecimal k = new BigDecimal(Math.exp(10));
       
       //System.err.println(-1-(-1));
    }*/
}

Berikut contoh script metode pembelajaran lainnya :
1. Hebb Rule
2. Delta Rule
3. Perceptron
4. Backpropagation
5. Constructive Backpropagation (dg momentum)

Written by ElangSakti
Java : Contoh Script Algoritma Constructive Backpropagation ~ Jaringan Saraf Tiruan (JST)
Bahasan: Ketiga contoh pembelaran (training) Jaringan saraf Tiruan sebelumnya, Hebb Rule, Delta Rule, Perceptron, dan Backpropagation masih memilik...
Published at Senin, 13 Januari 2014, Updated at Senin, 13 Januari 2014
Reviewed by dr. on 2014-01-13T11:13:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Java : Contoh Script Algoritma Backpropagation ~ Jaringan Saraf Tiruan (JST)

ElangSakti backpropagation , Informatika , jaringan saraf tiruan , jst Tidak ada komentar

Sebelumnya kita sudah membahas tentang Hebb Rule, Delta Rule, dan Perceptron. Kali ini kami contohkan script algoritma dasar dari Backpropagation.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package abppn;

import java.math.BigDecimal;
import java.text.DecimalFormat;

/**
 *
 * @author x86
 */
public class BP {
    // kondisi
    double x[][];
    // target
    double t[];
    
    int unit_input;
    int unit_hidden;
    int unit_output;
    
    // learning rate
    double alfa;
    // maximum loop
    int maxloop;
    // target error
    double ERR;
    // last error
    double ERX;
    
    // bobot input - hidden
    double v[][];
    // bobot bias - hidden 
    double v0[];
    // bobot hidden - ouput
    double w[][];
    // bobot bias - output
    double w0[];
    
    double MSE;
    
    int loop;
    double hasil_mentah;
    double hasil_akhir;
    
    void init_static(){
        //double init_x[][] = {{0.5,1},{1,0.5},{1,1},{0.5,0.5}};
        //double init_t[] = {1,1,0.5,0.5};
        //double init_x[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};
        //double init_t[] = {1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1, 1, 1, 1, 1,-1, 1, 0, 1, 1};
        double init_x[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
        double init_t[] = {1,0.5,1,0,1,0.5,1,0,1,0.5,1,0,1,0.5,1,1,1,1,1,0,1,0.5,1,1};
        int init_uinput = init_x[0].length;
        int init_uhidden = 4;
        int init_uoutput = 1;
        double init_alfa = 1;
        int init_maxloop = 10000;
        double init_ERR = 0.01;
        //double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
        double init_v[][] = new double[init_uinput][init_uhidden];
        for(int a=0; a<init_v.length; a++){
            for(int b=0; b<init_v[0].length; b++){
                init_v[a][b] = Math.random();
            }
        }
        //double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
        double init_v0[] = new double[init_uhidden];
        for(int a=0; a<init_v0.length; a++){
            init_v0[a] = Math.random();
        }
        //double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
        double init_w[][] = new double[init_uoutput][init_uhidden];
        for(int a=0; a<init_w.length; a++){
            for(int b=0; b<init_w[0].length; b++){
                init_w[a][b] = Math.random();
            }
        }
        //double init_w0[] = {0.9505};
        double init_w0[] = new double[init_uoutput];
        for(int a=0; a<init_w0.length; a++){
            init_w0[a] = Math.random();
        }
        
        this.x = init_x;
        this.t = init_t;
        this.unit_input = init_uinput;
        this.unit_hidden = init_uhidden;
        this.unit_output = init_uoutput;
        this.alfa = init_alfa;
        this.maxloop = init_maxloop;
        this.ERR = init_ERR;
        this.v = init_v;
        this.v0 = init_v0;
        this.w = init_w;
        this.w0 = init_w0;
    }
    
    void init_dinamic(){
        double init_x[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
        double init_t[] = {1,0.5,1,0,1,0.5,1,0,1,0.5,1,0,1,0.5,1,1,1,1,1,0,1,0.5,1,1};
        int init_uinput = init_x[0].length;
        //int init_uhidden = 4;
        int init_uoutput = 1;
        //double init_alfa = 1;
        //int init_maxloop = 10000;
        //double init_ERR = 0.01;
        //double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
        
        this.x = init_x;
        this.t = init_t;
        this.unit_input = init_uinput;
        //this.unit_hidden = init_uhidden;
        this.unit_output = init_uoutput;
        //this.alfa = init_alfa;
        //this.maxloop = init_maxloop;
        //this.ERR = init_ERR;
        
        
        double init_v[][] = new double[this.unit_input][this.unit_hidden];
        for(int a=0; a<init_v.length; a++){
            for(int b=0; b<init_v[0].length; b++){
                init_v[a][b] = Math.random();
            }
        }
        //double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
        double init_v0[] = new double[this.unit_hidden];
        for(int a=0; a<init_v0.length; a++){
            init_v0[a] = Math.random();
        }
        //double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
        double init_w[][] = new double[this.unit_output][this.unit_hidden];
        for(int a=0; a<init_w.length; a++){
            for(int b=0; b<init_w[0].length; b++){
                init_w[a][b] = Math.random();
            }
        }
        //double init_w0[] = {0.9505};
        double init_w0[] = new double[this.unit_output];
        for(int a=0; a<init_w0.length; a++){
            init_w0[a] = Math.random();
        }
        
        this.v = init_v;
        this.v0 = init_v0;
        this.w = init_w;
        this.w0 = init_w0;
    }
    
    void learn_static(){
        double data[][] = this.x;
        double target[] = this.t;
        int jumlah_data = data.length;
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        // do it for learn
        int loop = 0;
        //this.maxloop = 1000;
        //System.out.println(jumlah_hidden);
        //System.out.println(this.v0.length);
        //System.exit(0);
        
        do{
            //System.out.println("Loop : "+loop);
            //System.out.println("-----------");
            // for all data
            for(int h=0; h<jumlah_data; h++){
                // hitung z_in dan z
                double z[] = new double[jumlah_hidden];
                for(int j=0; j<jumlah_hidden; j++){
                    //itung sigma xi vij
                    double z_in[] = new double[jumlah_hidden];
                    double jum_xv=0;
                    for(int i=0; i<jumlah_input; i++){
                        double tmp=x[h][i]*v[i][j];
                        jum_xv=jum_xv+tmp;
                    }
                    z_in[j] = v0[j]+jum_xv;
                    z[j] = aktivasi(z_in[j]);
                    //z[j] = 1/(1+(double)Math.exp(-z_in[j]));
                    //z[j] = (1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
                  //  System.out.println("z["+j+"] = "+z[j]);
                }
                
                //~ itung y_in dan y     (output)
                double y[] = new double[jumlah_output];
                for(int k=0; k<jumlah_output; k++){
                    double y_in[] = new double[y.length];
                    double jum_zw=0;
                    for(int j=0; j<jumlah_hidden; j++){
                        double tmp=z[j]*w[k][j];
                        jum_zw=jum_zw+tmp;
                    }
                    y_in[k]=w0[k]+jum_zw;
                    y[k] = aktivasi(y_in[k]);
                    //y[k]=1/(1+(double)Math.exp(-y_in[k]));
                    //y[k]=(1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
                    //System.out.println("Math.exp("+-y_in[k]+") = "+Math.exp(-y_in[k]));
                    //System.out.println("y["+k+"] = "+y[k]);
                }
                
                // hitung MSE
                double sum_e = 0;
                double Err_y[] = new double[jumlah_output];
                for(int k=0; k<jumlah_output; k++){
                    //error otput
                    //Err_y[k]=(t[h]-y[k])*y[k]*(1-y[k]);
                    Err_y[k] = t[h]-y[k];
                    sum_e += Math.pow(Err_y[k],2);
                }
                
                this.MSE = 0.5*sum_e;
                
                //ngitung delta bias dan delta bobot
                double Aw[][] = new double[this.w.length][this.w[0].length];
                double Aw0[] = new double[this.w0.length];
                for(int k=0; k<jumlah_output; k++){
                    for(int j=0; j<jumlah_hidden; j++){
                        //delta bobot hO
                        Aw[k][j] = this.alfa * Err_y[k] * y[k] * z[j];
                        //delta bias hO
                        Aw0[k] = this.alfa * Err_y[k] * y[k];
                    }
                }
                
                //ngitung delta bias dan delta bobot
                double Err_in[] = new double[jumlah_hidden]; 
                double Err_z[] = new double[jumlah_hidden];
                double Av[][] = new double[this.v.length][this.v[0].length];
                double Av0[] = new double[this.v0.length];
                for(int j=0; j<jumlah_hidden; j++){
                    double tmp=0;
                    for(int k=0; k<jumlah_output; k++){
                        tmp = tmp + (Err_y[k]*this.w[k][j]);
                    }
                    // eror sebelum output / setelah hidden
                    Err_in[j]=tmp;
                    // eror hidden (t[h]-y[k])*y[k]*(1-y[k]);
                    Err_z[j]=Err_in[j]*(z[j])*(1-z[j]);

                    for(int i=0; i<jumlah_input; i++){
                        //delta bobot iH
                        Av[i][j]=this.alfa*Err_z[j]*this.x[h][i];
                    }
                    //delta bias  hidden
                    Av0[j]=this.alfa*Err_z[j];
                }
                
                //update bobot dan bias
                //update bobot bias outpuut
                for(int j=0; j<jumlah_hidden; j++){
                    for(int k=0; k<jumlah_output; k++){
                        this.w[k][j]=this.w[k][j]+Aw[k][j];
                        //this.w[k][j]=this.w[k][j]-Aw[k][j];
                    }
                }
                for(int k=0; k<jumlah_output; k++){
                    this.w0[k]=this.w0[k]+Aw0[k];
                    //this.w0[k]=this.w0[k]-Aw0[k];
                }

                //update bobot bias hidden
                for(int i=0; i<jumlah_input; i++){
                    for(int j=0; j<jumlah_hidden; j++){
                        this.v[i][j]=this.v[i][j]+Av[i][j];
                        //this.v[i][j]=this.v[i][j]-Av[i][j];
                    }
                }
                for(int j=0; j<jumlah_hidden; j++){
                    this.v0[j]=this.v0[j]+Av0[j];
                    //this.v0[j]=this.v0[j]-Av0[j];
                }
            }
            loop++;
            //System.out.println("err : "+ERX);
        }while(is_stop()>this.ERR && loop<this.maxloop);
        this.loop = loop;
        //System.out.println("err : "+this.MSE);
        //System.out.println("loop : "+loop);
    }
    
    double aktivasi(double inp){
        return 1/(1+(double)Math.exp(-inp)); 
    }
    
    //penentuan berhenti atau lanjut
    double is_stop(){
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        int jumlah_data = this.x.length;
        double akumY=0;
        
        //~ itung z_in dan z
        for(int h=0; h<jumlah_data; h++){
            double z[] = new double[jumlah_hidden];
            for(int j=0; j<jumlah_hidden; j++){
                //itung sigma xi vij
                double z_in[] = new double[z.length];
                double jum_xv=0;
                for(int i=0; i<jumlah_input; i++){
                    double tmp=this.x[h][i]*this.v[i][j];
                    jum_xv=jum_xv+tmp;
                }
                z_in[j]=this.v0[j]+jum_xv;
                z[j] = aktivasi(z_in[j]);
                //z[j]=1/(1+(double)Math.exp(-z_in[j]));
                //z[j]=(1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
                //System.out.println(-z_in[j]);
            }

            //~ itung y_in dan y (output)
            double y[] = new double[jumlah_output];
            for(int k=0; k<jumlah_output; k++){
                double y_in[] = new double[y.length];
                double jum_zw=0;
                for(int j=0; j<jumlah_hidden; j++){
                    double tmp=z[j]*this.w[k][j];
                    jum_zw=jum_zw+tmp;
                }
                y_in[k]=this.w0[k]+jum_zw;
                y[k] = aktivasi(y_in[k]);
                //y[k]=1/(1+(double)Math.exp(-y_in[k]));
                //y[k]=(1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
                //System.out.println("t[]-y = "+t);
                akumY += Math.pow((t[h]-y[k]),2);
            }
        }
        this.MSE = akumY/this.x[0].length;
        return this.MSE;
    }
    
    void test(double data[]){
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        double outt[] = this.t;
        
        //pada hidden
        double z[] = new double[jumlah_hidden];
        for(int j=0; j<jumlah_hidden; j++){
            double z_in[] = new double[z.length];
            double tmp = 0;
            for(int i=0; i<data.length; i++){
                tmp = tmp + (data[i] * this.v[i][j]);
            }
            z_in[j] = this.v0[j] + tmp;
            z[j] = aktivasi(z_in[j]);
            //z[j] = 1/(1+(double)Math.exp(-z_in[j]));
            //z[j] = (1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
        }

        //pada ouotpr
        double y[] = new double[jumlah_output];
        for(int k=0; k<jumlah_output; k++){
            double y_in[] = new double[y.length];
            double tmp = 0;
            for(int j=0; j<jumlah_hidden; j++){
                tmp = tmp + z[j] * this.w[k][j];
            }
            y_in[k] = this.w0[k] + tmp;

            y[k] = aktivasi(y_in[k]);
            //y[k] = 1/(1+(double)Math.exp(-y_in[k]));
            //y[k] = (1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
/*
            if(y[k]<0.1){
                y[k] = -1;
            }else if(y[k]>0.1){
                y[k] = 1;
            }else{
                y[k] = 0;
            }
            /*
            if(y[k]>0)
             y[k]=1;
            else
             y[k]=0;*/
            double err_pad = this.MSE*this.x[0].length;
            double hazil = 0;
            if(y[k] < err_pad){
                hazil = 0;
            }else if(y[k]>(1-err_pad)){
                hazil = 1;
            }else{
                hazil = 0.5;
            }
            
            this.hasil_mentah = y[k];
            this.hasil_akhir = hazil;
            //System.out.println("Output "+y[k]);
        }
    }
    
    double double_format(double num, int len){
        String format = "#.";
        for(int a=0; a<len; a++){
            format += "#";
        }
        DecimalFormat change = new DecimalFormat(format);
        return Double.valueOf(change.format(num));
    }
    
    String kesimpulan(double h){
        String x = "";
        switch(String.valueOf(h)){
            case "0.0":
                x = "Hard Contact Lenses";
                break;
            case "0.5":
                x = "Soft Contact Lenses";
                break;
            case "1.0":
                x = "No Contact Lenses";
                break;
        }
        return x;
    }
    /*
    public static void main(String haripinter[]){
       BP BP = new BP();
       BP.init_static();
       BP.learn_static();
       /*double ax[] = {0.5,0.5};
       double bx[] = {0.5,1};
       double cx[] = {1,0.5};
       double dx[] = {1,1};
       BP.test(ax);
       BP.test(bx);
       BP.test(cx);
       BP.test(dx);*/
       
       //double xys[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};//
    /*
       double xys[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
       for(int a=0; a<xys.length; a++){
           double inp[] = xys[a];
           System.out.println(BP.t[a]);
           BP.test(inp);
       }
       //BigDecimal k = new BigDecimal(Math.exp(10));
       
       //System.err.println(-1-(-1));
    }*/
}

Berikut contoh script metode pembelajaran lainnya :
1. Hebb Rule
2. Delta Rule
3. Perceptron
4. Backpropagation
5. Constructive Backpropagation (dg momentum)

Written by ElangSakti
Java : Contoh Script Algoritma Backpropagation ~ Jaringan Saraf Tiruan (JST)
Bahasan: Sebelumnya kita sudah membahas tentang Hebb Rule, Delta Rule, dan Perceptron. Kali ini kami contohkan script algoritma dasar dari Backprop...
Published at , Updated at
Reviewed by dr. on 2014-01-13T11:06:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Java : Contoh Script Algoritma Perceptron ~ Jaringan Saraf Tiruan (JST)

ElangSakti Informatika , jaringan saraf tiruan , jst , Perceptron Tidak ada komentar

Berikutnya sudah kita bahas tentang metode pembelajaran pada jaringan saraf tiruan yang namanya Hebb Rule dan Delta Rule, kali ini saya berikan contoh metode pembelajaran Perceptron.

/**
 *
 * @author x86
 */
package c0der;

public class perceptron{
    final double alfa=0.8;
    final double teta=0.5;
    double yOut;
    double y;
    double bias;
    double trans[],bobot[];
    int epoh;
    boolean kondisi;

    public void learn(double[][] inputan, double[] target){
        trans = new double[target.length];
        bobot = new double[inputan.length];
        //mengubah nilai -1 dengan 0
        for(int a=0; a<target.length; a++){
            if(target[a]==1){
                trans[a]=1;
            }else{
                trans[a]=-1;
            }
        }

        epoh=0;
        do{
            System.out.println(++epoh);
            kondisi=true;
            for(int b=0; b<inputan.length; b++){
                //prncarian nilai output
                double bubut=0;
                for(int c=0; c<inputan[0].length; c++){
                    bubut+=bobot[c]*inputan[b][c];
                    System.out.print(bobot[c]);
                }
                System.out.println();
                yOut=bias+bubut;

                //penggunaan pengaktifan bipolar
                if(yOut<-teta){
                    y=-1;
                }else if((yOut>=-teta)&&(yOut<=teta)){
                    y=0;
                }else{
                    y=1;
                }

                //penentuan kondisi
                if(y!=trans[b]){
                    for(int c=0; c<inputan[0].length; c++){
                        bobot[c]=bobot[c]+alfa*trans[b]*inputan[b][c];
                    }
                    bias=bias+alfa*trans[b];
                    kondisi=false;
                }
            }

            if(epoh==1000){
                System.out.println("I Dont Know This...");
                kondisi=true;
            }
        }
        while(kondisi==false);
    }


    public void test(double in1,double in2){
        yOut=bias+in1*bobot[0]+in2*bobot[1];

        if(yOut<-teta){
            y=-1;
        }else if((yOut>-teta) && (yOut<teta)){
            y=0;
        }else{
            y=1;
        }

        if(y==-1) y=0;
        System.out.println((int)in1+" "+(int)in2+" adalah "+(int)y);
    }

    public static void main(String haripinter[]){
        perceptron persept = new perceptron();
        double data[][] = {{1,1},{1,0},{0,1},{0,0}};
        double target[] = {1,1,1,0};
        persept.learn(data, target);
        
        persept.test(1, 1);
        persept.test(0, 1);
        persept.test(1, 0);
        persept.test(0, 0);
        
    }
}

Berikut contoh script metode pembelajaran lainnya :
1. Hebb Rule
2. Delta Rule
3. Perceptron
4. Backpropagation
5. Constructive Backpropagation (dg momentum)

Written by ElangSakti
Java : Contoh Script Algoritma Perceptron ~ Jaringan Saraf Tiruan (JST)
Bahasan: Berikutnya sudah kita bahas tentang metode pembelajaran pada jaringan saraf tiruan yang namanya Hebb Rule dan Delta Rule, kali ini saya be...
Published at , Updated at
Reviewed by dr. on 2014-01-13T11:01:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Java : Contoh Script Algoritma Delta Rule ~ Jaringan Saraf Tiruan (JST)

ElangSakti delta rule , Informatika , jaringan saraf tiruan , jst 1 komentar

Berbeda dengan metode pembelajaran Hebb Rule, Delta Rule dianggap sebagai metode pembelajaran yang lebih efektif dan cepat dibandingkan dengan Heb Rule. Tapi tentu perbandingan tersebut relatif :)

/**
 *
 * @author x86
 */
package c0der;

class deltaRule{
    final double alfa=0.2;
    final double teta=0.5;
    //double output[]=new double[target.length];
    double output[];
    //double eror[]=new double[inputan.length];
    double eror[];
    boolean kondisi;
    double bobot[]={0.1,0.3};
    int epoh;
    double y, yOut;

    void learn(double[][] inputan,double[] target){
        output = new double[target.length];
        eror = new double[inputan.length];
        kondisi=false;
        epoh=0;
        do{
            System.out.println(++epoh);
            for(int a=0; a<inputan.length; a++){
                //pencarian nilai output
                yOut=0;
                for(int b=0; b<inputan[0].length; b++){
                  yOut+=inputan[a][b]*bobot[b];
                }

                //pergantian bobot jika antara target dan output belum sesuai
                for(int b=0; b<inputan[0].length; b++){
                    //pengaktifan biner
                    if(yOut<=teta){
                      output[a]=0;
                    }else{
                      output[a]=1;
                    }
                    eror[a]=target[a]-output[a];
                    bobot[b]+=alfa*inputan[a][b]*eror[a];
                }
            }

            //penetuan kondisi
            int x=0;
            for(int b=0; b<target.length; b++){
                if(output[b]!=target[b]){
                  x++;
                }
            }
            if(x==0) kondisi=true;
            //jika sistem tidak bisa melakukan pembelajaran
            if(epoh==10000){
                System.out.println("I Dont Know This...");
                kondisi=true;
            }
        }
        while(kondisi==false);
    }

    void test(double in1,double in2){
        y=in1*bobot[0]+in2*bobot[1];
        if(y<=teta){
            y=0;
        }else{
            y=1;
        }
        System.out.println((int)in1+" "+(int)in2+" "+(int)y);
    }
    
    public static void main(String haripinter[]){
        deltaRule delta = new deltaRule();
        double data[][] = {{1,1},{1,0},{0,1},{0,0}};
        double target[] = {1,1,1,0};
        delta.learn(data, target);
        
        delta.test(1, 1);
        delta.test(0, 1);
        delta.test(1, 0);
        delta.test(0, 0);
    }
}

Berikut contoh script metode pembelajaran lainnya :
1. Hebb Rule
2. Delta Rule
3. Perceptron
4. Backpropagation
5. Constructive Backpropagation (dg momentum)

Written by ElangSakti
Java : Contoh Script Algoritma Delta Rule ~ Jaringan Saraf Tiruan (JST)
Bahasan: Berbeda dengan metode pembelajaran Hebb Rule, Delta Rule dianggap sebagai metode pembelajaran yang lebih efektif dan cepat dibandingkan de...
Published at , Updated at
Reviewed by dr. on 2014-01-13T10:56:00+07:00
Rating: 4.7

1 komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Java : Contoh Script Algoritma Hebb Rule ~ Jaringan Saraf Tiruan (JST)

ElangSakti Hebb Rule , Informatika , jaringan saraf tiruan , Java , jst Tidak ada komentar

Bagi yang sedang belajar tentang jaringan saraf tiruan, tentu nantinya akan berhadapan dengan yang namanya Hebb Rule, Perceptron, Delta Rule, dan Backpropagation. Mereka itu adalah beberapa metode pembelajaran dalam jaringan saraf tiruan.

/**
 *
 * @author x86
 */
package c0der;

public class hebbRule{
    public double bobot[]={0.2,0.2};
    double bias, yOut;
    int y;
    int epoh;

    void learn(double[][] inputan,double[] target){
        epoh=0;
        double bias=0;
        for(int a=0; a<inputan.length; a++){
            //pencarian bobot
            for(int b=0; b<inputan[0].length; b++){
                bobot[b]=bobot[b]+inputan[a][b]*target[a];
            }
            //pencarian bias
            bias+=1*target[a];
        }
    }

    void test(double in1, double in2){
        yOut=bias+in1*bobot[0]+in2*bobot[1];

        //penggunaan pengaktifan biner
        if(yOut>=2.2)
         y=1;
        else
         y=0;

        System.out.println((int)in1+" "+(int)in2+" = "+(int)y);
    }

    public static void main(String haripinter[]){
        hebbRule hebb = new hebbRule();
        double data[][] = {{1,1},{1,0},{0,1},{0,0}};
        double target[] = {1,1,1,0};
        hebb.learn(data, target);
        
        hebb.test(1, 1);
        hebb.test(0, 1);
        hebb.test(1, 0);
        hebb.test(0, 0);
        
    }
}

Monggo buat yang mau sharing atau mau bertanya.. Untuk contoh metode lainnya, bisa dilihat pada posting lainnya.

Berikut contoh script metode pembelajaran lainnya :
1. Hebb Rule
2. Delta Rule
3. Perceptron
4. Backpropagation
5. Constructive Backpropagation (dg momentum)

Written by ElangSakti
Java : Contoh Script Algoritma Hebb Rule ~ Jaringan Saraf Tiruan (JST)
Bahasan: Bagi yang sedang belajar tentang jaringan saraf tiruan, tentu nantinya akan berhadapan dengan yang namanya Hebb Rule, Perceptron, Delta Ru...
Published at , Updated at
Reviewed by dr. on 2014-01-13T10:41:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Video : Rangkaian Dasar Joule Thief

ElangSakti Back EMF , Electronics , Elektronika , Joule Thief , skema 19 komentar

Sebelumnya kita sudah membahas tentang dasar dari Joule Thief, yaitu konsep tentang Back EMF. Joule Thief adalah hasil penerapan dari efek Back EMF dimana pada tulisan sebelumnya, back EMF dihasilkan ketika suatu rangakaian koil / lilitan diputus arusnya.

Nah, pada joule thief, sakelar pemutus arus tidak manual lagi, tapi menggunakan transistor. Pada transistor ada istilah batas ambang dan cut off, kapan batas minimal transistor akan bekerja dan kapan maksimal transistor akan berhenti bekerja. Nah, jeda pemutusan kerja transistor itulah yang dijadikan patokan untuk memutus-nyambung-putus-nyambung terus menerus secara konstan. Akibatnya, Back EMF akan terus dihasilkan oleh koil dan led akan terus menerus menyala.

Sebenarnya lednya hidup-mati-hidup-mati, tapi karena frekuensinya tinggi / prosesnya sangat cepat, jadi yang dilihat oleh mata kita adalah led yang menyala terus-menerus. So, saya tidak tahu kenapa rangkaian berikut dinamakan Joule Thief, tapi inti dari yang namanya Joule Thief ya itu tadi, seperti yang saya paparkan. :) Ini rangkaian Joule Thief yang sederhana untuk menyalakan banyak led.

Rangkaian dasar Joule Thief

Pada video di bawah ini, satu batre 0.9 volt bisa menyalakan dua buah led, bahkan lebih. Pada video, saya menggunakan lilitan primer sebanyak 8 lilit dan sekunder 32 lilit. Lilitan ini ditentukan dengan kebutuhan. Saya memilih jumlah lilitan tersebut dan perbandingan 1:4 hanya sebagai percobaan saja. Jadi pemilihan 1:4 masih tidak menggunakan hitungan :).

Kemudian untuk resistor, pada percobaan saya ganti dengan potensio 1K, maksudnya biar bisa saya coba-coba. Jadi resistor efektif untuk satu batre itu mulai 470 ohm. Transistor yang digunakan harus NPN, jadi jenis / kode transistor berpengaruh pada daya dan frekuensi yang bisa dibebankan. Transistor untuk menyalakan led 1.8 volt tentu beda dengan transistor untuk menyalakan lampu TL, dayanya sudah beda.

Bonus : Joule Thief untuk lampu LED HPL

Artikel lainnya yang berkaitan dengan Joule Thief, Fungsi Relay Pengertian, Prinsip, dan Cara Kerja Relay dan Driving Relay - Mengaktifkan Relay 12v dengan 3v Input.

Written by ElangSakti
Video : Rangkaian Dasar Joule Thief
Bahasan: Sebelumnya kita sudah membahas tentang dasar dari Joule Thief, yaitu konsep tentang Back EMF . Joule Thief adalah hasil penerapan dari efe...
Published at Minggu, 05 Januari 2014, Updated at Minggu, 05 Januari 2014
Reviewed by dr. on 2014-01-05T20:59:00+07:00
Rating: 4.7

19 komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Video : Lebih Memahami Back EMF pada Coil (Konsep dasar Joule Thief)

ElangSakti Back EMF , Elektronika , Joule Thief , Lilitan 5 komentar

Apa itu Back EMF? Apa itu Joule Thief?

Sebelum menjawab kedua pertanyaan tersebut, mungkin pembaca lebih sering medapatkan suguhan informasi tentang JT atau Joule Thief daripada Back EMF. Oke, sebelum kita membahas keduanya, coba ingat-ingat kembali tentang konsep coil, lilita, toroid. Coba ingat-ingat kembali tentang medan elektromagnet pada seuatas kawat yang dialiri arus listrik. :)

Pada dasarnya, logam jika dialirih arus listik akan mengeluarkan (dikelilingi) medan elektromagnet (selanjutnya saya singkat medan magnet saja) sesuai dengan arah arus. Ingat aturan tangan kanan? Kepalkan tangan pembaca, kecuali jempol. Nah, jempol menunjukkan arah arus, sedangkan jari-jemari lainnya menunjukkan arah medan magnet. Ingat, ada arus mengalir, ada medan magnet ditimbulkan.

Sebaliknya, adanya medan magnet akan menimbilkan adanya arus listrik. Perhatikan pada trafo / transformator, misal pada trafo step down atau trafo penurun tegangan. Apakah kabel / lilitan pada sisi primer bersambung ke lilitan sekunder? Tidak. Lalu bagaimana bisa pada lilitan sekunder juga ada listriknya? Itu disebabkan karena adanya medan elektromagnet yang dihasilkan pada lilitan primer yang berpindah pada lilitan sekunder. Proses tersebut dinamakan dengan induksi, induksi elektromagnetik.

Awalnya lilitan primer menghasilkan medan magnet, kemudan inti besi pada trafo memperkuat induksi tersebut, selanjutnya medan magnet pada besi trafo menginduksi lilitan sekunder sehingga timbulkan listrik pada lilitan sekunder. Lalu apa hubungannnya dengan Back EMF dan Joule Thief?

Secara sederhana :) (untuk versi rumitnya pembaca bisa cari di google), Back EMF merupakan energi (listrik) yang dihasilkan oleh lilitan sesaat setelah arus diputus pada lilitan tersebut. Ingat, pengertian ini bukan pengertian ilmiah, akan tetapi sekedar pengertian konsep sederhana saja. Ketika arus mengalir pada lilitan, maka otomatis lilitan tersebut memiliki medan elektromagnet dan membuat intinya 'menjadi magnet'. Dan ketika arus pada lilitan tersebut diputus, maka medan elektromagnet tersebut akan 'diserap' kembali oleh kawat lilitan sehingga kawat tersebut akan dialiri arus. Arus itu mempunyai polaritas yang berkebalikan dengan arus sebelumnya. Arus yang mengalir itu disebut dengan Back EMF.

Jadi, kadang Back EMF ini bisa merusak rangkaian karena arusnya yang lebih besar. Misal, rusaknya transistor akhir pada power amplifier kadang disebabkan adanya Back EMF dari spool mic. Oleh karena itu harus dikasi pengaman.

Untuk melihat adanya Back EMF, berikut rangkaian dasar yang bisa dicoba.

Perhatikan pada rangkaian di atas, positif batere ke kutup negatif led, kutub negatif batere ke kutub positif led. Secara sederhan, led tersebut tidak mungkin menyala karena dua alasan. Pertama, kutub positif led dan baterai terbalik, jadi tidak mungkin menyala. Kedua, umumnya led akan menyala ketika dikasi tegangan 1.8 volt, jadi baterai AA yang dipake hanya 1.5 volt, itupun sudah bekas jam dinding. Jadi seharusnya led tersebut tidak bisa menyala.

Lalu bagaimana agar led tersebut tetap bisa menyala? Kita gunakan Back EMF. Caranya? sambungkan rangkaian, kemudian buka sakelar. Nah, ketika sakelar diputus / dibuka, Back EMF akan mengalir ke led dan membuat led menyala. Ingat, Back EMF tegangannya besar dan arah arusnya terbalik dengan arah arus baterai. Arus yang dari baterai ke kanan, makan Back EMF arusnya ke kiri. Itulah sebabnya kenapa kutub positif led disambungkan dengan kutub negatif baterai. Ketika sakelar diputus, maka kutub positif led akan mendapatkan aliran arus dari lilitan / coil.

Coba perhatikan video berikut :

Oke, untuk Joule Thief, kita bahasa pada ulasan berikutnya. Saya bukan sarjana Fisika atau Elektro, jadi mohon koreksinya jika ada kekeliruan.Oiya, untuk back EMF ini salah satu implementasi untuk membuat rangkaian Joule Thief, contohnya bisa baca Video : Rangkaian Dasar Joule Thief.

Written by ElangSakti
Video : Lebih Memahami Back EMF pada Coil (Konsep dasar Joule Thief)
Bahasan: Apa itu Back EMF? Apa itu Joule Thief? Sebelum menjawab kedua pertanyaan tersebut, mungkin pembaca lebih sering medapatkan suguhan inf...
Published at , Updated at
Reviewed by dr. on 2014-01-05T20:13:00+07:00
Rating: 4.7

5 komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Elektron : Sekedar Puisi Galau

ElangSakti Elektron , Materi Dasar , Mekanika , Puisi Galau Tidak ada komentar

Bagaimana bisa elektron tahu bahwa di sekitarnya ada konduktor yang bermuatan positif?

Bagaimana bisa elektron yang ada di awan tahu kalau ada tiang listrik yang terhubung ke tanah?

Bagaimana bisa elektron tahu kalau pohon adalah jalan paling 'dekat' ke tanah daripada manusia?

Bagaimana bisa elektron tahu kalau logam yang dia tempati dekat dengan logam lain sehingga dia meloncat ke logam yang lain (hingga terjadi percikan api / sparks)?

Apa yang sebenarnya terjadi antara elektron dan proton? Apa mereka berkomunikasi?

Jika memang elektron itu seperti air, bergerak dari yang tinggi ke yang rendah

Atau jika memang elektron itu seperti bubuk pewarna dalam cairan yang akan bergerak mewarnai seluruh cairan hingga warna seluruh cairan merata,,

Berarti sebelum terjadi petir, sebelum terjadi loncatan elektron dari awan ke bumi

Mestinya elektron dari awan sudah berada di udara, berlompatan ke udara sehingga menemukan jalur yang menariknya ke bumi

Sehingga elektron lain mulai tertarik dan berkumpul di jalur itu

Seperti asap, ketika ada lubang kecil yang menarik asap tersebut, maka asap di sekelilingnya seakan menyusut jadi lebih padat

Kemudian membentuk seperti kain yang terpilin dan masuk ke lubang itu

Mungkin begitu.

Spreading the gap.

Mestinya kita bisa 'menangkap' elektron-elektron itu di udara.

how..

Engngng... di sisi lain, elektron-proton saling tarik menarik, elektron-elektron saling menolak..

Artinya, ada 'medan magnet' di anatara kedua muatan itu.

Emang seberapa besar jangkauan 'medan magnet' muatan-muatan itu?

Lalu 'medan magnet' itu sendiri apa? Kan elektron sudah barang paling kecil...

Apa 'medan magnet' itu semacam pancaran fekuensi?

Apa frekuensi itu ndak ada hubungannya dengan elektron juga?

GGaaaHHH!!!

Written by ElangSakti
Elektron : Sekedar Puisi Galau
Bahasan: Bagaimana bisa elektron tahu bahwa di sekitarnya ada konduktor yang bermuatan positif? Bagaimana bisa elektron yang ada di awan tahu kal...
Published at , Updated at
Reviewed by dr. on 2014-01-05T08:48:00+07:00
Rating: 4.7

Tidak ada komentar :

Posting Komentar

# Hack Your Skills! to be Professional Mechatronics

Java : Contoh Algoritma JST Backpropagation

ElangSakti bakcpropagation , Informatika , jaringan saraf tiruan , Java , jst 1 komentar

Good day all, kali ini saya menulis ulang algoritma jaringan saraf tiruan (jst) dengan pembelajaran backpropagation. Script ini saya buat berdasarkan buku hijaunya Sri Kusumadewi, jadi jika ingin memahaminya lebih dalam, bisa sambil membaca buku tersebut, judulnya "Artificial Intelligence (teknik dan aplikasinya)".

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package backpro;

import java.text.DecimalFormat;

/**
 * hari at elangsakti.com
 * @author x86
 */
public class BP {
    // kondisi
    double x[][];
    // target
    double t[];
    
    int unit_input;
    int unit_hidden;
    int unit_output;
    
    // learning rate
    double alfa;
    // maximum loop
    int maxloop;
    // target error
    double ERR;
    // last error
    double ERX;
    
    // bobot input - hidden
    double v[][];
    // bobot bias - hidden 
    double v0[];
    // bobot hidden - ouput
    double w[][];
    // bobot bias - output
    double w0[];
    
    void init_static(){
        double init_x[][] = {{0,1},{1,0},{1,1},{0,0}};
        double init_t[] = {1,1,0,0};
        int init_uinput = init_x[0].length;
        int init_uhidden = 4;
        int init_uoutput = 1;
        double init_alfa = 1;
        int init_maxloop = 1000;
        double init_ERR = 0.01;
        double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
        double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
        double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
        double init_w0[] = {0.9505};
        
        this.x = init_x;
        this.t = init_t;
        this.unit_input = init_uinput;
        this.unit_hidden = init_uhidden;
        this.unit_output = init_uoutput;
        this.alfa = init_alfa;
        this.maxloop = init_maxloop;
        this.ERR = init_ERR;
        this.v = init_v;
        this.v0 = init_v0;
        this.w = init_w;
        this.w0 = init_w0;
    }
    
    void learn_static(){
        double data[][] = this.x;
        double target[] = this.t;
        int jumlah_data = data.length;
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        // do it for learn
        int loop = 0;
        this.maxloop = 1000;
        
        do{
            // for all data
            for(int h=0; h<jumlah_data; h++){
                // hitung z_in dan z
                double z[] = new double[data.length];
                for(int j=0; j<jumlah_hidden; j++){
                    //itung sigma xi vij
                    double z_in[] = new double[z.length];
                    double jum_xv=0;
                    for(int i=0; i<jumlah_input; i++){
                        double tmp=x[h][i]*v[i][j];
                        jum_xv=jum_xv+tmp;
                    }
                    z_in[j] = v0[j]+jum_xv;
                    z[j] = 1/(1+(double)Math.exp(-z_in[j]));
                }
                
                //~ itung y_in dan y     (output)
                double y[] = new double[jumlah_output];
                for(int k=0; k<jumlah_output; k++){
                    double y_in[] = new double[y.length];
                    double jum_zw=0;
                    for(int j=0; j<jumlah_hidden; j++){
                        double tmp=z[j]*w[k][j];
                        jum_zw=jum_zw+tmp;
                    }
                    y_in[k]=w0[k]+jum_zw;
                    y[k]=1/(1+(double)Math.exp(-y_in[k]));
                }
                
                //ngitung error output dan delta bias dan delta bobot
                double Err_y[] = new double[jumlah_output]; 
                double Aw[][] = new double[this.w.length][this.w[0].length];
                double Aw0[] = new double[this.w0.length];
                for(int k=0; k<jumlah_output; k++){
                    //error otput
                    Err_y[k]=(t[h]-y[k])*y[k]*(1-y[k]);
                    
                    
                    for(int j=0; j<jumlah_hidden; j++){
                        //delta bobot hO
                        Aw[k][j] = alfa*Err_y[k]*z[j];
                        //delta bias hO
                        Aw0[k] = alfa*Err_y[k];
                    }
                }
                
                //ngitung error hiden dan delta bias dan delta bobot
                double Err_in[] = new double[jumlah_hidden]; 
                double Err_z[] = new double[jumlah_hidden];
                double Av[][] = new double[this.v.length][this.v[0].length];
                double Av0[] = new double[this.v0.length];
                for(int j=0; j<jumlah_hidden; j++){
                    double tmp=0;
                    for(int k=0; k<jumlah_output; k++){
                        tmp = tmp + (Err_y[k]*this.w[k][j]);
                    }
                    // eror sebelum output / setelah hidden
                    Err_in[j]=tmp;
                    // eror hidden (t[h]-y[k])*y[k]*(1-y[k]);
                    Err_z[j]=Err_in[j]*(z[j])*(1-z[j]);

                    for(int i=0; i<jumlah_input; i++){
                        //delta bobot iH
                        Av[i][j]=this.alfa*Err_z[j]*this.x[h][i];
                    }
                    //delta bias  hidden
                    Av0[j]=this.alfa*Err_z[j];
                }
                
                //update bobot dan bias
                //update bobot bias outpuut
                for(int j=0; j<jumlah_hidden; j++){
                    for(int k=0; k<jumlah_output; k++){
                        this.w[k][j]=this.w[k][j]+Aw[k][j];
                    }
                }
                for(int k=0; k<jumlah_output; k++){
                    this.w0[k]=this.w0[k]+Aw0[k];
                }

                //update bobot bias hidden
                for(int i=0; i<jumlah_input; i++){
                    for(int j=0; j<jumlah_hidden; j++){
                        this.v[i][j]=this.v[i][j]+Av[i][j];
                    }
                }
                for(int j=0; j<jumlah_hidden; j++){
                    this.v0[j]=this.v0[j]+Av0[j];
                }
            }
            loop++;
        }while(is_stop()>this.ERR && loop<this.maxloop);
        System.out.println("err : "+ERX);
        System.out.println("loop : "+loop);
    }
    
    //penentuan berhenti atau lanjut
    double is_stop(){
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        int jumlah_data = this.x.length;
        double akumY=0;
        
        //~ itung z_in dan z
        for(int h=0; h<jumlah_data; h++){
            double z[] = new double[jumlah_hidden];
            for(int j=0; j<jumlah_hidden; j++){
                //itung sigma xi vij
                double z_in[] = new double[z.length];
                double jum_xv=0;
                for(int i=0; i<jumlah_input; i++){
                    double tmp=this.x[h][i]*this.v[i][j];
                    jum_xv=jum_xv+tmp;
                }
                z_in[j]=this.v0[j]+jum_xv;
                z[j]=1/(1+(double)Math.exp(-z_in[j]));
            }

            //~ itung y_in dan y (output)
            double y[] = new double[jumlah_output];
            for(int k=0; k<jumlah_output; k++){
                double y_in[] = new double[y.length];
                double jum_zw=0;
                for(int j=0; j<jumlah_hidden; j++){
                    double tmp=z[j]*this.w[k][j];
                    jum_zw=jum_zw+tmp;
                }
                y_in[k]=this.w0[k]+jum_zw;
                y[k]=1/(1+(double)Math.exp(-y_in[k]));
                
                akumY += Math.pow((t[h]-y[k]),2);
            }
        }
        double E = akumY/this.x[0].length;
        ERX = akumY;
        return E;
    }
    
    void test(double data[]){
        int jumlah_input = this.unit_input;
        int jumlah_hidden = this.unit_hidden;
        int jumlah_output = this.unit_output;
        
        //pada hidden
        double z[] = new double[jumlah_hidden];
        for(int j=0; j<jumlah_hidden; j++){
            double z_in[] = new double[z.length];
            double tmp = 0;
            for(int i=0; i<data.length; i++){
                tmp = tmp + (data[i] * this.v[i][j]);
            }
            z_in[j] = this.v0[j] + tmp;
            z[j] = 1/(1+(double)Math.exp(-z_in[j]));
        }

        //pada ouotpr
        double y[] = new double[jumlah_output];
        for(int k=0; k<jumlah_output; k++){
            double y_in[] = new double[y.length];
            double tmp = 0;
            for(int j=0; j<jumlah_hidden; j++){
                tmp = tmp + z[j] * this.w[k][j];
            }
            y_in[k] = this.w0[k] + tmp;

            y[k] = 1/(1+(double)Math.exp(-y_in[k]));

            if(y[k]>0.5)
             y[k]=1;
            else
             y[k]=0;
            System.out.println("Output "+(double)y[k]);
        }
    }
    
    double double_format(double num, int len){
        String format = "#.";
        for(int a=0; a<len; a++){
            format += "#";
        }
        DecimalFormat change = new DecimalFormat(format);
        return Double.valueOf(change.format(num));
    }
    
    public static void main(String haripinter[]){
       BP BP = new BP();
       BP.init_static();
       BP.learn_static();
       double ax[] = {0,0};
       double bx[] = {0,1};
       double cx[] = {1,0};
       double dx[] = {1,1};
       BP.test(ax);
       BP.test(bx);
       BP.test(cx);
       BP.test(dx);
    }
}

Berikut hasil kompilasi dan eksekusi dari script di atas :

run:
err : 0.01997614559923392
loop : 639
Output 0.0
Output 1.0
Output 1.0
Output 0.0
BUILD SUCCESSFUL (total time: 1 second)

Written by ElangSakti
Java : Contoh Algoritma JST Backpropagation
Bahasan: Good day all, kali ini saya menulis ulang algoritma jaringan saraf tiruan (jst) dengan pembelajaran backpropagation. Script ini saya buat ...
Published at Sabtu, 04 Januari 2014, Updated at Sabtu, 04 Januari 2014
Reviewed by dr. on 2014-01-04T19:24:00+07:00
Rating: 4.7

1 komentar :

Posting Komentar

Langganan: Postingan ( Atom )