Category Archive Uncategorized

ByVisions education

KERJA SAMA BAGAIMANA YANG MENGHASILKAN “WIN WIN SOLUTION”????

                Kata “Kerjasama” memiliki makna yang berbeda-beda di kepala saya. Pertama kali kata ini diperkenalkan kepada saya oleh para guru di sekolah. Guru malah memberi nasihat yang terkesan negatif “Jangan bekerja sama dengan teman”. Bekerja sama berarti melakukan kecurangan.” Tentu saja,ketika itu para guru sedang berbicara mengenai aturan main dalam situasi ulangan dan ujian, bukan dalam konteks pergaulan sehari – hari.Namun, entah mengapa justru kerjasama yang berkonotasi negatif itulah yang lebih melekat di kepala saya. Tambahan lagi, saya memperoleh reward yang luar biasa dari ketidakmauan saya untuk bekerjasama dengan orang lain: menjadi juara kelas! itu semakin menguatkan pandangan saya mengenai buruknya kerja sama.Dalam kacamata saya sebagai anak anak ketika itu, kerjasama akan menempatkan saya pada posisi yang dirugikan,karena harus berbagi sesuatu kepada orang lain dan tidak mendapatkan apa pun,padahal bekerja sendiri saja sudah menempatkan saya di peringkat pertama.

             Namun,pandangan tentang kerjasama itu berubah drastis ketika saya memasuki dunia kerja. Ternyata,rumus sukses di tempat kerja berbanding terbalik dengan rumus  sukses di sekolah. Di tempat kerja, kesuksesan justru hanya akan didapatkan kalau  kita pandai bekerjasama dan berkolaborasi dengan orang lain.Kecakapan berkolaborasi bahkan boleh dibilang adalah keahlian terpenting seorang profesional.Itulah sebabnya, kata “kerjasama” boleh dibilang menjadi primadona di tempat kerja.

 

Akan tetapi,sesungguhnya pandangan ini mengandung jebakan yang “DANGEROUS!”.Pandangan ini menempatkan orang ke dalam dua kategori:orang yang bisa bekerjasama versus orang yang tidak bisa bekerjasama.Orang yang bisa bekerjasama disukai dan menjadi orang yang sukses, sementara orang yang tidak bisa bekerja sama malah dibenci ,ini tentu saja merupakan sebuah pandangan yang sangat dangkal dan salah kaprah!

Yang ingin saya share disini adalah tidak semua kerja sama  itu baik, bahkan ada banyak situasi kerja sama itu justru buruk dan merupakan bencana bagi banyak orang.Salah satu hal yan paling saya ingat dari mantan gubernur DKI jakarta,Basuki Tjahaja  Purnama (Ahok), adalah ketidakmauannya untuk bekerjasama dengan anggota DPRD. Bahkan, beberapa rapat yang diselenggarakannya dengan DPRD berlangsung panas.Menurut Ahok, ia sengaja melakukan hal itu untuk membongkar banyaknya proyek siluman dalam APBD versi DPRD yang mengakibatkan penggelembungan anggaran lebih dari Rp 12 triliun.

Kesimpulannya: teamwork Ahok dengan DPRD sangat buruk.Intinya, kerjasama itu tidak selalu baik. Ada beberapa catatan yang penting yang saya sampaikan disini. Pertama, kerja sama itu sesungguhnya hanyalah merupakan nilai sekunder, bukan nilai primer. Kebenaran, kejujuran, dan keadilan adalah nilai primer. nilai itu harus ada diatas nilai apapun. Ketika sebuah nilai primer diabaikan, akan rusaklah sendi sendi kehidupan.

Kerjasama, betapapun baiknya, hanyalah sebuah nilai sekunder. Ia menjadi tidak penting, bahkan menjadi salah satu dan berbahaya, bila tidak didasari kebenaran,kejujuran, dan keadilan.Bukankah semua penjahat yang sukses memiliki teamwork yang baik? Bukankah penjarahan uang rakyat senantiasa dilakukan dengan kerjasama yang sangat baik dan sangat efektif?? Namun ketika kita tidak melakukan nilai primer, nilai sekunder hanya akan mendatangkam bencana bagi kita semua.

Kedua, kerjasama itu hanya akan baik bila ia mementingkan empat kepentingan sekaligus: Kepentingan Saya (My Win), Kepentingan Anda (Your Win), Kepentingan Orang Lain (Their Win), dan Kepentingan Tuhan (God’s Win).Inilah yang seharusnya menjadi landasan ketika kita ingin bekerjasama dengan orang lain.Banyak orang yang tidak memahami prinsip menang-menang dengan empat kepentingan ini. Ketika berniat bekerjasama dengan orang lain, kita hanya mementingkan kepentingan dua pihak:Saya dan Anda. Ketika kepentingan  dua pihak ini terakomodasi dengan baik, kita kemudian menyebutnya dengan istilah “win-win solution”.Padahal bila hanya dua pihak yang menang,ini sesungguhnya lebih tepat disebut  sebagai “win-win collution”.

 

 

 

 

 

 

ByVisions education

Mau kuliah di perguruan tinggi impian,tanpa pusing bayarnya,BISA!

Hello Sobat,Ada yang pernah dengar Dana Cita tidak?

Dana Cita hadir untuk menurunkan kendala keuangan berpendidikan tinggi di Indonesia. Kami memiliki misi untuk memperluas akses bagi semua pelajar dengan menjembatani kesenjangan dalam kesanggupan pembiayaan. Melalui platform kami, pelajar dapat memperoleh pinjaman terjangkau untuk menuntut ilmu di lembaga pendidikan tinggi dan program vokasi terpilih. Sesuai dengan nama kami (“Dana Cita”), kami hadir untuk mendanai aspirasi setiap pelajar, baik cita-cita yang besar maupun kecil.

Tim Dana Cita memiliki pengalaman kerja yang luas di Indonesia dan Asia Tenggara untuk lembaga-lembaga global termasuk bank investasi terkemuka, perusahaan manajemen konsultan, impact investor, dan lembaga pembangunan multilateral.

Apakah kamu punya wirausaha dan ingin menambah teman dan komunitas Mari join

Sebagai Campus Ambassador!

Campus Ambassador Dana Cita adalah peran yang penting untuk mewujudkan misi kami di kalangan mahasiswa. Mewakili Dana Cita di kampus adalah suatu kebanggaan yang mendorong Ambassador kami untuk berkontribusi terhadap komunitas Dana Cita

Cara mendapatkan pinjaman di Dana Cita

1.klik www.danacita.com

2.Lengkapi Biodata

3.Isi formulir yang dikirim ke email

4.Setelah lengkap isi kembali formulir dan sertakan kode ZLVN agar bebas biaya admin senilai

Rp 100 ribu

5.Tunggu konfirmasi dari Tim Dana Cita

6.Biaya spp/ukt segera kami bayarkan

 

Cheers,

 

ByVisions education

Implementasi Linear Regression

Simple Linear Regression Menggunakan Python

Nah dipostingan ini saya akan bahas tentang Simple Linear Regression. Simple Linear Regression merupakan salah satu  algoritma supervised, dengan kata lain algoritma ini belajar berdasarkan contoh pada data yang tersedia. Simple Linear Regression dapat memodelkan permasalahan hubungan linear antara sebuah input dan output.

xb + a = y 

x = input \\ y = output \\ b = gradient \\ a = konstanta

Inti dari Simple Linear Regression adalah menyelesaikan permasalahan garis lurus. Dalam pendekatan ini nilai a  dan b  akan didapatkan dari proses learning atau training.

Contoh Permasalahan Simple Linear Regression

Ok langsung saja kita mulai ke contoh kasus. Dalam kasus ini kita akan memodelkan permasalahan mengenai permasalahan asuransi mobil.

Deskripsi data:

  • x = Jumlah tuntutan
  • y = Total uang yang dibayarkan untuk seluruh tuntutan

Contoh:

  • x = 108 tuntutan
  • y = $392.5 untuk 108 tuntutan

DataRelation

 

Unduh Data

Proses Training Simple Linear Regression 

Untuk menyelesaikan permasalahan diatas, hal yang perlu kita lakukan adalah menghitung nilai a dan b, hal tersebut dapat diselesaikan dalam lima tahap dibawah ini:

  • Hitung nilai rata – rata x dan y\bar{x} = \frac{\sum\limits_{i=1}^{N} x_i}{N}
    \bar{y} = \frac{\sum\limits_{i=1}^{N} y_i}{N}
  • Hitung varince datavar(x) = \frac{\sum\limits_{i=1}^{N} (x_i - \bar{x})}{N-1}
  • Hitung covariance datacov(x, y) = \frac{\sum\limits_{i=1}^{N} (x_i - \bar{x})(y_i - \bar{y})}{N-1}
  • Hitung nilai b b = \frac{cov(x, y)}{var(x)}
  • Hitung nilai a a = \bar{y} - b \bar{x}

Implementasi Proses Training Menggunakan Python

Dalam implementasi ini saya menggunakan dua library pada Python pandas dan numpy. Pandas saya gunakan untuk mebaca file csv pada file Data/data.csv dan mengkonversinya menjadi DataFrame  dan numpy saya gunakan untuk melakukan perhitungan statistik data. Oh ia, untuk membaca file csv pada pyhton banyak alternatif lainnya seperti menggunakan module csv pada phyton.

#import library pandas dan inisialisasikan menjadi pd
import pandas as pd
#import library numpy dan inisialisasikan menjadi np
import numpy as np

#baca data pada file data.csv dalam folder Data menggunakan pandas
data = pd.read_csv('Data/data.csv')

#assign nilai X (Jumlah Klaim) pada variable x
x = data.X.values

#assign nilai Y (Total Pembayaran) pada variable y
y = data.Y.values

#Bagi data menjadi 2 bagian untuk train dan untuk test

#ambil nilai x dari urutan pertama hingga 10 terakhir (108 - 13)
x_train = x[:-10]
#ambil nilai y dari urutan pertama hingga 10 terakhir (392.5 - 31.9)
y_train = y[:-10]


#ambil 10 data terakhir dari x
x_test = x[-10:]
#ambil 10 data terakhir dari y
y_test = y[-10:]

#hitung nilai rata-rata x dan y
x_mean = np.mean(x_train)
y_mean = np.mean(y_train)


#hitung variance x
x_var = np.var(x_train, ddof=1)

#hitung covariance data
cov = np.cov(np.vstack((x_train, y_train)), ddof=1)[0][1]

#hitung nilai b
b = cov / x_var
#hitung nilai a
a = y_mean - (b * x_mean)

Proses Testing Simple Linear Regression

Jika pada proses training kita melakukan perhitungan untuk mencari nilai a  dan b  pada model. Pada proses testing hal yang akan kita lakukan adalah melakukan prediksi dengan menghitung nilai y

y  = xb + a

Implementasi Proses Testing Menggunakan Pyhton

Dalam implementasi ini kita akan menggunkan nilai 10 terakhir dari nilai x yaitu x_test

#y = xb + a
predict = x_test * b + a

Hasil prediksi

x_test predict
15 64.93399
8 41.55334
29 111.6953
30 115.0354
24 94.99484
9 44.89343
31 118.3755
14 61.5939
53 191.8576
26 101.675

Evaluasi Model

Setelah melakukan proses training dan testing, hal terakhir yang harus kita lakukan adalah mengevaluasi model. Apakah model kita sudah sesuai dengan data yang ada? Dalam proses evaluasi ini saya akan menggunakan formula Root Mean Square Error atau disingkat RMSE

RMSE = \sqrt {\frac{\sum\limits_{i=1}^{N} (\hat{y}_i - y_i)^2}{N}}

Dimana \hat{y}  adalah nilai prediksi model dan y  adalah nilai yang seharusnya. Dengan menggunakan RMSE kita dapat mengetahui nilai rata-rata kesalahan pada model dalam meprediksi nilai total pembayaran untuk sejumlah klaim.

x_test predict y_test (predict – y_test)^2
15 64.93399 32.1 1078.07107
8 41.55334 55.6 197.308783
29 111.6953 133.3 466.76277
30 115.0354 194.5 6314.622553
24 94.99484 137.9 1840.852976
9 44.89343 87.4 1806.808545
31 118.3755 209.8 8358.440208
14 61.5939 95.5 1149.623703
53 191.8576 244.6 2781.765019
26 101.675 187.5 7365.926308
RMSE = 56.00016244

Implementasi RMSE pada Pyhton

#menghitung RMSE model
RMSE = np.sqrt(np.mean(pow(predict - y_test, 2)))

Penjelasan:

  • pow(a) = a ^ 2
  • np.mean(a) = hitung nilai rata-rata dai vector a
  • np.sqrt(a) = \sqrt{a}

Plot Model

Ok pada bagian ini, saya akan memplot data bersama dengan model menggunakan library matplotlib pada python.

#import library pyplot dari matplotlib dan inisialisasi sebagai plt
from matplotlib import pyplot as plt

#predict seluruh nilai y untuk seluruh nilai x
predict_all = (x * b) + a

#plot data y berdasarkan x dengan bentuk circle 
plt.plot(x, y, 'ro')

#plot data predict_all berdasarkan x 
plt.plot(x, predict_all)

#definiskan label untuk garis x
plt.xlabel('Jumlah Tuntutan')
#definisikan label untuk garis y
plt.ylabel('Total Pembayaran')
#tampilkan graph
plt.show()

Output:

DataFitting

Implementasi Linear Regression Menggunakan Sklearn

Pada Simple Linear Regression pada phyton, kita dapat menggunakan Sklearn. Dengan menggunakan Sklearn kita tidak perlu melakukan coding dari awal, memang lebih praktis tapi perlu diingat bahwa kita perlu memahami tentang cara kerja dari algoritma. Sehingga saya anjurkan untuk melakukan coding dari 0 sebagai berikut:

import pandas as pd
from matplotlib import pyplot as plt
from sklearn import linear_model
import numpy as np

#baca data pada file data.csv dalam folder Data menggunakan pandas
data = pd.read_csv('Data/data.csv')
#reshape data x dan y dari bentuk (1 row 63 columns ke 63 rows 1 columns)
x = data.X.values.reshape(63, 1)
y = data.Y.values.reshape(63, 1)

#ambil nilai x dari urutan pertama hingga 10 terakhir (108 - 13)
x_train = x[:-10]
#ambil nilai y dari urutan pertama hingga 10 terakhir (392.5 - 31.9)
y_train = y[:-10]


#ambil 10 data terakhir dari x
x_test = x[-10:]
#ambil 10 data terakhir dari y
y_test = y[-10:]

smpReg = linear_model.LinearRegression()


#train model
smpReg.fit(x_train, y_train)

#test model
predict = smpReg.predict(x_test)

#menghitung RMSE model
RMSE = np.sqrt(np.mean(pow(predict - y_test, 2)))

#plot data dan model
figure = plt.figure(1)
plt.plot(x_train, y_train, 'ro')
plt.plot(x, smpReg.predict(x))
plt.xlabel('Jumlah Tuntutan')
plt.ylabel('Total Pembayaran')
plt.show()

 

Untuk download code

Disarikan dari https://prasetiautamacv.wordpress.com/2016/07/03/simple-linear-regression-menggunakan-phyton/

ByVisions education

Kernel Trick Via Python

 

Apakah Kernel itu?

Kernel? pada postingan ini saya akan menshare tentang kernel. Kernel yang saya maksud bukanlah kernel pada linux, akan tetapi pada konteks Machine Learning. Ide dasar pada penggunaan kernel pada machine learning adalah jika point negatif dan positif pada dimensi \mathbb{R}^N tidak dapat dipisahkan, maka transform fitur tersebut ke \mathbb{R}^M  (M > N ) dimana point negatif dan positif dapat dipisahkan. Inti dari kernel trick adalah mentransformasi low-dimensional fitur ke higher-dimensional fitur.

Secara matematik, kernal adalah inner produk dari beberapa fitur map.

K(x,y) = <\phi(x), \phi(y)>

Contoh:

Jika kita ingin memprediksi harga smart phone berdasarkan variable:

x_1 = merek
x_2 = model

x = [x_1, x_2]

Dengan linear model kita dapat menuliskan permasalahan diatas menjadi

harga = \beta_0 + \beta_1  x_1 + \beta_2  x_2

Namun kita juga dapat memodelkan permasalahan diatas dalam model non linear, contoh: polynominal model

harga = \beta_0 + \beta_1 {x_1}^4 + \beta_2  {x_2}^4 + \beta_3  4(x_1 x_2)

harga = \beta (x^Tx)^T(x^Tx)

harga = \beta<\phi(x), \phi(x)>

Dimana \phi(x) = (x^Tx)

<\phi(x), \phi(x)>  adalah kernel, inner produk dari \phi(x), yang mentransform fitur x dari \mathbb{R}^2  ke \mathbb{R}^3 .

Keuntungan dan Kelemahan Kernel Trick

  • Keuntungan
    • Pemilihan kernel yang tepat akan meningkatkan performa machine learning
    • Transformasi low-dimensional fitur ke high-dimensional fitur memungkinkan untuk menyelesaikan permasalahan dengan berbagai model
  • Kelemahan
    • Semakin besar dimensi suatu fitur maka semakin tinggi resource yang diperlukan dalam komputasi
    • Tidak terdapatnya ketentuan yang baku untuk menentukan jenis kernel dan nilai parameter kernel, sehingga untuk mendapatkan performa yang diharapkan trial dan error perlu dilakukan beberapa kali.

Bagaimana Membuat Sebuah Kernel?

Seperti saya jelaskan sebelumnya bahwa kernel adalah inner product dari dua atau lebih fitur map. Untuk membuat sebuah kernel terdapat beberapa langkah

  1. Definisikan fitur map yang akan memetakan fitur X  ke R^x.
  2. Definisikan inner product antara fitur map <,>
  3. Pastikan bahwa inner product antara fitur map adalah fungsi simetri positif semi-definite.

Contoh:

Untuk fitur \bold{x} = [x_1, x_2] =  dan \bold{z} = [z_1, z_2] , definisikan dua fitur map \phi(\bold{x})  dan \phi(\bold{z}) . Dimana

\phi([x_1, x_2]) = ({x_1}^2, \sqrt{2}{x_1}x_2, {x_2}^2)
\phi([z1, z2]) = ({z_1}^2, \sqrt{2}{z_1}{z_2}, {z_2}^2)

Inner product dari \phi(\bold{x})  dan \phi(\bold{z})  adalah k(\bold{x},\bold{z}) = <\phi(\bold{x}), \phi(\bold{z})>

k(\bold{x},\bold{z}) = {x_1}^2{z_1}^2 + 2{x_1}{x_2}{z_1}{z_2}+{x_2}^2{z_2}^2 = <\bold{x}, \bold{z}>^2

Pastikan bahwa k(.) adalah fungsi simetri semi-definit. Jika suatu fungsi simetri positif semi-definit, maka fungsi tersebut akan memenuhi beberapa ketentuan berikut:

  1. k(.) adalah fungsi simetri jika k(\bold{x}, \bold{z}) = k (\bold{z}, \bold{x})
  2. Matrix yang dihasilkan oleh fungsi k(x, x)  memiliki eigenvalue \geq{0}

Demonstrasi Menggunakan Python

Dalam demonstrasi ini saya akan mendemostrasikan kernel menggunakan phyton. Untuk variabel x dan z \in{R}^{3x2}

1
2
x = np.array([[1, 2], [2, 3], [4, 5]])
z = np.array([[8, 2], [9, 3], [10, 5]])

Definisikan fitur map \phi(\bold{x}) = ({x_1}^2, \sqrt{2}{x_1}x_2, {x_2}^2)

1
2
3
4
5
def phi(x):
 x1 = np.power(x[0], 2)
 x2 = pow(2, 1/2) * x[0] * x[1]
 x3 = np.power(x[1], 2)
 return np.array([x1, x2, x3])

Seperti saya jelaskan sebelumnya, bahwa kernel adalah inner product dari beberapa fitur map, maka kernel k(\bold{x}, \bold{z})  

1
kXZ = np.inner(phi(x), phi(z))

Sampai tahap ini kita telah memiliki kernel fungsi yang merupakan inner product dari \phi(\bold{x}) dan \phi(\bold{z}) . Setelah ini kita harus memastikan bahwa kernel fungsi k(.) adalah fungsi simetri semi-definit.

k(.) adalah fungsi simetri

1
2
3
4
In[1]: print(k(z[0, :], x[0, :]))
Out[1]: 144
In[2]: print(k(x[0, :], z[0, :]))
Out[2]: 144

Matrix yang dihasilkan oleh fungsi k(x, x)  memiliki eigenvalue \geq{0}

1
2
3
4
5
6
7
8
#definisikan variable K dengan nilai matrix 3x3 bernilai 0
K = np.zeros((3,3))
#lakukan pengulangan dari 0 sampai 2
for i in range(3):
#lakukan pengulangan dari 0 sampai 2
 for h in range(3):
#hitung nilai matrix K (i,h), untuk setiap K(i,h) = k(x_i, x_h)
  K[i, h] = k(x[i, :], x[h, :])

Ok pada potongan kode diatas kita telah berhasil membuat matrix K, dimana K(i, h) = k(x_i, x_h). Langkah selanjutnya memastikan bahwa eigenvalue matrix K \geq{0} . Untuk hal ini kita dapat menggunakan fungsi pada numpy np.linalg.eig

1
w, v = np.linalg.eig(K)

Fungsi np.linalg.eig akan menghasilkan duat output, 1: eigenvalues dan 2: eigen vectors.

1
2
In[3]: w
Out[3]: 1870.731, 0.009, 4.260

Dari perhitungan eigenvalue diatas, bisa kita lihat bahwa seluruh eigenvalue matrix K  \geq{0}  atau positif.

Apakah Kernel hanya dapat digunakan untuk Support Vector Machine?

Istilah kernel sering dikaitkan dengan algoritma Support Vector Machine (SVM). Namun dalam pengaplikasiaannya, kernel juga dapat diadaptasi terhadap algoritma lainnya seperti Extreme Learning Machine (ELM) dan Regularized Ada-Boost. Untuk info lebih lanjut tentang kernel-trick dapat mengunjungi situs http://www.kernel-machines.org

Referensi

  1. https://ocw.mit.edu/courses/sloan-school-of-management/15-097-prediction-machine-learning-and-statistics-spring-2012/lecture-notes/MIT15_097S12_lec13.pdf
  2. https://www.youtube.com/watch?v=3liCbRZPrZA

 

 

Disarikan dari https://prasetiautamacv.wordpress.com/2017/03/26/kernel-trick/

ByVisions education

Virus Deep Neural Network Dari Theano Menggunakan Anaconda

Belakangan ini kita sering menjumpai istilah ‘Deep Learning’ atau ‘Deep Neural Network’. Sebenarnya Deep Neural Network adalah istilah untuk sebuah jaringan saraf tiruan (Artificial Neural Network-ANN) dengan jumlah hidden layer lebih dari dua. Istilah ini sebenarnya merupakan re-branding dari jaringan saraf tiruan sendiri. Kenapa saya mengatakan ‘re-branding’, karena sebenarnya ANN dengan hidden layer lebih dari dua sudah ada sebelum istilah Deep Neural Network muncul, namun pada saat itu sangatlah sulit untuk men-train sebuah ANN dengan hidden layer lebih dari dua dikarenakan masalah vanishing dan exploiding gradient, serta spesifikasi komputer yang tidak memadai.

Seiring dengan munculnya istilah DeepNN, beberapa framework yang diperuntukan untuk membuat aplikasi ataupun prototype DeepNN mulai bermunculan seperti

Pada post kali ini saya akan share mengenai cara instalasi Theano dan Keras.

Theano

Theano merupakan sebuah Python library yang diperuntukan untuk memodelkan sebuah permasalahan matematika. Theano akan mentransform code yang kita tuliskan kedalam bentuk optimized C sehingga pada kasus tertentu performa Theano dapat lebih cepat dibandingkan ‘hand-crafted C’ implementasi . Selain itu, Theano juga dapat dijalankan menggunakan GPU, yang tentunya lebih cepat dibanding CPU dalam proses komputasi dan training ANN dengan jumlah data yang banyak.

Pada postingan ini saya akan menginstall Theano menggunakan anaconda, untuk installasi anaconda dan python bisa lihat postingan ini. Setelah berhasil menginstall anaconda dan phyton, kita bisa langsung menginstall theano dengan mengetikan perintah

1
conda install theano pygpu

Pada command prompt atau conda command prompt, jika proses installasi diatas telah selesai. Ada dapat menguji apakah installasi telah sukses atau tidak dengan menjalankan script python

1
2
import theano
theano.test

Jika tidak terdapat error maka proses intallasi Theano telah sukses, namun jika terdapat error, anda dapat mengetikan perintah

1
conda install mingw libpython

pada command prompt untuk menginstall mingw yang diperlukan untuk meng-compile Theano.

Keras

Ok, setelah kita berhasil menginstall Theano, kini saatnya meng-install Keras. Keras merupakan high-level API yang diperuntukan untuk memodelkan Neural Network dan dapat berjalan diatas Theano ataupun TensorFlow. Sama seperti Theano, Keras berbasis Python. Berbeda dengan Theano, pada Keras untuk membuat sebuah model Deep-NN kita tidak perlu memulai dari 0, karena Keras sudah menyediakan beberapa model ANN seperti CNN, RNN, dan FeedForward.

Jika pada tahan produksi atau jika anda ingin men-train sebuah Deep-NN model dengan jumlah data yang banyak, saya anjurkan untuk menggunakan Keras, dikarenakan model pada Keras telah dioptimisasi, sehingga dapat berjalan lebih cepat dibanding jika kita melakukan hand-crafted implementasi menggunakan Theano atau TensorFlow. Tapi jika anda ingin ‘bermain – main’, dengan model anda sendiri dan ingin belajar mengenai Deep-NN saya anjurkan untuk menggunakan Theano.

Install Keras

Untuk menginstall Keras, caranya cukup mudah, anda cukup mengetikan perintah

1
conda install -c conda-forge keras=2.0.2

pada command prompt. Setelah anda menginstall Keras, anda dapat mencoba menjalankan script

1
2
from keras.models import Sequential
model = Sequential()

Pada tahap ini anda akan mendapatkan error, hal ini dikarenakan pengaturan awal Keras adalah untuk bejalan diatas TensorFlow. Untuk menjalankan Keras diatas Thenao, caranya cukup mudah.

  1. Temukan file keras.json pada direktori C:/Users/nama_user_anda/.keras
  2. Ubah “backend”: “tensorflow” menjadi “backend”: “theano”

Ok sampai pada tahap ini kalian telah berhasil untuk menginstall Keras dan Theano, selama bermain-main dengan Deep-NN

Disarikan dari https://prasetiautamacv.wordpress.com/2017/04/09/install-keras-dengan-theano/

ByVisions education

Perceptron Menggunakan Theano

Apakah itu Perceptron?

Perceptron ditemukan oleh Rosenblatt pada tahun 1958 [1]. Perceptron merupakan Artificial Neural Network (ANN) tanpa hidden layer, dimana input layer terhubung langsung dengan output layer. Perceptron merupakan salah satu algoritma linear, sehingga memiliki performa yang tidak cukup baik dalam menyelesaikan permasalah non-linear.

Secara umum perceptron model serupa dengan linear regresi model. Regresi dapat dimodelkan dengan formula:

y = xb + a

dimana,

x = input \\ y = output \\ b = gradient \\ a = konstanta

Sedangkan perceptron dapat dimodelkan dengan formula

y = \sum_{n} w_i x_i = W^T x
\frac{\partial y}{\partial w_i} = x_i

dimana,

x = input\\ y = output \\ W = weights \\ \sigma(.) = output \ function

Perceptron
Perceptron Model

Dikarenakan model perceptron yang sederhana, saya menyarankan agar mempelajari perceptron terlebih dahulu sebelum mepelajari Multiple Layer Perceptron (MLP) atau ANN dengan hiden layer >= 1.

Pada postingan kali ini saya akan membahas mengenai perceptron dan bagaimana cara mentrain perceptron menggunakan back propagation. Di postingan ini, saya akan menggunakan Theano dalam mengimplementasi perceptron.

 

Training Perceptron Menggunakan BackPropagation

Tujuan utama dalam proses training adalah meminimalisir error atau perbedaan antara output yang diharapkan (desired output) dan output sebenarnya yang dihasilkan oleh perceptron (actual output). Dalam hal ini kita dapat menggunakan algoritma seperti backpropagation. Cara kerja algoritma backpropagation sendiri adalah dengan mengubah nilai weights pada sebuah perceptron secara iterative berdasarkan nilai error hingga nilai error mencapai batas tertentu. Secara umum terdapat tiga tahapan pada BackPropagation.

  1. Forward Propagation: Pada tahap ini input akan diberikan kepada perceptron, dap perceptron akan menghasilkan output berdasarkan input tersebut.
  2. Error Calculation: Perbedaan antara actual output dan desired output dikalkulasi menggunakan sebuah fungsi error (contoh: root mean square atau croos entropy)
  3. Backpropagation: Merubah nilai weight pada perceptron berdasarkan nilai error pada tahan ke dua.

Ok pada bagian ini saya akan menjabarkan secara singkat tentang ketiga tahapan diatas.

Forward Propagation

Tahap forward propagation adalah proses dimana perhitungan output perceptro berdsarkan input yang diberikan. Hal ini dapat diselesaikan dengan formula dibawah:

Untuk x = input, y = output, W = weights, \sigma(.) = output \ function .

z = \sum_{n} w_i x_i = W^T x
y = \sigma (z)

dimana

y = \sigma(z) = \dfrac{1} {1 + e ^ {-z}}

  \frac{\partial y}{\partial z} = -1(1 + e ^ {-z}) ^ {-2}  =  \dfrac{1}{1 + e ^ {-z}} \dfrac{e^{-z}}{1 + e^{-z}} = y(1 - y)

Pada tutorial ini saya menggunakan fungsi Sigmoid sebagai fungsi keluaran perceptron dikarenakan nilai output yang saya harapkan adalah 0 atau 1.

Sigmoid
Fungsi Sigmoid dengan nilai input -20 ~ 20

Note:

  • BP tidak dapat digunakan pada perceptron dengan binary threshold sebagai fungsi output, dikarenakan turunan binary threshold terhadap nilai z = 0 (\frac{\partial y}{\partial z} = 0  )

y =\begin{cases}1, &  z \geq {threshold}\\0, & \text{otherwise} \\ \end{cases} 

Error Calculation

Setelah mendapatakan output dari perceptron berdasarkan input yang diberikan, pada tahap error calculation perceptron akan dievaluasi “apakah output perceptron sesuai dengan output yang diharapkan atau tidak”. Untuk menghitung perbedaan antara actual output dan desired output dapat digunakan berbagai macam fungsi error seperti Squared Error, Root Mean Squared Error (RMSE), Cross Entropy, atau Cosine Proximity. Dalam tutorial ini saya akan menggunakan Squared Error(untuk memudahkan proses perhitungan BP)

Untuk

t = actual \ output, t \in {0 ~ 1} \\ y = desired \ output , y \in {0 \ atau \ 1}, dan \\ N = jumlah \ data

Squared error dari t dan y dapat dihitung menggunakan formula

E = \dfrac{1}{2} \sum\limits_{i=1}^N (t_i - y_i)^2

dimana

\frac{\partial E}{\partial y} = \dfrac{2}{2} \Sigma (t_i - y_i)^2 * -1 = - \Sigma (t_i - y_i)

Note:

  • Error fungsi juga dikenal dengan nama cost function dan objective function.

 

Back Propagation

Secara umum proses learning pada neural network adalah dengan mengubah nilai weights berdasarkan error yang dibuat network tersebut dalam memprediksi data yang diberikan. Proses learning pada network dapat diformulasikan dengan formula

w_{new} = w_{old} - \Delta w

dimana,

\Delta w = \pm x

Kondisi:

  • Jika output benar, maka \Delta w = 0
  • Jika output salah (t =0 tetapi y = 1), maka \Delta w = -x
  • Jika output salah (t =1 tetapi y = 0), maka \Delta w = +x

Pada backpropagation proses learning tidak berdasarkan desired output, namun berdasarkan turunan fungsi error \frac{\partial E}{\partial z}.

\frac{\partial E}{\partial z_i} = \frac{\partial y_i}{\partial z_i} \frac{\partial E}{\partial y_i}

\frac{\partial E}{\partial z_i} = -y_i(1-y_i) (t_i - y_i)

\frac{\partial E}{\partial w_i} = \frac{\partial z_i}{\partial w_i} \frac{\partial E}{\partial z_i}

\frac{\partial E}{\partial w_i} = x_i\frac{\partial E}{\partial z_i}

Sehingga,

\Delta w = \varepsilon  \frac{\partial E}{\partial w_i}

\varepsilon = learning \ rate

Note:

  • Learning rate menentukan seberapa besar nilai weights akan berubah. Semakin kecil nilai learning rate, maka proses training akan semakin lama tapi perceptron akan dapat memahami lebih baik. Analogi (learning rate = tinggi = sistem kebut semalam, learning rate = kecil = belajar bertahap)

Implementasi menggunakan Theano

Pada tutorial ini saya akan menggunakan perceptron untuk menyelesaikan permasalahan gerbang logikal AND.

INPUT OUTPUT
A B A AND B
0 0 0
0 1 0
1 0 0
1 1 1

Memodelkan perceptron dengan Theano

Langkah pertama dalam mengimplementasikan perceptron menggunakan Theano adalah mendefinisikan variable tensor.

1
2
3
4
#input
X = T.dmatrix('x')
#desired output
t = T.ivector('t')

Untuk variable weights dan bias, tidak hanya didefinisikan namun kita juga harus menginisialisasi nilai awal variable tersebut. Untuk weights saya menggunakan nilai random dengan limit [-4 \sqrt{\frac{6}{nInput + nOutput}}, 4 \sqrt{\frac{6}{nInput + nOutput}}]  (ref: 2), dimana nInput = jumlah neuron pada layer input (nOutput = 2) dan nOutput = jumlah neuron pada layer output (nOutput = 1). Sedangkan nilai bias diinisialisasi dengan nilai 0

1
2
3
4
5
bound = 4 * (6./np.sqrt(nInput + nOutput))
#weights
W = theano.shared(value=rng.uniform(low=-bound, high=bound, size=(nInput, nOutput)))
#bias
b = theano.shared(value= np.zeros(nOutput))

Pada tutorial ini saya menggunakan sigmoid sebagai activation function pada output layer. Pada theano terdapat build-sigmoid function sehingga kita tidak perlu membuat dari scratch.

1
2
#T.dot(a,b) = dot product dari variable a dan b
y = T.nnet.sigmoid(T.dot(X, W) + b)

Implementasi Squared Error

Setelah berhasil memodelkan perceptron, langkah selanjutnya adalah dengan membuat fungsi untuk menghitung error. Saya menggunakan squared error untuk menhitung perbedaan actual output dan desired output.

1
2
def SE(t, y):
 return T.sum(T.power(t - y.T, 2))/2

Implementasi BackPropagation

Seperti dijelaskan sebelumnya, bahwa untuk mentrain perceptron menggunakan BackPropagation, nilai weights dan bias akan diubah berdasarkan derivative error function (cost function) terhadap variable yang bersangkutan. \frac{\partial E}{\partial w} adalah derivative error terhadap weights, dan \frac{\partial E}{\partial b} adalah derivative error terhadap bias.

Pada Thenao, untuk menghitung derivative terhadap sebuah variable, kita dapat menggunakan fungsi T.grad().

1
2
3
4
5
cost = SE(t, y)
#gradient cost function terhadap variable W
gW = T.grad(cost, W)
#gradient cost function terhadap variable b
gB = T.grad(cost, b)

Setela menghitung nilai \frac{\partial E}{\partial w} dan \frac{\partial E}{\partial b} kita dapat mengupdate nilai W dan b dengan formula

w_{new} = w_{old} - \Delta w

b_{new} = b_{old} - \Delta b

Implementasi formula diatas pada theano dapat dilakukan dengan mengexpresikan formula diatas pada sebuah variable

1
updates = [(W, W - learningRate * gW), (b, b - learningRate * gB)]

(W, W – learningRate * gW) memiliki arti w_{new} = w_{old} - \Delta w .

Wrap Everything

Langkah terakhir dalam mengimplementasikan perceptron pada Theano adalah dengan menyatukan model diatas pada sebuah fungsi. Pada tahap ini, kita akan mendefinisikan sebuah fungsi  Theano yang akan menyatukan ekspresi – ekspresi diatas.

1
2
trainModel = theano.function(inputs=[X, t], outputs=cost, updates=updates)
testModel = theano.function(inputs=[X], outputs=pred)

trainModel adalah fungsi yang akan digunakan untuk mentrain perceptron, dimana input fungsi tersebut adalah X dan t (desired output), sedangkan outputnya adalah cost atau error function. Pada fungsi ini dijelaskan juga tentang variable yang akan diupdate setiap fungsi ini dijalankan.

testModel  adalah fungsi yang akan digunakan untuk mentest perceptron, dimana input funsi tersebut adalah X dan outputnya adalah nilai prediksi terhadap input yang diberikan.

Train Perceptron

Untuk mentrain perceptron, kita hanya perlu memanggil fungsi trainModel, jika ingin mentrain perceptron sebanyak 100 iterasi kita hanya perlu memanggil fungsi tersebut sebanyak 100 kali. Hal tersebut dapat diimplementasikan dengan mudah menggunakan loop.

1
2
for i in range(100):
 err = trainModel(inputX, desiredOutput)

Atau jika ingin mentrain model hingga error function dibawah batas tertentu kita dapat menggunakan while.

1
2
3
err = 1
while err > 0.5
 err = trainModel(inputX, desiredOutput)
Error Function
Hasil training (nilai error function) perceptron dengan iterasi = 1000 dan learning rate = 0.9

Note:

  • Penggunakan error fungsi tergantung dengan permasalahan yang ingin dimodelkan dengan ANN, apakah itu regresi, binary-classification, atau multiclasses-classification

Full Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import theano
import theano.tensor as T
import numpy as np
def SE(t, y):
return T.sum(T.power(t - y.T, 2))/2
inputX = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
desiredOutput = np.array([0, 0, 0, 1])
rng = np.random.RandomState(5145022)
nInput = 2
nOutput = 1
iterationStep = 1000
learningRate = 0.1
X = T.dmatrix('x')
t = T.ivector('t')
bound = 4 * (6./np.sqrt(nInput + nOutput))
W = theano.shared(value=rng.uniform(low=-bound, high=bound, size=(nInput, nOutput)))
b = theano.shared(value= np.zeros(nOutput))
y = T.nnet.sigmoid(T.dot(X, W) + b)
pred = y > 0.5
cost = SE(t, y)
gW = T.grad(cost, W)
gB = T.grad(cost, b)
updates = [(W, W - learningRate * gW), (b, b - learningRate * gB)]
trainModel = theano.function(inputs=[X, t], outputs=cost, updates=updates)
testModel = theano.function(inputs=[X], outputs=pred)
err = 1
errList = np.zeros(iterationStep)
for i in range(iterationStep):
err = trainModel(inputX, desiredOutput)
errList[i] = err
print(testModel(inputX))

 

Referensi

  1. Rosenblatt, Frank. “The perceptron: A probabilistic model for information storage and organization in the brain.” Psychological review 65.6 (1958): 386.
  2. Glorot, Xavier, and Yoshua Bengio. “Understanding the difficulty of training deep feedforward neural networks.” Aistats. Vol. 9. 2010.
ByVisions education

Modal IP dua koma bisa tembus dan raih beasiswa untuk S3 di Oxford

Bisa kuliah di kampus rangking nomor 1 di dunia mungkin adalah impian semua orang.Karena untuk meraihnya berbeda-beda setiap orang,tidak ada proses yang instan dan semua orang memiliki proses yang berbeda-beda.Ada yang bisa langsung bisa meraihnya, ada yang harus berliku-liku.Sekedar sharing contohnya adalah kak Mukhlis Jamal Holle adalah awardee LPDP  yang lolos mengambil studi DPhil di University of Oxford, kampus nomor satu di dunia.Meskipun, di sekolah hanya beberapa guru mengenal beliau karena  sering bolak-balik ke ruang guru untuk mengambil remedial.Bahkan,ketiika di jenjang SMA, jika hanya ada satu siswa yang nilainya dibawah SKM, sering sekali satu siswa itu adalah beliau. Sempat juga dianggap tidak mampu untuk masuk jurusan favorit dan beliau memilih Biologi, jurusan yang bagi kebanyakan org adalah jurusan nomer 2, tapi nomer 1 buat beliau. Di ujian nasionalpun mungkin beliau tidak lulus jika ada yang salah dua nomor lagi di salah satu mata pelajaran.Beruntung akhirnya beliau bisa lolos UM-UGM.

 

Saat kuliah S1, beliau sempat sempat mendambakan kuliah diluar negeri. Namun pada saat itu,karena keterbatasan pengalaman dan keterbatasan kemampuan bahasa, kak Muhkhlis belum berani untuk mencoba mendaftar di kampus top Dunia.Beruntung beliau  diterima studi lanjut S2 di salah satu kampus terbaik di Jepang.Sembari menjalani studi S2, kak Mukhlis terus mengasah kemampuan bahasa inggris dengan membiasakan mendengar video-video belajar bahasa inggris di Youtube.Hingga sampai di penghujung perkuliahan S2,kak Mukhlis belum mengetahui akan mendapat pekerjaan yang inginkan atau melanjutkan studi S3 selepas S2, beliau mencoba segala kemungkinan yang ada. Beruntung selama studi S2 aku mendapat kesempatan untuk menghadiri konferensi yang dihadiri banyak akademisi di kampus-kampus terbaik dunia sehingga hal ini benar-benar membuka pandanganku terhadap penelitian ekologi terupdate saat ini.

Setelah beliau belajar bahasa inggris selama lebih dari 5 tahun, dan mengorbankan banyak hal untuk bisa melakukan penelitian dan mengikuti konferensi ilmiah, akhirnya beliau punya nyali untuk mendaftar ke University of Oxford.Beliau semakin optimis bahwa Indonesia adalah bangsa yang besar dan punya potensi yang sangat kuat.And after all, ini bukanlah tujuan akhir, melainkan hanya salah satu proses untuk mencapai tujuan itu. Dan proses menuju tujuan itu masi sangatlah panjang. Semoga bisa dimudahkan.

Namun, semoga ini bisa sedikit banyak memberikan gambaran bagi rekan-rekan yang ingin studi lanjut. Bukan karena beliau lebih baik, namun karena mungkin lahir lebih dulu dan mendapat kesempatan ini lebih dulu:

1.Tidak ada proses yang instan dan semua orang memiliki proses yang berbeda-beda. Ada yang bisa langsung bisa meraihnya, ada yang harus berliku-liku dahulu. Buatku, butuh proses bertahun-tahun untuk akhirnya bisa lolos.
2. Rejeki tidak akan tertukar dan sudah diatur oleh YMK.
3.Tutupi satu kekurangan dengan kelebihan yang lain karena pada prinsipnya setiap orang itu unik dan memiliki kelebihan yang tidak dimiliki orang lain.
4.Jangan takut gagal, apalagi takut gagal sebelum mencoba.
5. yang mencoba saja bisa gagal, apalagi yang tidak mencoba
6.Gagal itu biasa, yang terpenting adalah berani untuk bangkit dari kegagalan dan terus mengevaluasi diri.
7.Mengunderestimate diri sendiri untuk kemudian berusaha keras untuk mengembangkan diri itu boleh, yang tidak boleh adalah self-underestimate lalu tidak berani mencoba.

 

Disarikan dari https://mukhlishholle.wordpress.com/2017/04/29/oxford-bukan-lagi-mimpi-its-real/

ByVisions education

Tahap Awal Mengenal Machine Learning

Bukan penggemar Harry Potter kalau Anda belum menguasai bahasa Python. Apa yang anda pikirkan ketika mendengar kata Python? Ya, Sanca kembang atau sanca batik adalah sejenis ular yang berbisa dan bahkan bisa menelan manusia. Di film Harry Potter, teringat yang hanya menguasai bahasa ular hanya Harry sendiri diantara teman-teman lainnya.

Baru-baru ini di dunia Ilmu Komputer selintas lalu ada kata Machine Learning yang kemungkinan sudah familiar bagi mahasiswa Ilmu Komputer atau Teknik Informatika, atau bahkan siswa SMA.Machine Learning adalah bidang Ilmu Komputer yang membuat sebuah komputer dapat belajar berdasarkan data yang diberikan.Jika Anda tertarik dengan dunia yang satu ini untuk mempelajari Machine Learning ada dua pendekatan, dimulai dari mempelajari teori atau langsung ke praktiknya. Maka, untuk belajar Machine Learning, ada beberapa bahasa pemograman yang populer dikalangan Scientific Programmer.

  1.  (https://www.r-project.org/)
  2. Matlab (http://www.mathworks.com/)
  3. Python (https://www.python.org/)
  4. Julia  (http://julialang.org/)

Diantara bahasa pemrograman diatas saya memilih Python karena komunitas Phyton yang sudah stable dan terdapat banyak scientific librarynya.

Langkah Pertama:

Instalasi python di Windows sangat gampang. Langkah-langkanya sama seperti menginstal software Windows pada umumnya, next-next-finish.Tapi ada konfigurasi yang harus dipilih ditengah-tengah proses instalasi, agar perintah Python dapat dikenali di CMD.Python yang akan di instal dalam panduan ini adalah python versi 3. Download di situs resmi python (python.org).

Langkah kedua

Install PyCharm di https://www.jetbrains.com/pycharm/download/ pilih yang community ya untuk kebutuhan scientific, soalnya kalau yang professional itu berbayar

Kemudian setelah donwload Pycharm, diinstall yaa

 

Contoh pemrograman class di Python

Setelah di run

Selesai!

Silahkan coba,kalau mau jadi lebih Expert atau Tingkat Dewa silahkan bergabung secara remote di homepage kami pythonthusiast.com !

 

Cheers,

 

Sari Dewi

ByVisions education

Konsep Multi Layer Perceptron Menggunakan Tensorflow pada Kasus Diagnosis Kanker Payudara

Multi Layer Perceptron Menggunakan Tensorflow pada Kasus Diagnosis Kanker Payudara

Multi Layer Perceptron

ilustrasi
Apa itu Multi Layer perceptron?

Multi-layer perceptron adalah perceptron dengan satu atau lebih hidden layer, dimana input sebuah perceptron adalah output dari perceptron sebelumnya. Tidak seperti perceptron yang hanya dapat memodelkan permasalahan linear, multi-layer perceptron juga dapat menyelesaikan permasalahan non-linear.

Walapun secara teori sebuah MLP adalah sebuah neural network model dengan satu atau lebih hidden layer, pada implementasinya sangatlah jarang ditemukan multi-layer perceptron dengan hidden layer lebih dari tiga (sebelum konsep Deep NN ditemukan). Hal tersebut dikarenakan kesulitan dalam proses latihan multilayer perceptron dengan lebih dari tiga hidden layer. Permasalahan yang biasa dialami oleh multi-layer perceptron yang memiliki lebih dari tiga hidden layer adalah vanishing/exploding gradient.

Vanishing/exploding gradient disebabkan oleh unstable gradient pada neural network. Pada sebuah neural network yang memiliki banyak hidden layer, nilai gradient pada layer awal dapat menjadi sangat besar ataupun sangat kecil. Hal tersebut dikarenakan proses learning pada layer terdahulu  lebih lambat dari layer sebelumnya. Permasalahan vanishing/exploding gradient adalah permasalahan yang tidak dapat dielakan oleh ANN dengan deep hidden layer.

Baru-baru ini kita sering mendengar konsep Deep Neural Network (DNN),  yang merupakan re-branding konsep dari Multi Layer Perceptron dengan dense hidden layer [1]. Pada Deep Neural Network permalahan seperti vanishing / exploding gradient telah dapat diatasi sehingga untuk menlatih ANN dengan hidden layer lebih dari tiga sangatlah memungkinkan.

Kesuksesan dari DNN sendiri tidak hanya didukung oleh penemuan teknik komputasi untuk DNN, namun juga didukung dengan meningkatnya jumlah data yang tersedia untuk melatih DNN dan kapasitas hardware yang memungkinkan. Beberapa penemuan teknik komputasi DNN adalah aktivasi fungsi ReLu dan fungsi Cross Entropy Loss.

ReLu

ReLu[4]  merupakan sebuah aktifasi fungsi yang mengeluarkan output 0 jika nilai x = 0, jika tidak nilai keluaran adalah nilai x itu sendiri.

f(x) = max(0, x)

f(x) =\begin{cases}0, & \text{if } x < 0\\x, & \text{otherwise} \\ \end{cases} 

Aktivasi Fungsi Relu
Plotting relu dengan nilai x = [-100 ~ 100]

Turunan dari fungsi ReLu dapat diekspresikan denganf(x) =\begin{cases}0, & \text{if } x < 0\\1, & \text{otherwise} \\ \end{cases} 

Turunan fungsi relu
Graph dari turunan aktifasi fungsi ReLu
  • Keunggulan ReLu
    • Dibandingkan dengan sigmoid dan hard tanh, operasi pada fungsi ReLu lebih simpel dikarenakan implementasi ReLu dapat dilakukan dengan menggunakan threshold pada nilai 0. Selain itu, dikarenakan gradient dari ReLu adalah 1 atau 0 maka neuron dengan ReLu tidak akan mengalami vanishing gradient dikarenakan nilai gradient yang tidak akan saturate.
    • Pada beberapa paper ditemukan bahwa neural network model menggunakan ReLu dapat mencapai konvergen lebih cepat dibandingkan dengan model dengan sigmoid ataupun tanh
  • Permasalahan dalam ReLu
    • Walaupun relu tidak mengalami permasalahan vanishing gradient dan dapat mempercepat neural network model untuk mencapai konvergen, fungsi ReLu dapat menyebabkan masalah “dying neuron”. Hal tersebut akan terjadi ketika gradient dengan nilai yang besar melewati neuron dengan ReLu dan nilai weight diupdate berdasarkan nilai gradient tersebut.

w_{t} = w_{t-1} - \eta \nabla F(w_{t-1})

  • Hal ini akan menjadikan sebagian besar output keluaran neuron tersebut bernilai negatif yang mana pada fungsi ReLu akan bernilai 0.

Cross Entropy

Berbeda dengan artikel sebelumnya mengenai linear regressi, dimana squared error digunakan untuk menghitung error antara predicted output dan actual output, pada artikel ini akan digunakan cross entropy [3]. Hal ini dikarenakan permasalahan pada penggunaan squared error bila diimplementasikan pada kasus klasifikasi dengan logistik output.

Telah diketahui sebelumnya bahwa nilai gradient berdasarkan fungsi squared error tehadap nilai w_i  dengan logistik output adalah

\frac{\partial E}{\partial w_i} = - x_i y_i(1-y_i) (y_i - a_i)

Dapat dilihat dari formula diatas bahwa nilai (1-y_i)  akan mendekati 0 ketika nilai predicted output y mendekati 1. Sebagai contoh, jika y  mendekati 1 (y = 0.99999) dan nilai actual ouput a adalah 0, maka nilai gradient adalah \simeq 0 .

=  - x_i * 0.99999(1-0.99999)(0.99999- 0)

Hal tersebut dapat mengakibatkan proses latihan terjebak didalam plateau, dikarenakan nilai gradient update yang sangat kecil. Sedangkan pada kasus diatas seharusnya terdapat nilai gradient update yang cukup besar karena nilai predicted output y = 0.99999  berbeda dengan nilai actual output a = 0.

Berbeda dengan squared error, cross entropy tidak mengalami permasalahan seperti diatas. Pada cross entropy semakin besar kesalahan prediksi ANN maka akan semakin besar nilai update terhadap weight. Fungsi error cross entropy dapat diformulasikan sebagai berikut

E = - \frac{1}{N}\sum_{i=1}a_i log (y_i)+(1 - a_i)log(1-y_i)

dimana y_i adalah keluaran neuron ke ith, a_i adalah actual output ke ith, dan N  adalah jumlah total dataset. Sedangkan turunan untuk cross entropy dengan fungsi output logistik  terhadap w_i adalah

\frac{\partial E}{\partial w_i} = \frac{\partial z}{\partial w_i}\frac{\partial y_i}{\partial z_i}\frac{\partial E}{\partial y_i} =  - x_i y_i(1-y_i)  \frac{a_i(1-y_i) - (1 - a_i)y_i}{y_i(1 - y_i)} = - x_i(y_i - a_i)

Jika dilihat dari formula diatas, dapat disimpulkan bahwa besaran gradient update pada ANN model dengan error fungsi cross entropy akan ditetukan dengan nilai perbedaan antara predicted output dan actual output (y_i - a_i) . Semakin besar perbedaan antara keduanya, semakin besar nilai update pada weight neuron. Sebagai contoh, jika nilai y_i = 0.99999 sedangkan nilai a_i = 0, maka besaran nilai gradient update adalah x_i * 0.9999.

Full Implementasi

Dalam artikel kali ini, saya akan mengimplementasikan multilayer perceptron dengan lima hidden layer pada kasus diagnosis kanker payudara menggunakan Breast Cancer Wisconsin dataset. Wisconsin dataset sendiri terdiri dari 9 input features dan 2 output (benign atau  malignant). Input features merupakan hasil perhitungan dari sebuah digitized image of a fine needle aspirate (FNA) dari berat sebuah payu dara. Untuk penjelasan dataset dapat dilihat disini.

Struktur dari neural network model yang digunakan dalam artikel ini terdiri dari:

  • Input Layer: 9 units
  • Hidden Layer 1: 1024 output units (aktivasi fungsi: ReLu / Sigmoid)
  • Hidden Layer 2: 1024 output units (aktivasi fungsi: ReLu / Sigmoid)
  • Hidden Layer 3: 2048 output units (aktivasi fungsi: ReLu / Sigmoid)
  • Hidden Layer 4: 2048 output units (aktivasi fungsi: ReLu / Sigmoid)
  • Hidden Layer 5: 2048 output units (aktivasi fungsi: ReLu / Sigmoid)
  • Output Layer: 2 units (aktivasi fungsi: Logistic)
ANN Model struktur
Ilustrasi struktur ANN Model yang terdiri dari 5 hidden layers.

Pada implementasi kali ini, TensorFlow akan digunakan sebagai framework dalam memodelkan ANN. Tidak digunakannya Theano pada artikel ini dikarenakan pengembangan Thenao telah diberhentikan (detail).

Langkah pertama dalam implementasi ini adalah membuat fungsi untuk mendefinisikan model. Terdapat tiga variabel dalam fungsi tersebut, features, label, dan mode. Features adalah parameter untuk input feature. Labels adalah parameter untuk actual outputs. Sedangkan mode adalah parameter untuk mendefinisikan running mode, apakah train, eval, atau prediction.

1
2
# mendefinisikan ANN model
def my_model(features, labels, mode):

Pada implementasi ini ANN model akan memiliki struktur seperti penjelasan sebelumnya. Untuk menginisialisasi nilai weight pada model digunakan fungsi Xavier [5]. Dan pada input layer seluruh input akan di-reshape kedimensi [n, 9] dimana n adalah jumlah batch_size atau jumlah data untuk setiap epoch, nilai -1 mengindikasikan bahwa nilai batch_size tidak diinisialisasi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# fungsi xavier untuk inisialisasi weight neural network
init = tf.contrib.layers.xavier_initializer()
# aktivasi untuk hidden output units
activation = tf.nn.sigmoid
# definisikan sebuah tensor untuk input layer yg berdimensi 9
# -1 (belum didefinikan) adalah dimensi untuk jumlah batch
input_layer = tf.reshape(features["x"], [-1, 9])
# layer 1 dengan input adalah output dari input layer
# layer 1 memiliki 1024 output units dengan aktifasi sesuai dengan nilai variable activation
layer1 = tf.layers.dense(inputs=input_layer, units=1024, activation=activation, kernel_initializer=init,
name="layer1")
# layer 2 dengan input adalah output dari layer 1
# layer 2 memiliki 1024 output units dengan aktifasi sesuai dengan nilai variable activation
layer2 = tf.layers.dense(inputs=layer1, units=1024, activation=activation, name="layer2")
# layer 3 dengan input adalah output dari layer 2
# layer 3 memiliki 2048 output units dengan aktifasi sesuai dengan nilai variable activation
layer3 = tf.layers.dense(inputs=layer2, units=2048, activation=activation, name="layer3")
# layer 4 dengan input adalah output dari layer 3
# layer 4 memiliki 2048 output units dengan aktifasi sesuai dengan nilai variable activation
layer4 = tf.layers.dense(inputs=layer3, units=2048, activation=activation, name="layer4")
# layer 5 dengan input adalah output dari layer 4
# layer 5 memiliki 2048 output units dengan aktifasi sesuai dengan nilai variable activation
layer5 = tf.layers.dense(inputs=layer4, units=2048, activation=activation, name="layer5")
# output layer dengan input adalah output dari layer 5
# output layer memiliki 2 output units
logits = tf.layers.dense(inputs=layer5, units=2)
# menghitung probability terhadap seluruh kelas (benign atau maligant) berdasarkan input yang diberikan
prob = 1 / (1 + tf.exp(-logits))

Pada baris code diatas telah diimplementasikan ANN model sesuai dengan struktur yang dijelaskan sebelumnya. tf.layer.dense adalah sebuah tensor pada Tensorflow yang mendifinisikan feed-forward neural network, yang dapat digunakan sebagai (hidden/output) layer. Pada tensor logits parameter activation = None yang mana memiliki arti fungsi linear digunakan pada layer tersebut.

Tahap selajutnya adalah mendifinisikan aksi untuk setiap mode, train, eval, dan predict. Untuk setiap mode dapat didefinisikan nilai keluaran yang berbeda dengan mendifinisikan nilai paramater pada EstimatorSpec. Perlu diperhatikan bahwa pada Tensorflow sebuah fungsi yang medifinisikan ANN model harus memiliki output balikan class EstimatorSpec yang digunakan sebagai input untuk fungsi Estimator yang digunakan dalam proses melatih dan mengevaluasi model.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# prediksi dari model terdiri dari 2 units, class dan probability
# classes adalah index dari output units dengan nilai terbesar
# contoh jika nilai output units adalah [0.5, 0.3] maka classes adalah 0
predictions = {
"classes": tf.argmax(logits, axis=1),
"probabilities": prob
}
#aksi untuk mode predict
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
# merubah output menjadi onehot_labels
# contoh jika depth = 2, maka untuk nilai 1 = [1 0] dan nilai 2 = [0 1]
onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=2)
# meghitung cross entropy error
loss = -tf.reduce_mean(tf.cast(onehot_labels, tf.float64) * tf.log(prob) + (1.-tf.cast(onehot_labels, tf.float64)) * tf.log(1. - prob))
if mode == tf.estimator.ModeKeys.TRAIN:
#pada proses training digunakan metode Gradient Descent dengan learning rate 0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
train_op = optimizer.minimize(loss=loss, global_step=tf.train.get_global_step())
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
# evaluasi matrix saat proses validasi
eval_metric_ops = {
"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])
}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Setelah mendefinisikan ANN model, tahap terakhir adalah mendefinisikan dan menetapkan nilai tensor variable untuk input features dan labels. Pada implementasi ini Pandas library digunakan untuk me-manage dataset yang disimpan dalam file CSV.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# read dataset dalam bentuk CSV
data = pd.read_csv("data\\breast-cancer-wisconsin.csv")
# ambil data berdasarkan kolom pada DataFrame
# X = features input
# y = labels
X = data[["clump_thickness", "uniformity_of_cellsize", "uniformity_of_cell_shape", "marginal_adhesion", "single_epithelial_cell_size", "bare_nuclei", "bland_chromatin", "normal_nucleoli", "mitoses"]].values.astype("float64")
y = data["class"].values
# lakukan proses splitting untuk data train dan validasi
# 70% training dan 30% evaluasi
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# definisikan tensor untuk data train dan validasi
# pada proses training urutan data akan disuffel untuk setiap iterasi
# hal tersebut dilakukan untuk meningkatkan generalisasi performance dari ANN model
train_fn = tf.estimator.inputs.numpy_input_fn({"x": X_train}, y_train, num_epochs=1, shuffle=True)
eval_input_fn = tf.estimator.inputs.numpy_input_fn({"x": X_test}, y_test, num_epochs=1, shuffle=False)
# definisikan Estimator model dimana mode_fn adalah fungsi yang telah kita definisikan sebelumnya
# dan model_dir adalah directory untuk menyimpan model dan log dari model
estimator = tf.estimator.Estimator(model_fn=my_model, model_dir="./tmp/model(lr=0.001)_sign_grad")
# lakukan proses training sebanyak 300 iterasi
train_spec = tf.estimator.TrainSpec(input_fn=train_fn, max_steps=300)
# lakukan proses evaluasi atau validasi untuk setiap iterasi
eval_spec = tf.estimator.EvalSpec(input_fn=eval_input_fn)
# lakukan eksekusi untuk proses training dan validasi
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)

Hasil Eksprimen

Dalam eksperimen ini ANN model dilatih dengan learning rate 0.01* dan iterasi sebanyak 300.  Dataset dibagi menjadi dua bagian, training (70%) dan validasi (30%). Training error dan validasi error diestimasi dengan fungsi cross-entropy. Selain itu, akurasi performance dari model dievaluasi dengan validasi data pada setiap iterasi.

*Note: nilai learning rate akan sangat mempengaruhi hasil dari proses training, pemilihan nilai learning rate pada artikel ini dilakukan beberapa kali secara random. 0.01 adalah nilai yang terbaik yang didapatkan dalam eksperimen ini.

Error Loss

Berdasarkan grafik 1 dapat dilihat bahwa training dan validasi error ANN model menggunakan aktivasi fungsi ReLu pada hidden layer menurun secara berangsur pada setiap iterasi. Pada iterasi awal nilai dari training error dan validasi error berkisar diangka 0.68 dan terus menurun hingga mencapai nilai 0.25 pada akhir iterasi.

loss
Grafik 1: Error loss ANN model dengan fungsi ReLu atau Sigmoid pada hidden unit.

Disisi lain, training error dan validasi error dari ANN model dengan aktivasi fungsi Sigmoid tidak mengalami proses penurunan yang signifikan dari proses awal training. Pada iterasi awal nilai training dan validasi error berkisar pada nilai 0.66 dan berakhir pada kisaran nilai 0.65.

Dari hasil diatas, dapat disimpulkan bahwa penggunaan aktivasi fungsi ReLu pada hidden units meningkatkan performa dari proposed ANN model. Hal tersebut dikarenakan ANN model dengan ReLu memiliki kemungkinan yang lebih kecil untuk mengalami vansihing gradient yang biasa dialami oleh multilayer perceptron dengan deep hidden layer yang menggunakan aktivasi fungsi sigmoid atau tanh pada hidden units. ANN model dengan ReLu dapat melakukan proses trainining yang lebih baik dikarenakan komputasi gradient  yang tidak mengalami proses saturation.

Akurasi

Untuk mengevaluasi performa generalisasi dari ANN model pada kasus klasifikasi, sebuah model harus diuji untuk memprediksi unseen data. Seperti dijelaskan pada sebelumnya bahwa pada eksperimen ini, akurasi dari proposed model juga dihitung untuk setiap iterasi menggunakan validasi data.

Performa AKurasi
Grafik performa akurasi dari ANN model

 

Pada grafik 2 ditampilkan akurasi dari ANN model dengan ReLu atau Sigmoid aktivasi fungsi. Pada iterasi awal, akurasi dari ANN model dengan ReLu adalah 38.04% dan meningkat secara berkelanjutan pada setiap iterasi. Akurasi tertinggi dari ANN model dengan ReLu mencapai nilai 92.19 pada akurasi ke-268.

Berbeda dengan ReLu, akurasi dari ANN model dengan sigmoid pada hidden unitsnya tidak cukup memuaskan. Akurasi stagnan pada nilai 61.95% dari iterasi awal hingga iterasi akhir. Hal tersebut mengindikasikan terjadinya vanishing gradient, dimana proses pembelajaran pada model tidak terjadi pada keseluruhan layer ANN model.

Kesimpulan

Untuk melatih sebuah ANN model dengan deep hidden layer tidaklah mudah. Sebuah ANN dengan deep hidden layer dapat dengan mudah mengalami permasalahan vanishing\exploding gradient. Penemuan teknik komputasi seperti fungsi aktifasi ReLu dan fungsi error Cross Entropy dapat meminimalisir kemungkinan sebuah deep ANN untuk mengalami vanishing gradient. Pada artikel ini sebuah neural network dengan lima hidden layer digunakan untuk memodelkan permasalahan diagnosis kanker payu dara. Dari hasil eksperimen ditemukan bahwa ANN model dengan ReLu aktivasi fungsi memiliki performa yang lebih unggul dibanding dengan ANN model dengan sigmoid fungsi. Walaupun akurasi dari ANN model dengan ReLu memiliki performa yang menjanjikan (akurasi > 90%) namun pengembangan dari proposed model masih bisa dapat dilakukan.

Download

Source code dari implementasi diatas dapat didownload disini

Referensi

[1] LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep learning. Nature521(7553), 436-444.

[2] https://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf

[3] http://www.deeplearningbook.org/

[4] Nair, V., & Hinton, G. E. (2010). Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10) (pp. 807-814).

[5] Glorot, X., & Bengio, Y. (2010, March). Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics (pp. 249-256).

Disarikan dari https://prasetiautamacv.wordpress.com/2018/01/07/multi-layer-perceptron-menggunakan-tensorflow-pada-kasus-diagnosis-kanker-payudara/

ByVisions education

Pada Sebuah Bumi, Aku Menangis: Sebuah Novel Religi

Intinya apapun status agama anda tidak lah pasti mencerminkan kepribadian seseorang itu baik atau buruk. Memang kita mesti memiliki parameter untuk mengukur tingkat keimanan kita dengan tingkat Iman.Namun,kita tidak boleh berpikir bahwa Agama saya lah yang paling baik dan benar. Berikut sinopsis novel religi yang menarik yang akan saya ringkaskan untuk Anda.

Nalini terlahir dengan cap anak haram oleh semua orang, dikarenakan ayah dan ibunya yang menikah di bawah tangan dan tak mendapat persetujuan dari siapapun. Karena hukum agama dan undang-undang menyatakan bahwa pernikahan yang dilakukan oleh seorang lelaki dan perempuan yang masih tergolong satu mahram, maka haram untuk menikah. Ayah dan ibu Nalini, adalah sesama saudara sesusuan. Rabiah, ibu Nalini yang dulunya pernah disusui oleh ibu dari Husain, yang menjadi suaminya itu nekad untuk tetap hidup bersama walau memang sadar mereka tersalah. Tapi cinta mengalahkan semuanya, hasrat dan cinta mereka membuat semuanya seakan buta. Tak peduli pada setiap cercaan semua orang dan anggota keluarga yang menentang kisah percintaan mereka yang terlarang.

Sampai lahirlah seorang bayi perempuan bernama Nalini. Yang akhirnya diasuh oleh tantenya, adik dari ayahnya. Setelah Husain dan Rabiah meninggal dunia. Husain meninggal terserang penyakit jantung, sedangkan Rabiah meninggal setelah melahirkan Nalini. Cinta yang sehidup semati. Membuat gadis itu merindukan kehadiran keduanya setiap saat dalam kesepian, melamun dalam senja.

Kesendirian itu menimbulkan Nalini menjadi seorang gadis penyendiri, karena ia takut jika ada teman-teman yang mengerti akan kisah hidup orangtuanya, kembali mengejeknya sebagai anak haram. Tapi ternyata tak ada satupun teman di masa lalunya yang saat ini tengah berada di kampus yang ia masuki. Teman-teman Nalini menganggapnya sedikit aneh karena ia sering duduk sendiri di bawah pohon beringin tua. Padahal di tempat itulah, Nalini dapat merasakan keteduhan, sambil mengamati sekumpulan gadis-gadis berjilbab yang selalu tertawa riang seakan tak mengenal sebuah masalah yang berat menghinggapi mereka.

 

Tertarik?

silahkan download di playstore yaa!

Estimate Price: IDR Rp 41.500,-

Disarikan dari penulis novel terkenal Vanny Chrisma W