Statistika dan Machine Learning: Satu Ilmu Dua Wajah

Versi pdf dari tulisan ini bisa didownload di http://rizal.fathony.org/pdf/sml.pdf
Hampir semua orang yang bergelut di dunia ilmu pengetahuan sedikit banyak pasti pernah berinteraksi dengan statistika (ilmu statistik). Tidak dapat dipungkiri bahwa statistika mempunyai peranan penting sebagai katalis perkembangan ilmu-ilmu lain, baik ilmu alam (seperti astronomi dan biologi) ataupun ilmu sosial (seperti ekonomi, demografi, sosiologi, dsb.). Statistika dipakai oleh disiplin ilmu lain sebagai alat untuk mengambil kesimpulan, menguji hipotesis/teori, memahami fenomena, menganalisis eksperimen, menentukan keputusan, dsb.

Machine learning saat ini menjadi cabang ilmu pengetahuan yang populer dibicarakan di media. Didapuk sebagai salah satu cabang dari ilmu kecerdasan buatan (artificial inteligence), hampir semua orang pernah berinteraksi, memakai ataupun mendengar sistem komputer yang dibangun memakai teknik machine learning. Mulai dari melihat tag-otomatis foto di Facebook, menggunakan rekomendasi pencarian di Google, meng-klik rekomendasi produk sejenis di online shopping, menikmati servis email tanpa-spam, sampai dengan mendengar berita AlphaGo yang mengalahkan pemain profesional top di permainan Go.

Meskipun aplikasi dari disiplin ilmu statistika dan machine learning kelihatan sangat berbeda, dua ilmu tersebut sangat berkaitan. Baik statistika maupun machine learning merupakan ilmu tentang data. Teori-teori di disiplin ilmu statistika dan machine learning sebagian besar juga saling tumpang tindih. Hal ini bisa dilihat dari isi sebuah buku tentang statistika, “All of statistics: a concise course in statistical inference” (Wasserman, 2013) dan buku tentang machine learning, “Machine learning: a probabilistic perspective” (Murphy, 2012). Jika kita lihat sekilas kata-kata kunci dari daftar isi buku “All of statistics”, akan sangat susah mencari kata kunci yang tidak tercantum juga di buku “Machine learning”. Topik-topik mulai dari probability distribution, linear & logistic regression, maximum likelihood estimation, markov model, sampai Bayesian MCMC dibahas oleh kedua buku. Jadi, apa persamaan dan perbedaan kedua disiplin ilmu tersebut? Kita akan bahas lebih detail di tulisan ini.

Pondasi dasar: teori peluang

Pondasi dasar dari statistika dan machine learning adalah ilmu teori peluang. Semua teknik-teknik dalam statistika dan machine learning dibangun di atas teori peluang, yang merupakan bahasa matematika untuk mengukur derajat ketidakpastian. Ilmu-ilmu dasar yang juga penting bagi statistika dan machine learning diantaranya adalah aljabar linear, kalkulus dan teknik optimisasi. Dalam mendalami statistika dan machine learning, latar belakang kuat di ilmu-ilmu dasar tersebut akan sangat membantu.

Disiplin ilmu statistika sudah dirintis sejak abad ke 17 di mana dasar-dasar teori peluang dirumuskan oleh berbagai ahli. Berbagai distribusi peluang seperti distribusi normal/Gaussian, dan distribusi Poisson dirumuskan di sekitar abad ke 18 dan 19. Pondasi dari teori statistika modern dituangkan oleh statistisi dari Inggris, Ronald Fisher di awal abad ke 20. Kontribusi Fisher sangat penting dalam perkembangan statistika termasuk diantaranya adalah teknik estimasi terkenal maximum likelihood.

Dibandingkan statistika, disiplin ilmu machine learning masih tergolong relatif lebih muda, baru dirumuskan di sekitar akhir abad 20. Machine learning didefinisikan sebagai disiplin ilmu yang mempelajari algoritma komputer yang bisa belajar (learn) tanpa harus diprogram secara eksplisit, melainkan dengan sendirinya belajar dari data. Karena machine learning juga merupakan ilmu yang menggunakan data, pondasi dasar machine learning banyak ‘meminjam’ dari disiplin ilmu statistika yang pada abad 20 sudah relatif lebih matang.

Pengambilan kesimpulan dan interpretasi vs. prediksi

Kalau topik-topik yang dipelajari statistika dan machine learning kurang lebih sama, ilmu-ilmu dasar yang dibutuhkan-pun juga sama, lalu di mana letak perbedaan statistika dan machine learning? Perbedaan utamanya terletak pada fokus yang berbeda dari kedua disiplin ilmu tersebut. Statistika lebih fokus ke pengambilan kesimpulan dan interpretasi dari model, sedangkan machine learning lebih fokus ke penggunaan model untuk prediksi data baru. Untuk lebih jelasnya mari kita lihat contoh sederhana dari alur kerja praktisi statistika dan machine learning dalam memecahkan masalah.

Salah satu contoh problem sederhana yang sering dianalisis oleh praktisi statistika diantaranya adalah problem di mana peneliti mempunyai variabel dependen kategorik y yang ingin dianalisis dengan beberapa variabel independen x1, x2, … . Contoh aplikasinya misalnya analisis tentang kelulusan mahasiswa di mana y = 1 bermakna lulus dan y = 0 bermakna tidak lulus. Variabel-variabel x bisa berupa profil mahasiswa, total jam belajar, jam tidur, keaktivan di kelas, dan variabel-variable lain yang mungkin berhubungan dengan kelulusan. Teknik yang sering dipakai untuk memodelkan problem seperti ini diantaranya model regresi logistik.

Alur kerja praktisi statistika dalam membangun model regresi logistik biasanya dimulai dengan pengecekan asumsi, menjalankan estimasi parameter (maximum likelihood) dengan software, mengecek nilai parameter dan signifinasinya, dan memilih variabel yang signifikan. Untuk mengecek dan membandingkan model mana yang lebih bagus (variabel mana saja yang sebaiknya dimasukkan ke model), ukuran seperti Akaike Information Creiterion (AIC)} akan digunakan. Setelah modelnya fix, praktisi statistika akan menganalisis interpretasi dari parameter yang dihasilkan, seperti variabel apa yang mempengaruhi kelulusan, apakah mempengaruhi secara positif/negatif, dan seberapa besar pengaruhnya (bisa dicek dari nilai parameter untuk variabel tersebut). Pada akhirnya akan praktisi statistika akan menarik kesimpulan tentang hubungan variabel-variabel tersebut dengan kelulusan mahasiswa.

Kita lihat contoh problem yang dihadapi praktisi machine learning dengan tipe yang mirip, satu variabel dependen kategorik y dan beberapa variabel independen x1, x2, … . Contoh aplikasinya misalnya untuk mendeteksi email spam. Nilai variabel y = 1 berarti email spam, y = 0 berarti bukan email spam. Variabel-variabel x berisi karakteristik dari email tersebut, misalnya jumlah kata di email, apakah email mengandung attachment, apakah ada gambar di email itu, atau apakah email mengandung kata-kata tertentu, misalnya kata “promo” atau “obat”.

Model regresi logistik juga termasuk salah satu model yang sering dipakai praktisi machine learning. Mereka juga melakukan estimasi parameter dengan maximum likelihood via software. Praktek menambahkan regularisasi seperti L1 (lasso) atau L2 (ridge) ke model sangat lumrah dilakukan di machine learning untuk meningkatkan generalisasi dari model. Praktisi machine learning biasanya tidak begitu fokus ke pemilihan variabel terutama jika jumlah variabelnya tidak banyak, semua variabel masuk ke model. Fokus pemilihan dan pembandingan model lebih ke bagaimana memilih konstanta regularisasi yang tepat. Untuk melakukan itu praktisi machine learning membagi dataset untuk modeling (training data) ke beberapa fold dan melakukan teknik cross validation. Model yang memiliki tingkat kesalahan prediksi paling kecil di tahap cross validation akan dipilih. Selanjutnya, model tersebut akan disimpan, di-deploy ke server dan dibikin programming interface yang nantinya akan dipanggil sekiranya ada email baru yang perlu diprediksi apakah spam atau bukan.

Dari dua alur kerja diatas, walaupun sama-sama menggunakan model regresi logistik, terlihat jelas perbedaan fokus dati praktisi statistika dan machine learning. Selain dari fokus yang berbeda (interpretasi versus prediksi), ada beberapa perbedaan yang terlihat. Diantaranya adalah bagaimana memperlakukan parameter hasil estimasi. Tidak seperti praktisi statistika, praktisi machine learning kurang peduli tentang nilai dari parameter-parameter tersebut. Ada preferensi di mana praktisi machine learning ingin agar nilai parameter-parameter tersebut relatif kecil dengan menambahkan regularisasi, namun berapapun nilainya tidak menjadi permasalahan, asalkan model tersebut bisa memprediksi data baru dengan akurat. Perbedaan yang lain ada dalam cara pemilihan model. Praktisi statistika cenderung memilih model berdasarkan teori analitik seperti AIC, sedangkan praktisi machine learning cenderung memilih model berdasarkan performa empirikal di tahap cross validation.

Apa konsekuensi dari perbedaan ini? Arah kompleksitas pengembangan yang berbeda dari statistika dan machine learning. Langkah selanjutnya setelah pemodelan regresi logistik bagi praktisi statistika akan berusaha mendapatkan kesimpulan dan interpretasi yang lebih pas, seperti dengan menganalisis lebih lanjut sumber variance dari model dengan ANOVA, atau memodelkan berdasarkan distrbusi peluang yang lain dengan Generalized Linear Model (GLM). Karena pentingnya interpretasi dari model yang didapat, praktisi statistika cenderung memilih model-model linear untuk analisis. Faktanya, GLM merupakan model yang paling populer di disiplin ilmu statistika.

Karena fokus peneliti machine learning lebih ke akurasi prediksi, semakin banyak informasi (variabel independen) yang masuk ke model, cenderung memberikan prediksi yang lebih bagus. Untuk kasus permodelan text, seperti contoh email spam di atas, variabel-variable yang lumrah dipakai oleh praktisi machine learning adalah diperoleh dari teknik bag-of-words. Dengan teknik ini, setiap kata atau kombinasi kata yang ada di kamus menjadi satu variabel yang nilainya 1 jika variabel kata tersebut ada di email, atau 0 jika tidak ada. Hasilnya, jumlah variabel bisa ribuan bahkan jutaan. Model linear juga kurang begitu banyak dipakai oleh praktisi machine learning karena akurasi prediksi akan cenderung meningkat dengan model non-linear. Non-linearitas bisa didapatkan dengan banyak cara, di antaranya adalah dengan menumpuk beberapa model linear ke beberapa layer seperti yang dilakukan di model Neural Network, atau memproyeksikan variabel ke dimensi lebih tinggi seperti yang di lakukan oleh teknik kernel trick yang lumrah diterapkan di model Support Vector Machine (SVM). Kompleksitas model tidak menjadi masalah bagi praktisi machine learning asalkan bisa meningkatkan akurasi prediksi dan ada resource komputer untuk menjalankan estimasi model.

Area-area sama-sama di dalami oleh peneliti statistika dan machine learning

Meskipun alur kerja praktisi statistika dan machine learning begitu berbeda seperti contoh di atas, mereka sama-sama menggunakan model regresi logistik dan menggunakan teori dan rumus yang sama. Faktanya, banyak sekali teori yang sama-sama dipelajari baik di bidang ilmu statistika ataupun machine learning. Di bagian ini kita akan melihat beberapa contohnya. Dari sisi paling dasar misalnya, statistika dan machine learning sama-sama membahas konsep random variable, distribusi-distribusi statistik, expected value, variansi, sampai pada konsep distribusi prior dan posterior.

Teknik inferensi model parametrik dengan maximum likelihood estimation (MLE) juga dipelajari di kedua ilmu, sekaligus teori-teori MLE seperti konsistensi dan sufficient statistic. Algoritma untuk mendapatkan estimasi MLE secara numerik seperti menggunakan metode gradient descent and Quasi Newton juga dipelajari di machine learning dan statistika komputasi. Teknik MLE untuk kasus di mana suatu model bergantung pada variabel yang tidak diobservasi melalui Expectation – maximization (EM) algorithm juga sangat populer di kalangan peneliti statistika dan machine learning, termasuk juga penerapan EM algorithm untuk estimasi mixture model.

Model-model linear seperti regresi linear, regresi logistik, dan GLM, beserta variasi regularisasi dari model-model tersebut seperti regressi lasso dan regresi ridge dipelajari di kedua disiplin ilmu. Teknik reduksi variabel secara linear seperti Principal Component Analysis (PCA) dan Independent Component Analysis (ICA) sering juga digunakan oleh praktisi kedua disiplin ilmu. Model linear Support Vector Machine (SVM) yang mempunyai karekteristik sample sparsity –dimana parameter model hanya bergantung pada sebagian kecil dari data– sangat populer di bidang machine learning dan juga mulai dipelajari di bidang ilmu statistika.

Konsep-konsep Bayesian statistics memegang peranan sangat penting baik di disiplin ilmu statistika dan machine learning. Banyak sekali model-model yang dipelajari di kedua ilmu yang menggunakan prinsip Bayesian statistics seperti Bayesian linear regression, Bayesian logistic regression, Bayesian GLM, Latent Dirichlet Allocation (LDA), dan beberapa Bayesian non-parametric model seperti Gaussian Process dan Dirichlet Process. Konsep-konsep distribution sampling seperti importance sampling, Markov Chain Monte Carlo (MCMC), dan Gibbs sampling sama-sama dipelajari di statistika dan machine learning.

Area-area lain yang sama-sama dipelajari di bidang ilmu statistika dan machine learning diantaranya, probability density estimation, model non-parametik, analisis cluster, dan model Marckov chain.

Area penting bagi peneliti statistika yang kurang didalami peneliti machine learning

Fokus yang berbeda dari disiplin ilmu statistika dan machine learning mengakibatkan arah konsentrasi yang berbeda pula dari kedua ilmu tersebut. Berikut ini adalah contoh-contoh area yang menjadi fokus peneliti statistika namun kurang didalami oleh peneliti machine learning. Sebagian besar dari area-area di bawah ini sangat penting untuk menunjang keakuratan pengambilan kesimpulan dan interpretasi model namun tidak begitu penting untuk prediksi.

Sampling (dari populasi). Teori pengambilan sampel (sampling) sangat penting peranannya pada fase pengumpulan data sebelum nantinya diproses dan dianalisis, terutama untuk aplikasi statistika di bidang ilmu sosial. Teknik pengambilan sampel yang benar akan memberikan garansi pada ke-valid-an penarikan kesimpulan yang nantinya akan diambil saat melakukan analisis lebih lanjut. Di sisi lain, data-data yang di olah oleh praktisi machine learning kebanyakan berupa data transaksional dimana tidak diperlukan pengambilan sampel. Sebagai contoh, kasus kasus klasifikasi email spam. Data untuk membentuk model didapatkan dari email-email sebelumnya. Tantangan di machine learning biasanya adalah kebanyakan dari data yang ada tidak mengandung label (variabel dependen y). Untuk kasus ini diperlukan input dari manusia untuk memberikan label ke data, sebagai contoh, memberikan label apakah suatu email adalah spam atau bukan.

Uji hipotesis. Pengujian hipotesis adalah salah satu aspek paling penting di bidang ilmu statistika. Praktisi statistika menggunakan teknik-teknik pengujian hipotesis untuk menarik kesimpulan apakah hipotesis awal yang mereka bentuk dalam suatu permasalahan didukung oleh data ataukah tidak. Pengujian hipotesis tidak banyak didalami peneliti machine learning karena fokus mereka yang lebih ke prediksi daripada pengambilan keputusan.

Analisis varians (ANOVA). ANOVA dan generalisasinya (seperti MANOVA, dan MANCOVA) merupakan tekniki yang dipakai luas di bidang ilmu statistika. Teknik ini menganalisa dan membandingkan variasi dari dua grup berbeda. Sebagaimana dengan uji hipotesis, analisis varians juga kurang didalami oleh peneliti machine learning.

Model-model linear advanced. Beberapa model linear yang lebih advanced dikembangkan oleh peneliti statistika untuk menganalisis lebih lanjut model yang lebih kompleks. Sebagai contoh adalah path analysis dimana interaksi antar variabel dideskripsikan dalam bentuk graph. Contoh lainnya adalah survival analysis yang memodelkan rata-rata waktu sebelum suatu event akan terjadi. Peneliti statistika juga mengembangkan model linear yang lebih kompleks untuk menganalisis kasus-kasus dimana asumsi standar dari model yang sederhana tidak terpenuhi. Sebagai contoh adalah two stages least square regression, dan generalized estimating equation (GEE).

Area penting bagi peneliti machine learning yang kurang didalami peneliti statistika

Di sisi lain, banyak juga area-area yang menjadi fokus di disiplin ilmu machine learning, namun kurang didalami oleh peneliti statistika. Area-area tersebut sebagian besar berguna untuk meningkatkan akurasi dari prediksi namun mengakibatkan model yang dibentuk menjadi kompleks dan susah untuk di-interpretasikan. Berikut ini beberapa contoh diantaranya.

Kernel trick. Teknik ini terkait dengan proyeksi variabel. Berbalikan dengan teknik-teknik proyeksi variabel ke dimensi lebih rendah yang populer di statistika dan machine learning seperti melalui PCA, kernel trick berkaitan dengan proyeksi variabel ke dimensi lebih tinggi. Kernel trick memungkinkan sebuah model linear seperti regresi logistik atau SVM untuk mendapakkan non-linearitas dengan secara tidak langsung memproyeksikan variabel ke dimensi yang lebih tinggi (bahkan dimensi tak terhingga) tanpa harus melakukan transformasi variabel secara eksplisit.

Neural networks dan deep learning. Cara lain untuk mendapatkan non-linearitas adalah dengan menumpuk beberapa model linear ke beberapa layer. Teknik inilah yang dilakukan oleh neural network. Teknik deep learning yang sangat populer saat ini menggunakan banyak layer yang dimana di setiap layer berfungsi untuk membentuk representasi menengah yang lebih compact dari data. Beberapa teknik tambahan seperti parameter sharing, convolution dan recurrence berperan untuk menambah keakuratan dari representasi tersebut dan menunjang kesuksesan applikasi deep learning di berbagai area seperti computer vision (CV) dan natural language processing (NLP).

Inferensi semi-supervised. Di beberapa kasus, terkadang data yang tersedia sangat banyak, namun hanya sebagian kecil dari data tersebut memiliki label. Untuk mendapatkan label membutuhkan ahli yang biayanya mahal. Sebagai contoh adalah kasus untuk memprediksi apakah suatu review di website e-commerce asli dari pembeli ataukah palsu (misalnya komentar bayaran). Data untuk variabel independen (x) sangat banyak tersedia yang bisa didapatkan dari komentar-komentar yang sudah ada. Namun untuk mendapatkan label (y), perlu seorang ahli yang membaca dan menganalisis review untuk menentukan review tersebut palsu atau tidak. Teknik inferensi semi-supervised mencoba untuk mengikutsertakan data-data tanpa label ke dalam pembentukan model.

Probabilistic graphical models (PGM). PGM memodelkan conditional dependency dari koleksi beberapa random variable. PGM banyak dipakai oleh peneliti machine learning untuk menangaini structured prediction, kasus dimana model tidak hanya melakukan prediksi satu variabel y, tetapi melakukan prediksi vektor y yang mempunyai struktur. Sebagai contoh adalah kasus aplikasi di area NLP dimana kita diberikan satu kalimat sebagai isi dari variabel x dan harus mempredisksi tiap kata di kalimat itu apakah menjadi subjek, predikat, objek, ataukah keterangan. Beberapa model PGM yang populer diantaranya adalah hidden Markov model (HMM), conditional random field (CRF), dan latent Dirichlet allocation (LDA).

Cara berfikir matematis vs. algoritmis

Peneliti disiplin ilmu statistika kebanyakan berada di Department of Statistics atau Department of Mathematics and Statistics, sedangkan peneliti machine learning kebanyakan berada di Department of Computer Science. Peneliti statistika rata-rata memulai belajar dari latar belakang matematika, sedangkan peneliti machine learning rata-rata memulai dari latar belakang algoritma.

Dalam menghadapi suatu masalah, peneliti statistika lebih melihat dari sisi formulasi matematika untuk memodelkan masalah. Peneliti machine learning, selain memperhitungkan model matematika, rata-rata juga memikirkan bagaimana peforma dari algoritma yang akan digunakan untuk mengestimasi model. Performa dari algoritma biasanya di ukur dengan big O notation. Sebagian besar publikasi riset peneliti machine learning mendeskripsikan algoritma estimasi model beserta performa/kompleksitas dari algoritma tersebut. Sebagai contoh adalah algoritma inferensi model latent dirichlet allocation (LDA) (Blei, et al., 2003) yang memiliki kompleksitas O(kN^2), dimana N adalah jumlah sampel dan k adalah jumlah variabel. Artinya kurang lebih adalah, jika jumlah sampel bertambah menjadi dua kali lipat, algoritma tersebut akan berjalan 4 kali lebih lambat dari sebelumnya; dan jika jumlah variabel bertambah dua kali lipat, algoritma akan menjadi 2 kali lebih lambat juga.

Analisis komplksitas algoritma ini sangat penting untuk melihat apakah algoritma itu akan cocok di-implementasikan ke data yang lebih besar. Algoritma inferens yang memiliki kompleksitas O(N) tentunya akan lebih dipilih daripada algorima dengan kompleksitas O(N^2). Hal ini dikarenakan jika jumlah sampel bertambah menjadi seribu kali lipat misalnya, algoritma dengan kompleksitas O(N) hanya akan menjadi lebih lambat seribu kali lipat juga, semisal yang awalnya memakan waktu 1 detik menjadi 1000 detik atau sekitar 17 menit. Di sisi lain, algoritma dengan kompleksitas O(N^2) menjadi satu juta kali lebih lambat, dari 1 detik menjadi 1 juta detik atau sekitar 12 hari. Sangat terasa perbedaannya.

Kultur jurnal vs. konferensi

Selain dari perbedaan cara berfikir, terdapat perbedaan kultur dalam proses publikasi hasil riset peneliti statistika dan machine learning. Tempat utama untuk publikasi pengambangan riset statistika adalah di jurnal, seperti Annals of Statistics, Biometrika, dan Journal of the American Statistical Association (JASA). Disisi lain, sebagai mana area riset lain di bawah Department of Computer Science, tempat utama publikasi riset oleh peneliti machine learning adalah di konferensi. Publikasi di konferensi-konferensi utama seperti Neural Information Processing Systems (NIPS) dan International Conference on Machine Learning (ICML) dan konefensi-konferensi lain (UAI, AISTATS, COLT) menjadi fokus utama peneliti machine learning. Dampaknya adalah progress pengembangan machine learning berjalan lebih cepat dari statistika, karena alur pemrosesan publikasi mulai dari submission sampai penerbitan hanya memakan waktu beberapa bulan untuk konferensi, dibandingkan jurnal yang bisa memakan waktu beberapa tahun. Peneliti machine learning dituntut untuk mengejar deadline konferensi untuk menuangkan ide baru mereka, sebelum orang lain yang punya ide mirip mempublikasikannya. Jika ide yang sudah dipublikasikan di konferensi perlu penjelasan lebih detail, jurnal machine learning seperti Journal of Machine Learning Research (JMLR) adalah tempatnya.

Bahasa pemrograman

Bahasa pemrograman yang populer di kalangan peneliti statistika adalah R. Hampir semua peneliti statistika menggunakan R untuk menuangkan ide dan teori mereka. Untuk praktisi statistika, selain R, bahasa yang pupuler diantaranya adalah SAS, Stata, dan Python. Di kalangan peneliti dan praktisi machine learning, Python menjadi bahasa yang paling populer, disusul oleh C++ untuk implementasi model yang membutuhkan performa tinggi, MATLAB untuk implementasi ide secara cepat, dan Lua yang populer di praksisi deep learning. Bahasa R juga populer di kalangan praktisi machine learning. Sebagian kecil dari peneliti dan praktisi statistika dan machine learning menggunakan bahasa pemrograman Julia yang memungkinkan implementasi ide secara cepat tanpa harus mengorbankan performa.

Penutup

Seperti yang telah dibahas di bagian-bagian sebelumnya, disiplin ilmu statistika dan machine learning mempunyai banyak persamaan dan juga perbedaan. Kedua disiplin ilmu sama-sama berdasarkan teori peluang dan membahas dasar-dasar teori dan model yang sama. Perbedaan keduanya terletak pada fokus yang berbeda. Statistika lebih fokus ke arah pengambilan kesimpulan, sedangkan machine learning fokus ke prediksi data baru. Dari persamaan dan perbedaan tersebut, tidak salah kalau statistika dan machine learning disebut sebagai dua wajah berbeda dari satu kesatuan disiplin ilmu.

Referensi

Blei, David M, Ng, Andrew Y, and Jordan, Michael I. Latent dirichlet allocation. Journal of Machine Learning Research, 3(Jan):993–1022, 2003.

Breiman, Leo et al. Statistical modeling: The two cultures. Statistical science, 16(3):199–231, 2001.

Friedman, Jerome, Hastie, Trevor, and Tibshirani, Robert. The elements of statistical learning, volume 1. Springer series in statistics Springer, Berlin, 2001.

Harrell, Frank. Regression modeling strategies: with applications to linear models, logistic and ordinal regression, and survival analysis. Springer, 2015.

Murphy, Kevin P. Machine learning: a probabilistic perspective. MIT press, 2012. Wasserman, Larry. Rise of the machines.

Wasserman, Larry. All of statistics: a concise course in statistical inference. Springer Science & Business Media, 2013.

Beberapa artikel di wikipedia

Calling Python’s scikit-learn machine learning library from Julia

It turns out to be very easy.

Here’s a python code for SVM classification

import sklearn.svm as sv
clf = sv.SVC()
clf.fit(X, y)
y_pred = clf.predict(X_test)

And here’s Julia code – utilizing PyCall module

using PyCall
@pyimport sklearn.svm as sv
clf = sv.SVC()
clf[:fit](X, y)
y_pred = clf[:predict](X_test)

Some useful functions/tricks in Julia’s REPL console

When writing code in Julia, I use REPL console frequently, mainly to understand how some functions or some expressions works in Julia. I usually create something like dummy matrices and vectors, and test the function/expression using that dummies. Fortunately, Julia’s REPL console provides many useful tricks for exploring how it works.

?Help

Getting help on a function in Julia is easy, just type ? followed by the name of the function to show the manual. Here’s an example

help?> eig
Base.eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> D, V

   Computes eigenvalues and eigenvectors of "A". See "eigfact()"
   for details on the "balance" keyword argument.

      julia> eig([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
      ([1.0,3.0,18.0],
      3x3 Array{Float64,2}:
       1.0  0.0  0.0
       0.0  1.0  0.0
       0.0  0.0  1.0)

   "eig" is a wrapper around "eigfact()", extracting all parts of
   the factorization to a tuple; where possible, using "eigfact()"
   is recommended.

Base.eig(A, B) -> D, V

   Computes generalized eigenvalues and vectors of "A" with respect
   to "B".

   "eig" is a wrapper around "eigfact()", extracting all parts of
   the factorization to a tuple; where possible, using "eigfact()"
   is recommended.

Who’s there?

Julia’s REPL provides the function whos() to display all the variables (and functions) in the environment. Take a look on this example:

julia> a = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> f(x) = x^2
f (generic function with 1 method)

julia> whos()
Base                          Module
Core                          Module
Main                          Module
a                             3-element Array{Int64,1}
ans                           Function
f                             Function

If we want to see all functions inside a module, we can use whos(ModuleName). Executing whos(Core) will show all functions/variables inside the Core module.

julia> whos(Core)
===                           Function
ANY                           TypeVar
ASCIIString                   DataType
AbstractArray                 DataType
Any                           DataType
Array                         DataType
Bool                          DataType
........

We can search for functions using Regex, for example if we want to see all function in Base containing the word with “inv”:

julia> whos(Base, r"inv"i)
erfcinv                       Function
erfinv                        Function
inv                           Function
invdigamma                    Function
invmod                        Function
invperm                       Function
pinv                          Function

Methods

In Julia, function is a collection of methods. Similar with the concept of polymorphism in Object Oriented Programming, in Julia, there can be many functions (methods) with the same name, but with different signature. The choice of which method to execute when we call a function is called dispatch. In Julia, the choice is based on the number of arguments passed to the function, and on the type of all arguments. If there are more than one methods satisfy the requirement, the one with the more specific types will be called. Here’s an example:

julia> f(x) = println("General method is called")
f (generic function with 1 method)

julia> f(x::Number) = println("Method for handling number")
f (generic function with 2 methods)

julia> f(x::Float64) = println("Method for handling floating point")
f (generic function with 3 methods)

julia> f(1)
Method for handling number

julia> f(1.0)
Method for handling floating point

julia> f([1, 2])
General method is called

Note that f(1.0) satisfy both f(x::Number) and f(x::Float64), but the more specific method is called.

Julia provides methods() function to show all methods in a function.

julia> methods(eye)
# 7 methods for generic function "eye":
eye{T}(::Type{Diagonal{T}},n::Int64) at linalg/diagonal.jl:95
eye(T::Type{T<:Top},m::Integer,n::Integer) at array.jl:176
eye(m::Integer,n::Integer) at array.jl:182
eye(T::Type{T<:Top},n::Integer) at array.jl:183
eye(n::Integer) at array.jl:184
eye(S::SparseMatrixCSC{Tv,Ti<:Integer}) at sparse/sparsematrix.jl:414
eye{T}(x::AbstractArray{T,2}) at array.jl:185

We can also show all methods that are applicable to a variable using methodwith() function. For example to show all methods that accept a Matrix variable:

julia> methodswith(Matrix)
67-element Array{Method,1}:
 size(a::Array{T,2}) at array.jl:20
 -(A::Array{T,2},B::Diagonal{T}) at linalg/special.jl:90
 -(A::Array{T,2},B::Bidiagonal{T}) at linalg/special.jl:90
 -(A::Array{T,2},B::Tridiagonal{T}) at linalg/special.jl:90
 -(A::Array{T,2},B::Triangular{T,S<:AbstractArray{T,2},UpLo,IsUnit}) at linalg/special.jl:90
 -(A::Array{T,2},B::SymTridiagonal{T}) at linalg/special.jl:99
..............

Which one?

In order to see which method will be chosen when we execute a function or expression, we can use @which macro.

julia> @which f(4.0)
f(x::Float64) at none:1

julia> @which 1 + 2
+(x::Int64,y::Int64) at int.jl:33

julia> @which 1.0 + 2
+(x::Number,y::Number) at promotion.jl:158

julia> @which rand(1, 2)
rand(dims::Int64...) at random.jl:123

Types-hierarchy

Since understanding Types-hierarchy is very important in Julia (it’s a key to master methods), we might want to know functions related to Type. Some basic type functions are subtypes(), super() typeof(), isa(), and issubtype(). Below are the examples:

julia> typeof(1.0)
Float64

julia> super(Float64)
FloatingPoint

julia> subtypes(Number)
2-element Array{Any,1}:
 Complex{T<:Real}
 Real

julia> subtypes(Real)
5-element Array{Any,1}:
 FixedPoint
 FloatingPoint
 Integer
 MathConst{sym}
 Rational{T<:Integer}

julia> isa(1.0, Real)
true

julia> isa(1.0, Integer)
false

julia> isa(1.0, Number)
true

julia> issubtype(Integer, FloatingPoint)
false

julia> issubtype(Integer, Number)
true

Note that some types has alias, for example Array data type which contains Vector (1-d array), Matrix (2-d array) and higher dimension Array.

julia> Vector
Array{T,1}

julia> Matrix
Array{T,2}

Compiler’s mind

Julia has built-in functions to see how the compiler parse the source code and translate it to lower representations of the code. Four macros @code_lowered, @code_typed, @code_llvm, and @code_native can be used to show four different levels of representation of the code from the highest to the lowest level.

julia> @code_lowered 1.0 + 2.0 + 3
1-element Array{Any,1}:
 :($(Expr(:lambda, {:a,:b,:c}, {{},{{:a,:Any,0},{:b,:Any,0},{:c,:Any,0}},{}}, :(begin  # operators.jl, line 82:
        return (a + b) + c
    end))))

julia> @code_lowered 3 * 2.0 + 1
1-element Array{Any,1}:
 :($(Expr(:lambda, {:x,:y}, {{},{{:x,:Any,0},{:y,:Any,0}},{}}, :(begin  # promotion.jl, line 158:
        return (top(apply))(+,promote(x,y))
    end))))

julia> @code_typed 3 * 2.0 + 1
1-element Array{Any,1}:
 :($(Expr(:lambda, {:x,:y}, {{},{{:x,Float64,0},{:y,Int64,0}},{}}, :(begin  # promotion.jl, line 158:
        return box(Float64,add_float(x::Float64,box(Float64,sitofp(Float64,y::Int64))::Float64))::Float64
    end::Float64))))

julia> @code_llvm 3 * 2.0 + 1

define double @"julia_+_3232"(double, i64) {
top:
  %2 = sitofp i64 %1 to double, !dbg !9747
  %3 = fadd double %2, %0, !dbg !9747
  ret double %3, !dbg !9747
}

julia> @code_native 3 * 2.0 + 1
        .text
Filename: promotion.jl
Source line: 158
        push    RBP
        mov     RBP, RSP
Source line: 158
        vcvtsi2sd       XMM1, XMM0, RDX
        vaddsd  XMM0, XMM1, XMM0
        pop     RBP
        ret

Setting up Julia environment in Windows

Installing Julia

The binary for installing Julia can be downloaded from: http://julialang.org/downloads/.
The installation will give us access to an interactive console session, known as REPL (read-eval-print-loop). The console is very similar to Matlab console where we can type any code in it and get the result right away. To get help on any function in Julia, press “?” and the function name. We can also execute shell command by typing “;” first followed by the shell command.

Untitled

Console replacement

The default Julia REPL console run on the standard Windows command prompt which lacks of features (like copying). There are several console alternatives that we can use. My favorite is ConEmu which can be downloaded from http://sourceforge.net/projects/conemu/.

Untitled

Code editor

There are several editor softwares which provide syntax highlighting for Julia code. Sublime Text (http://www.sublimetext.com/) is one of the most popular. Since Sublime Text isn’t really free, my choice goes to GitHub Atom (https://atom.io/). In both softwares we can install package for Julia syntax highlighting.

IDE

Juno http://junolab.org/ is the IDE that is recommended in Julia website. It support syntax highlighting, code completion, real-time feedback and variable browser. We can run the code step by step or choose some part of code to run and then get the feedback. The Matlab-like variable browser feature can also help us debugging the code.

Untitled

My preference

While Juno provides useful features for programmer, I personally prefer the REPL version since I use the console a lot for testing some function, exploring available functions and getting help. I usually type the code in Atom and then run in REPL console using include("file_name.jl") command. Here’s a screenshot of my Julia environment:

Untitled

Why I prefer Julia’s language design more than Matlab’s and R’s

Why I prefer Julia‘s language design more than Matlab’s and R’s

  1. Unlike Matlab, it uses [i] for array/vector/matrix indexing. | Matlab uses (i)
  2. Unlike R, it uses = as the assignment operator. |  R uses <-
  3. Unlike in R, . has a real meaning in Julia.
  4. Unlike in Matlab, we don’t need to put ; in the end of statement.  |  In Matlab, we have to put ; to suppress printing values.
  5. Unlike in R, matrix declaration is simple and convenient.
  6. Unlike in R, matrix operation is simpler in Julia.
  7. Unlike in Matlab, we can easily write inline function (without creating new file) in Julia
  8. Unlike Matlab and R, array values are passed by reference.
  9. Unlike Matlab and R, function arguments can be type-assigned.

As a programmer who has written code in a dozen programming languages, it’s good to have consistency across different languages. 1) , 2) , and 3) are mainly to get the consistency. I often made mistakes when writing R or Matlab code  because of the inconsistencies.

4) 5) and 6) are mainly for convenience. Consider these examples:

R :

A <- matrix(c(1,2,3,4,5,6,7,8,9), nrow=3, byrow = TRUE)
sol <- eigen(A)
AA <- sol$vec %*% diag(sol$val) %*% t(sol$vec)

Matlab :

A = [1, 2, 3; 4, 5, 6; 7, 8, 9];
[V, L] = eig(A);
AA = V * L * V';

Julia:

A = [1 2 3; 4 5 6; 7 8 9]
l, V = eig(A)
AA = V * diagm(l) * V'

Lastly, covering 7) 8) and 9), let’s write an example of function definition in Julia

distance(x::Number, y::Number) = abs(x - y)
distance(x::Vector, y::Vector) = sqrt( sum((x - y).^2) )
a = distance(1, 2)    # call distance(x::Number, y::Number) method
b = distance([1,2,3], [1,2,4])    # call distance(x::Vector, y::Vector) method
Source code R enak dipandang di LaTeX

Source code R enak dipandang di LaTeX

Agar source code R kita enak dipandang di LATEX, kita bisa gunakan package listings. Untuk mempercantik tampilan source codenya, kita perlu menentukan setting package nya. Berikut ini salah satu contoh setting nya:

\usepackage{listings}
\usepackage{color}    
\usepackage[T1]{fontenc}
\usepackage[scaled=0.9]{beramono}

\definecolor{dkgreen}{rgb}{0.3,0.53,0.42}
\definecolor{gray}{rgb}{0.5,0.5,0.5}
\definecolor{green}{rgb}{0.01,0.42,0.03}
\definecolor{blue}{rgb}{0.01,0.23,1}
\lstset{ %
  language=R,                 % choose the language of the code
  backgroundcolor=\color{white},  % choose the background color; you must add \usepackage{color} 
  basicstyle=\footnotesize\ttfamily,       % the size of the fonts that are used for the code
  breakatwhitespace=false,        % sets if automatic breaks should only happen at whitespace
  breaklines=true,                % sets automatic line breaking
  captionpos=b,                   % sets the caption-position to bottom
  commentstyle=\color{dkgreen},   % comment style
  deletekeywords={...},           % if you want to delete keywords from the given language
  escapeinside={\%*}{*)},         % if you want to add LaTeX within your code
  frame=single,                   % adds a frame around the code
  keywordstyle=\color{blue},      % keyword style  
  morekeywords={*,...},           % if you want to add more keywords to the set
  numbers=left,                   % where to put the line-numbers; possible values are (none, left, right)
  numbersep=5pt,                  % how far the line-numbers are from the code
  numberstyle=\tiny\color{gray},  % the style that is used for the line-numbers
  rulecolor=\color{black},        % if not set, the frame-color may be changed on line-breaks within not-black text (e.g. comments (green here))
  showspaces=false,               % show spaces everywhere adding particular underscores; it overrides 'showstringspaces'
  showstringspaces=false,         % underline spaces within strings only
  showtabs=false,                 % show tabs within strings adding particular underscores
  stepnumber=1,                   % the step between two line-numbers. If it's 1, each line will be numbered
  stringstyle=\color{green},      % string literal style
  tabsize=1,                      % sets default tabsize to 2 spaces
  title=\lstname,                 % show the filename of files included with \lstinputlisting; also try caption instead of title
  deletekeywords={t, new}			  % remove keywords 
}

Salah satu hasilnya bisa dilihat seperti berikut:

latex

Komputasi Statistik

Secara umum, permasalahan utama komputasi statistik dibagi menjadi dua, optimization dan integration; mewakili dua mazhab yang ada di ilmu statistik, frequentist dan bayesian.

1. Optimization untuk Frequentist Statistics

Permasalahan komputasi di frequentist statistics biasanya berupa pencarian estimasi parameter. Teknik esimasi yang paling banyak digunakan yaitu Maximum Likelihood Estimation (MLE), dimana parameter yang mempunyai nilai likelihood tertinggilah yang dipilih sebagai estimasi. Untuk model sederhana seperti Linear Regresion, solusi dari MLE dapat dihitung secara exact melalui manipulasi matrix (dikenal juga sebagai Least Square Estimation). Akan tetapi untuk sebagian besar model statistik, seperti Logistic Regression, Generalized Linear Models, ARIMA, dll; tidak ada metode eksak untuk mendapaiakan nilai parameter MLE.

Disinilah numerical optimization mengambil peranan. Algoritma-algoritma optimization memulai dengan perkiraan parameter, kemudian secara iterative memperbarui perkiraan itu berdasarkan teorama dari kalkulus bahwa parameter yang mempunyai nilai MLE maksimum, memiliki nilai derivative nol. Metode Newton dan turunannya yang mana memanfaatkan informasi second derivative adalah diantara algoritma yang paling banyak dipakai untuk optimization. Algoritma Quasi Newton – BFGS adalah salah satu turunan dari metode Newton yang paling populer, dimana alih-alih menggunakan nilai eksak second derivative, BFGS melakukan approksimasi terhadap nilai tersebut.

2. Integration untuk Bayesian Statistics

Di mahzab Bayesian Statistics, masalah komputasi utama adalah mencari summary (contohnya: rata-rata, varians, peluang event tertentu) dari posterior distribution dari parameter. Bayesian Statistics memperlakukan parameter sebagai continuous random variable, sehingga untuk mencari summary dari parameter diperlukan integration. Seringkali proses integration tidak dapat dilakukan secara eksak, sehingga diperlukan teknik lain. Metode numerical integration biasa seperti Riemann Sum juga tidak cocok diterapkan karena parameter biasanya berdimensi tinggi. Oleh karena itu, teknik Monte Carlo integration yang berdasarkan sampling algorithm menjadi pilihan. Algoritma yang sering dipakai untuk sampling diantaranya adalah Gibbs Sampling dan Metropolis-Hastings.

ref: Computational Statistics book by Givens and Hoeting