• Beranda
  • Kelas
  • Blog
  • Lainnya
    • Event
    • Webinar
      • DaftarLogin
    InformatikawanInformatikawan
    • Beranda
    • Kelas
    • Blog
    • Lainnya
      • Event
      • Webinar
      • DaftarLogin

      Artificial Intelligence

      • Beranda
      • Blog
      • Artificial Intelligence
      • #SourceCode Back Propagation C++ Jaringan Syaraf Tiruan

      #SourceCode Back Propagation C++ Jaringan Syaraf Tiruan

      • Ditulis oleh Muhammad Fadillah Arsa
      • Kategori Artificial Intelligence
      • Tanggal 18/06/2019
      • Komentar 0 komentar

      Back Propagation merupakan salah satu algoritma yang umum dipakai untuk melatih Jaringan Syaraf Tiruan (JST) melalui proses pembelajaran terarah (supervised learning).

      Back Propagation disebut juga sebagai backward propagation of errors karena ketika kesalahan (error) pada output melebihi batas toleransi, maka error tersebut akan didistribusikan ke lapisan-lapisan (layers) jaringan, kemudian dilakukan penghitungan untuk memodifikasi nilai bobot (weight) dan bias agar dapat mengurangi kesalahan pada output.

      Back Propagation dapat digunakan untuk melatih berbagai macam Recognition System, kecerdasan robot, serta sistem navigasi pada kendaraan.

      Algoritma Back Propagation

      Proses Back Propagation meliputi 3 fase:

      • Fase Propagasi Maju (Feed Forward). Input akan dipropagasi maju melewati hidden layer hingga output layer dengan fungsi aktivasi yang ditentukan.
      • Fase Propagasi Mundur (Backpropagation) dari error yang terkait. Selisih antara output dan target merupakan kesalahan yang terjadi. Kesalahan tersebut dipropagasi mundur, dimulai dari garis yang berhubungan langsung dengan unit-unit pada output layer.
      • Fase Modifikasi Bobot

      Keuntungan Back Propagation

      • Implementasi relatif sederhana.
      • Metode yang umum digunakan dan biasanya bekerja dengan baik.
      • Lama waktu komputasi akan berkurang jika weight yang digunakan pada awal penghitungan nilainya kecil.
      • Pembaruan kumpulan weight yang diperbaiki sekaligus, membuat proses pelatihan terasa halus (smooth).

      Kelemahan Back Propagation

      • Lambat dan tidak efisien, dapat terhambat dalam nilai lokal terkecil (local minima) yang berujung pada hasil yang kurang optimal.
      • Data input/output tersedia dalam jumlah yang besar, namun belum tentu nyambung dengan output yang dituju.
      • Masalah terlihat begitu kompleks, namun jelas ada sebuah solusi.
      • Mudah untuk membuat sejumlah contoh behaviour yang tepat.
      • Hasil penghitungan (solution) suatu masalah dapat berubah seiring waktu, terbatas pada parameter input dan ouput (contoh, hari ini 2+2=4, bisa jadi di masa depan 2+2=3.8).
      • Output bisa jadi “fuzzy”, atau non-numerik.

      Source Code Program

      /*
          Backpropagation karya Benhard Tampubolon
          Sample Input: Logika OR
      */
      
      #include <stdio.h>
      #include <math.h>
      
      #define banyakdata 4
      #define inputlayerneuron 2
      #define hiddenlayerneuron 3
      #define maxepoh 1000
      
      using namespace std;
      
      void backpropagation(double x[banyakdata][inputlayerneuron], double t[banyakdata], double v[inputlayerneuron][hiddenlayerneuron], double v0[hiddenlayerneuron], double w[hiddenlayerneuron], double w0, double alpha, double terror){
          bool stop = false;
          for(int a=0; (a<maxepoh && !stop); a++){
          	double E=0;
          	double mse;
              printf("\nEpoh ke -%d\n", a+1);
              printf("--------------------------------------\n");
              for(int i=0; i<banyakdata; i++){
                  double z_in[hiddenlayerneuron];
                  double z[hiddenlayerneuron];
                  double y_in;
                  double y;
                  double error;
                  double delta1;
                  double deltaw[hiddenlayerneuron];
                  double deltaw0;
                  double delta2in[hiddenlayerneuron];
                  double delta2[hiddenlayerneuron];
                  double deltav[inputlayerneuron][hiddenlayerneuron];
                  double deltav0[hiddenlayerneuron];
      
                  printf("Data ke -%d\n", i+1);
                  printf("--------------------------------------\n\n");
                  for(int j=0; j<hiddenlayerneuron; j++){
                      z_in[j] = v0[j];
                      for(int k=0; k<inputlayerneuron; k++){
                          z_in[j] = z_in[j] + v[k][j] * x[i][k];
                      }
                      printf("z_in ke-%d = %g\n",j+1,z_in[j]);
                  }
                  printf("\n");
                  for(int j=0; j<hiddenlayerneuron; j++){
                      z[j] = 1 / (1+exp(0.0 - z_in[j]));
                      printf("z ke-%d = %g\n",j+1,z[j]);
                  }
                  printf("\n");
                  y_in = w0;
                  for(int j=0; j<hiddenlayerneuron; j++){
                      y_in = y_in + w[j]*z[j];
                  }
                  printf("y_in = %g\n\n",y_in);
                  y = 1 / (1+exp(0.0 - y_in));
                  // y = y_in;
                  printf("y = %g\n\n",y);
                  error=t[i]- y;
                  printf("Error = %g\n", error);
                  E = E+error*error;
                  printf("Jumlah Kuadrat Error = %g\n\n", E);
                  delta1 = error * y * (1-y);
                  printf("delta 1 = %g\n\n",delta1);
                  for(int j=0; j<hiddenlayerneuron; j++){
                      deltaw[j] = alpha*delta1*z[j];
                      printf("delta w ke-%d = %g\n",j+1,deltaw[j]);
                  }
                  printf("\n");
                  deltaw0 = alpha*delta1;
                  printf("delta w0 = %.4f\n\n",deltaw0);
                  for(int j=0; j<hiddenlayerneuron; j++){
                      delta2in[j] = delta1*w[j];
                      printf("delta 2 in ke-%d = %g\n",j+1,delta2in[j]);
                  }
                  printf("\n");
                  for(int j=0; j<hiddenlayerneuron; j++){
                      delta2[j] = delta2in[j]*z[j]*(1-z[j]);
                      printf("delta 2 ke-%d = %g\n",j+1,delta2[j]);
                  }
                  printf("\n");
                  for(int j=0; j<inputlayerneuron; j++){
                      for(int k=0; k<hiddenlayerneuron; k++){
                          deltav[j][k] = alpha*delta2[k]*x[i][j];
                          printf("deltav%d%d = %g\n",j+1,k+1,deltav[j][k]);
                      }
                  }
                  printf("\n");
                  for(int j=0; j<hiddenlayerneuron; j++){
                      deltav0[j] = alpha*delta2[j];
                      printf("deltav0 ke-%d = %g\n",j+1,deltav0[j]);
                  }
                  printf("\n");
                  for(int j=0; j<inputlayerneuron; j++){
                      for(int k=0; k<hiddenlayerneuron; k++){
                          v[j][k] = v[j][k] + deltav[j][k];
                          printf("v%d%d = %g\n",j+1,k+1,v[j][k]);
                      }
                  }
                  printf("\n");
                  for(int j=0; j<hiddenlayerneuron; j++){
                      v0[j] = v0[j] + deltav0[j];
                      printf("v%d = %g\n",j+1,v0[j]);
                  }
                  printf("\n");
                  for(int j=0; j<hiddenlayerneuron; j++){
                      w[j] = w[j] + deltaw[j];
                      printf("w%d = %g\n",j+1,w[j]);
                  }
                  w0 = w0 + deltaw0;
                  printf("\nw0 = %g\n\n",w0);
                  printf("\n");
              }
              mse = E/(banyakdata+1);
              printf("mse = %g\n\n",mse);
              if(mse<terror){
                  stop = true;
                  break;
              }
          }
          printf("hasil\n");
          for(int j=0; j<inputlayerneuron; j++){
              for(int k=0; k<hiddenlayerneuron; k++){
                  printf("v%d%d = %g\n",j+1,k+1,v[j][k]);
              }
          }
          printf("\n");
          for(int j=0; j<hiddenlayerneuron; j++){
              printf("v%d = %g\n",j+1,v0[j]);
          }
          printf("\n");
          for(int j=0; j<hiddenlayerneuron; j++){
              printf("w%d = %g\n",j+1,w[j]);
          }
          printf("\nw0 = %g\n",w0);
      }
      
      int main(){
          double x[banyakdata][inputlayerneuron] = {{1,1},{1,0},{0,1},{0,0}};
          double t[banyakdata] = {1,0,0,0};
          double v[inputlayerneuron][hiddenlayerneuron]={{0.9562,0.7762,0.1623},{0.1962,0.6133,0.0311}};
          double v0[hiddenlayerneuron]={0.7496,0.3796,0.7256};
          double w[hiddenlayerneuron]={0.2280,0.9585,0.6799};
          double w0 = 0.9505;
          double alpha = 1.0;
          double terror = 0.1;
          backpropagation(x,t,v,v0,w,w0,alpha,terror);
          return 0;
      }

      Tag:Jaringan Syaraf Tiruan, Source Code

      • Bagikan:
      Muhammad Fadillah Arsa
      Founder Informatikawan dan Digidik. Mengenyam pendidikan di S1 Teknik Informatika Universitas Padjadjaran. Penulis buku Buku Sakti WordPress. Selengkapnya www.fadillaharsa.id

      Pos sebelumnya

      #SourceCode Perceptron C++ Jaringan Syaraf Tiruan
      18/06/2019

      Pos selanjutnya

      #Projek Aplikasi Dekstop Pembaca Huruf Jepang Melalui Kamera atau Foto
      18/06/2019

      Mungkin kamu juga suka

      tampilan-aplikasi-japan-ocr
      #Projek Aplikasi Dekstop Pembaca Huruf Jepang Melalui Kamera atau Foto
      18 Juni, 2019
      perceptron
      #SourceCode Perceptron C++ Jaringan Syaraf Tiruan
      18 Juni, 2019
      modul artificial intelligence
      Modul Artificial Intelligence untuk Teknik Informatika
      10 Juni, 2019

      Cari

      Pos-pos Terbaru

      • Webinar Flutter for Startup with Ilzam Mulkhaq 05/11/2020
      • Webinar UI/UX Designer with Yunilucki Siswantari 05/11/2020
      • Algoritma Rabin Karp – Metode Pencarian String 15/10/2020

      Kelas Populer

      Ethical Hacking Practical

      Ethical Hacking Practical

      Kelas Terbaru

      UI/UX Design

      UI/UX Design

      Aplikasi Web dengan Python Django

      Aplikasi Web dengan Python Django

      WHATSAPP 3 ADMIN
      BANDUNG INDONESIA
      INFORMATIKAWAN @GMAIL.COM
      BUKA SENIN - SABTU MINGGU: SLOWRESPON

      Informatikawan adalah platform pembelajaran bidang informatika. Menyediakan materi yang lengkap, terarah, dan dibimbing oleh pengajar berpengalaman di bidangnya.

      Fitur

      • Cara Belajar
      • Cara Membeli Kelas

      Lainnya

      • Aturan Penggunaan
      • Kebijakan Privasi
      • Refund Policy
      • Kontak Kami

      Menerima Berbagai Metode Pembayaran

      • ATM Bersama - Pembayaran Informatikawan
      • Prima - Pembayaran Informatikawan
      • Alto - Pembayaran Informatikawan
      • Bank BNI - Pembayaran Informatikawan
      • Bank Mandiri - Pembayaran Informatikawan
      • QRIS - Pembayaran Informatikawan
      • GOPAY GOJEK - Pembayaran Informatikawan
      • LinkAja - Pembayaran Informatikawan
      • OVO - Pembayaran Informatikawan
      • DANA - Pembayaran Informatikawan

      Informatikawan © 2020

      Login with your site account

      Masuk dengan Facebook Masuk dengan Google


      Lost your password?

      Not a member yet? Register now

      Register a new account

      Are you a member? Login now

      Tanya Kelas Berbayar
      Chat Whatsapp kami untuk bertanya perihal kelas online berbayar.
      * Hanya untuk bertanya perihal kelas online berbayar.
      Muhammad Fadillah Arsa
      Admin
      I will be back soon
      Muhammad Hafidz Alfarizi
      Admin
      I will be back soon
      Naufal Ariful Amri
      Admin
      I will be back soon