DIKTAT Machine Learning Rev Kaprodi 14 Maret 2021

DIKTAT
MACHINE LEARNING
UNIVERSITAS PUTERA BATAM

TAHUN 2021
Kode : Dikt.TIF.14
DIKTAT MACHINE LEARNING Tanggal : 09 Februari 2021
Revisi : 0
Tanggal Berlaku : 20 Maret 2021
DIKTAT MACHINE LEARNING
Proses Penanggung jawab Tanggal

Nama Jabatan Tanda tangan
1. Perumusan Andi Maslan, Kaprodi 9 Februari 2021
S.T., M.SI. Teknik
Informatika
2. Pemeriksaan Welly Sugianto, Dekan 11 Februari 2021
S.T., M.M. Fakultas
Teknik dan
Komputer
3. Persetujuan Dr. Yvonne Wakil Rektor 15 Februari 2021
Wangdra, B. Bidang
Com., M. Com Akademik
Universitas
Putera
Batam
4. Penetapan Dr. Nur Elfi Rektor 19 Februari 2021
Husda, S. Kom., Universitas
M.SI. Putera Batam
5. Pengendalian Dr. Realize, S. Ketua Pusat 25 Februari 2021

Kom., M.SI. Jaminan Mutu
Universitas
Putera
Batam
ii
DIKTAT
MACHINE LEARNING
TIM PENYUSUN:
Penanggung Jawab
Andi Maslan, S.T., M.SI.
Penyusun
Yuli Siyamto, S.Kom., M.Kom
Diterbitkan Oleh:
Universitas Putera Batam
iii
KATA PENGANTAR
Puji syukur kehadirat Allah SWT yang telah memberikan rahmat dan hidayah-Nya sehingga
diktat Machine Learning ini tepat pada waktunya. Adapun tujuan dari penulisan dari diktat
ini adalah untuk menyediakan bahan ajar bagi mahasiswa yang sesuai dengan RPS dan
untuk mendukung pencapaian CPL Prodi. Penulis mengucapkan terima kasih kepada semua
pihak yang telah membagi sebagian pengetahuannya sehingga diktat ini dapat diselesaikan
dengan baik dan tepat waktu. Penulis menyadari, bahwa diktat ini masih jauh dari kata
sempurna. Oleh karena itu, mohon kritik dan saran yang membangun demi kesempurnaan
diktat ini.
Batam, Februari 2021
Penyusun
iv
DESKRIPSI MATA KULIAH
Mata Kuliah Machine Learning melatih mahasiswa untuk menjelaskan ide dasar,
intuisi, konsep, algoritma, kemudian mengkode, mendemostrasikan, menguji serta
menguji berbagai teknik Machine Learning untuk membuat komputer menjadi lebih
cerdas melalui proses learning dari data.
v
DAFTAR ISI
Halaman
HALAMAN SAMPUL ...................................... ERROR! BOOKMARK NOT DEFINED.
LEMBAR PENGESAHAN .................................................................................... II
KATA PENGANTAR .......................................................................................... IV
DESKRIPSI MATA KULIAH ................................................................................. V
DAFTAR ISI...................................................................................................... VI
DAFTAR TABEL .............................................................................................. VIII
DAFTAR GAMBAR ........................................................................................... IX
BAB I SKALABILITAS MACHINE LEARNING ...................................................... 10
1.1 DEFINISI MACHINE LEARNING................................................................... 10
1.2 KLASIFIKASI MACHINE LEARNING ............................................................. 12
BAB II SCALE UP WITH PYTHON ..................................................................... 18
2.1 INTRODUCING PYTHON............................................................................. 18
2.2 SCALE UP WITH PYTHON ........................................................................... 20
BAB III PERSIAPAN DATA MACHINE LEARNING .............................................. 37
3.1 PENDAHULUAN ......................................................................................... 37
3.2 BERBAGI KUMPULAN DATA ...................................................................... 45
3.3 MENGGUNAKAN I/O PANDA..................................................................... 47
BAB IV FAST-LEARNING SVMS PYTHON ......................................................... 53
4.1 FAST-LEARNING SVMS............................................................................... 53
4.2 DATA COLLECTION..................................................................................... 54
4.3 MESIN VEKTOR .......................................................................................... 56
BAB V ARTIFICIAL NEURAL NETWORK............................................................ 64
5.1 PENDAHULUAN ARTIFICIAL NEURAL NETWORK ....................................... 64
5.2 FORWARD PROPAGATION ........................................................................ 65
5.3 BACKPROPAGATION .................................................................................. 67
BAB VI DEEP LEARNING ................................................................................. 72
6.1 DEEP LEARNING DENGAN H2O ................................................................. 72
6.2 DEEP LEARNING WITH THEANETS ............................................................. 76
BAB VII TENSOR FLOW .................................................................................. 80
vi
7.1 METODE TENSORFLOW ............................................................................. 80
7.2 PENGINSTALAN TENSORFLOW .................................................................. 81
BAB VIII KLASIFIKASI DAN REGRESI POHON ................................................... 88
8.1 PENDAHULUAN KLASIFIKASI DAN REGRESI .............................................. 88
8.2 BOOTSTRAP ............................................................................................... 90
8.3 XGBOOST ................................................................................................... 92
BAB IX UNSUPERVISED LEARNING .............................................................. 101
9.1 UNSUPERVISED LEARNING ...................................................................... 101
9.2 PCA .......................................................................................................... 102
BAB X K-MEANS ......................................................................................... 108
10.1 K-MEANS ................................................................................................. 108
10.2 PEMILIHAN K ........................................................................................... 114
BAB XI HADOOP ......................................................................................... 116
11.1 A BUNCH OF NODES ................................................................................ 116
11.2 VIRTUAL BOX ........................................................................................... 118
11.3 VAGRANT................................................................................................. 119
11.4 MENGGUNAKAN VM ............................................................................... 120
11.5 THE HADOOP ECOSYSTEM ...................................................................... 121
BAB XII MACHINE LEARNING WITH SPARK................................................... 127
12.1 MACHINE LEARNING WITH SPARK .......................................................... 127
12.2 DATA PREPROCESSING ............................................................................ 130
12.3 FILE JSON DAN SPARK DATAFRAMES ...................................................... 131
vii
DAFTAR TABEL
Halaman
Tabel 1 Model Klasifikasi ....................................................................................... 40

Tabel 2.Confusion Matrix ...................................................................................... 41
Tabel 3.UCI Machine Learning Repository ............................................................ 43
viii
DAFTAR GAMBAR
Halaman
Gambar 1 Konseb Machine Learning ................................................................... 12

Gambar 2 Klasifikasi Machine Learning ............................................................... 13
Gambar 3 Python 3................................................................................................ 19
Gambar 4 Jupyter Notebook ................................................................................. 27
Gambar 5. Precision .............................................................................................. 42
Gambar 6. Precision 2 ........................................................................................... 42
Gambar 7. Forward propagation .......................................................................... 66
Gambar 8. H2O ...................................................................................................... 72
Gambar 9. Neural network model ......................................................................... 76
Gambar 10. Tensorflow ......................................................................................... 81
Gambar 11. Pohon keputusan .............................................................................. 90
Gambar 12. Bootstrap ........................................................................................... 90
Gambar 13. XGBoost ............................................................................................. 93
Gambar 14. PCA .................................................................................................. 104
Gambar 15. Virtual Box ....................................................................................... 119
Gambar 16. Vagrant............................................................................................ 120
Gambar 17.Hadoop ............................................................................................. 122
Gambar 18. YARN dan MapReduce..................................................................... 122
Gambar 19. Spark ................................................................................................ 128
ix
BAB I
SKALABILITAS MACHINE LEARNING
CAPAIAN PEMBELAJARAN
- Mahasiswa mampu menjelaskan tentang skalabilitas Machine Learning.

- Mahasiswa mampu mendemostrasikan instalasi Python 3 untuk pembelajaran Machine
Learning.
- Mahasiswa mampu mengklasifikasikan dan mengkode dengan algoritma Machine
Learning dengan bahasa pemrograman Python.
- Mahasiswa mampu mempraktekkan algoritma-algoritma Machine Learning pada Jupyter
Notebook.
- Mahasiswa mampu menguji algoritma-algoritma Machine Learning pada Jupyter
Notebook.
MATERI
1.1 Definisi Machine Learning
Selama beberapa tahun terakhir, pembelajaran mesin telah tertanam di berbagai

jenis bisnis sehari-hari, nonprofit, dan operasi pemerintah. Seperti popularitas Pembelajaran
mesin meningkat, industri rumahan dari literatur berkualitas tinggi yang diajarkan
pembelajaran mesin terapan untuk praktisi dikembangkan. Literatur ini sangat tinggi
berhasil melatih seluruh generasi ilmuwan data dan pembelajaran mesin insinyur. Literatur
ini juga mendekati topik pembelajaran mesin dari perspektif menyediakan sumber belajar
untuk mengajari seseorang mesin. Belajar itu dan bagaimana cara kerjanya. Namun, meski
berhasil, pendekatan ini meninggalkan perbedaan-perspektif ent tentang topik: hal-hal
mendasar dalam melakukan pembelajaran mesin dari hari ke hari. Sebagai kumpulan
pengetahuan Machine Learning tetapi sebagai kunci untuk profesional, untuk duduk dengan
siap memecahkan masalah sehari-hari praktis dari praktik pembelajaran mesin. Suatu
10
program komputer dikatakan belajar dari pengalaman yang berhubungan dengan beberapa
tugas dan ukuran performansi jika performansinya pada tugas-tugas, sebagaimana diukur
menggunakan, meningkat dengan pengalaman.
Machine Learning adalah aplikasi dari disiplin ilmu kecerdasan buatan (Artificial
Intelligence) yang menggunakan teknik statistika untuk menghasilkan suatu model otomatis
dari sekumpulan data, dengan tujuan memberikan komputer kemampuan untuk "belajar".
Pembelajaran mesin atau Machine Learning memungkinkan komputer mempelajari
sejumlah data (learn from data) sehingga dapat menghasilkan suatu model untuk
melakukan proses input-output tanpa menggunakan kode program yang dibuat secara
eksplisit. Proses belajar tersebut menggunakan algoritma khusus yang disebut Machine
Learning algorithms. Terdapat banyak algoritma Machine Learning dengan efisiensi dan
spesifikasi kasus yang berbeda-beda. Machine learning, yaitu teknik untuk melakukan
inferensi terhadap data dengan pendekatan matematis. Inti Machine Learning adalah untuk
membuat model (matematis) yang merefleksikan pola-pola data.
Mesin = komputer, program computer. Belajar meningkatkan kinerja pada tugas
yang diberikan, berdasarkan pengalaman atau contoh. Alih-alih programmer menulis aturan
eksplisit tentang bagaimana memecahkan masalah yang diberikan, programmer
menginstruksikan komputer bagaimana belajar dari contoh. Dalam banyak kasus, program
komputer bahkan bisa menjadi lebih baik dalam tugas dari pada programmer.
11
Gambar 1 Konseb Machine Learning
- Era Sebelum 1980: hampir semua metode learning melakukan pembelajaran untuk
menghasilkan linear decision surfaces. Metode-metode pembelajaran linier ini sudah
memiliki pijakan teori yang kuat.
- Era 1980-an: Decision trees dan ANN menjadi pelopor dalam pembelajaran non linear.
Namun, pijakan teorinya masih lemah. Kedua metode juga sering terjebak pada
optimum lokal.
- Era 1990 sampai sekarang: telah dikembangkan metode-metode learning non linear
yang efisien berbasis computational learning theory. Metode-metode pembelajaran non
linear ini memiliki pijakan teori yang sudah mapan.
1.2 Klasifikasi Machine Learning
Klasifikasi Machine Learning berdasarkan apa yang diharapkan :

1) Pembelajaran Terarah (Supervised Learning)
2) Pembelajaran Tak Terarah (Unsupervised Learning)
3) Pembelajaran Semi Terarah (Semi-supervised Learning)
4) Reinforcement Learning
12
5) Transduction
6) Learning to learn
Klasifikasi Machine Learning berdasarkan input dan outputnya :
1) diskrit
2) kontineu
Klasifikasi Machine Learning berdasarkan cara kerjanya :

1) offline
2) online
Klasifikasi Machine Learning berdasarkan kemudahan interpretasi dan metode inferensinya :

1) induktif
2) deduktif
Gambar 2 Klasifikasi Machine Learning
Merupakan metode yang berusaha menemukan fungsi-fungsi pendekatan yang

bernilai diskrit. Banyak digunakan dalam data mining untuk klasifikasi. Dua fase
learning/pembelajaran dan pengujian. Decicion tree learning adalah suatu metode belajar
yang sangat populer dan banyak digunakan secara praktis. Metode ini merupakan
metode yang berusaha menemukan fungsi-fungsi pendekatan yang bernilai diskrit dan
13
tahan terhadap data-data yang terdapat kesalahan (noise data) serta mampu
mempelajari ekspresi-ekspresi disjungtive. Iterative Dichotomiser3 (ID3), Assistant dan
C4.5 merupakan jenis dari decision tree learning. Dalam membangun decision tree
learning dibutuhkan evaluasi semua atribut yang ada menggunakan suatu
ukuran statistik untuk mengukur efektifitas suatu atribut dalam mengklasifikasikan
kumpulan sampel data.
Bahkan jika sekarang adalah tentang data besar, kumpulan data besar sudah ada
jauh sebelum istilah itu sendiri diciptakan. Koleksi besar teks, urutan DNA, dan sejumlah
besar data dari teleskop radio selalu menjadi tantangan bagi para ilmuwan dan analis data.
Karena sebagian besar algoritma pembelajaran mesin memiliki kompleksitas komputasi O
(n2) atau bahkan O (n3), di mana n adalah jumlah instans pelatihan, tantangan dari
kumpulan data masif sebelumnya telah dihadapi oleh ilmuwan data dan analis dengan
menggunakan algoritma data yang bisa lebih efisien. Algoritma pembelajaran mesin
dianggap dapat diskalakan jika dapat berfungsi setelah penyiapan yang sesuai, dalam kasus
kumpulan data yang besar. Set data bisa menjadi besar karena banyaknya kasus atau
variabel, atau karena keduanya, tetapi algoritma yang dapat diskalakan dapat
menanganinya dengan cara yang efisien karena waktu berjalannya meningkat hampir secara
linier sesuai dengan ukurannya dari masalah tersebut. Oleh karena itu, ini hanya masalah
menukar waktu 1: 1 lebih banyak (atau lebih banyak daya komputasi) dengan lebih banyak
data. Sebaliknya, algoritma pembelajaran mesin tidak berskala jika dihadapkan dengan data
dalam jumlah besar, ia hanya berhenti bekerja atau beroperasi dengan waktu berjalan yang
meningkat secara non linear, misalnya, secara eksponensial, sehingga membuat
pembelajaran menjadi tidak mungkin. Pengenalan penyimpanan data murah, RAM yang
besar, dan CPU multiprosesor secara dramatis mengubah segalanya, meningkatkan
kemampuan laptop tunggal untuk menganalisis data dalam jumlah besar.
Pengubah permainan besar lainnya muncul di panggung dalam beberapa tahun
terakhir, mengalihkan perhatian dari satu mesin yang kuat ke kelompok komputer
komoditas (mesin yang lebih murah dan mudah tersedia). Perubahan besar ini adalah
pengenalan Map Reduce dan kerangka kerja open source Apache Hadoop dengan
Hadoop Distributed File System (HDFS) dan secara umum, komputasi paralel pada jaringan
komputer. Untuk mengetahui bagaimana kedua perubahan ini secara mendalam dan positif
14
mempengaruhi kemampuan dalam memecahkan masalah skala besar, pertama-tama harus
mulai dari apa yang sebenarnya mencegah (dan masih mencegahnya, tergantung pada
seberapa besar masalah) dalam menganalisis kumpulan data besar. Tidak peduli apa
masalahnya, pada akhirnya akan menyadari bahwa manusia tidak bisa menganalisis data
karena salah satu dari batasan berikut:
1) Komputasi mempengaruhi waktu yang dibutuhkan untuk mengeksekusi analisis
2) I / O memengaruhi seberapa banyak data yang dapat ambil dari penyimpanan ke
memori dalam satuan waktu
3) Memori mempengaruhi seberapa besar data yang dapat proses dalam satu waktu.
Akhirnya, itu tergantung pada algoritma yang akan digunakan untuk belajar dari
data. Setiap algoritma memiliki karakteristiknya sendiri, mampu memetakan data
menggunakan solusi yang dipengaruhi oleh bias atau varians yang berbeda. Oleh karena itu,
sehubungan dengan masalah yang, sejauh ini, maka selesaikan dengan pembelajaran mesin.
Berdasarkan pengalaman atau pengujian empiris, bahwa algoritma tertentu mungkin
bekerja lebih baik daripada yang lain. Dengan masalah skala besar, maka harus
menambahkan pertimbangan lain dan berbeda saat memutuskan algoritma:
1) Betapa rumitnya algoritma; yaitu, jika jumlah baris dan kolom dalam data
memengaruhi jumlah komputasi secara linier atau non linear. Sebagian besar solusi
pembelajaran mesin didasarkan pada algoritma kompleksitas kuadrat atau kubik,
sehingga sangat membatasi penerapannya pada data besar.
2) Berapa banyak parameter yang dimiliki model; di sini, ini bukan hanya masalah
varians dari perkiraan (overfitting), tetapi waktu yang diperlukan untuk menghitung
semuanya.
3) Jika proses pengoptimalan dapat diparalelkan; yaitu, dapatkah dengan mudah
membagi komputasi ke beberapa node atau inti CPU, atau apakah harus bergantung
pada satu proses pengoptimalan yang berurutan?
4) Haruskah algoritma belajar dari semua data sekaligus atau bisa gunakan tunggal
contoh atau kumpulan data kecil?
15
RANGKUMAN
Machine Learning adalah aplikasi dari disiplin ilmu kecerdasan buatan (Artificial Intelligence)
yang menggunakan teknik statistika untuk menghasilkan suatu model otomatis dari
sekumpulan data, dengan tujuan memberikan komputer kemampuan untuk "belajar".
Pembelajaran mesin atau Machine Learning memungkinkan komputer mempelajari
sejumlah data (learn from data) sehingga dapat menghasilkan suatu model untuk
melakukan proses input-output tanpa menggunakan kode program yang dibuat secara
eksplisit.
Proses belajar tersebut menggunakan algoritma khusus yang disebut Machine Learning
algorithms. Terdapat banyak algoritma Machine Learning dengan efisiensi dan spesifikasi
kasus yang berbeda-beda. Machine learning, yaitu teknik untuk melakukan inferensi
terhadap data dengan pendekatan matematis. Inti Machine Learning adalah untuk
membuat model (matematis) yang merefleksikan pola-pola data.
DAFTAR PUSTAKA
1. Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca Massaron,
Alberto Boschetti. ISBN 978-1-78588-721-5
2. Machine Learning Tingkat Dasar dan Lanjut, 2018. Suyanto, Informatika Bandung
3. Pengenalan Konsep Pembelajaran Mesin dan Deep Learning, 2020. Jan Wira Gotama
Putra
4. Machine Learning with Python Cookbook, 2018. Chris Albon
16
LATIHAN
1. Jelaskan tentang skalabilitas Machine Learning

2. Lakukan proses Install Anaconda versi terbaru di laptop anda!
3. Sebutkan dan jelaskan klasifikasi algoritma pada Machine Learning
4. Buatlah beberapa koding sederhana di Jupyter Notebook dan anda dapat juga
membuka file - file pembelajaran Python di semester 1!
17
BAB II
SCALE UP WITH PYTHON
- Mahasiswa mampu menjelaskan tentang software pendukung pembelajaran Machine

Learning dengan Python.
- Mahasiswa mampu menunjukkan software pendukung pembelajaran Machine Learning
dengan Python.
- Mahasiswa mampu mendemostrasikan software pendukung pembelajaran Machine
- Mahasiswa mampu mempraktekkan software pendukung pembelajaran Machine
MATERI
2.1 Introducing Python
Dibuat pada tahun 1991 sebagai bahasa tujuan umum, ditafsirkan, berorientasi
objek, Python perlahan dan mantap menaklukkan komunitas ilmiah dan tumbuh menjadi
ekosistem yang matang dari paket khusus untuk pemrosesan dan analisis data. Ini
memungkinkan untuk memiliki eksperimen yang tak terhitung dan cepat, pengembangan
teori yang mudah, dan penerapan aplikasi ilmiah yang cepat.
18
Gambar 3 Python 3
Sebagai praktisi pembelajaran mesin, tertarik menggunakan Python berbagai alasan:

1) Menawarkan sistem paket yang besar dan matang untuk analisis data dan
pembelajaran mesin. Ini menjamin bahwa akan mendapatkan semua yang
dibutuhkan selama analisis data, dan terkadang bahkan lebih. Ini sangat serbaguna.
Tidak peduli apa latar belakang atau gaya pemrograman.
2) Berorientasi objek atau prosedural, akan menikmati pemrograman dengan Python.
3) Jika belum mengetahuinya tetapi menguasai bahasa lain seperti C / C ++ atau Java
dengan baik, maka ini sangat mudah dipelajari dan digunakan. Setelah memahami
dasar-dasarnya, tidak ada cara lain yang lebih baik untuk belajar lebih banyak selain
langsung memulai dengan pengkodean.
4) Ini lintas platform; Solusinya akan bekerja dengan sempurna dan lancar di sistem
Windows, Linux, dan macOS. Tidak perlu khawatir tentang portabilitas.
5) Meskipun ditafsirkan, tidak diragukan lagi ini cepat dibandingkan dengan bahasa
analisis data utama lainnya seperti R dan MATLAB (meskipun tidak sebanding
dengan C, Java, dan bahasa yang baru muncul).
6) Dapat bekerja dengan data besar dalam memori karena jejak memori minimal dan
manajemen memori yang sangat baik. Pengumpul sampah memori akan sering
menghemat ketika memuat, mengubah, memotong, memotong, menyimpan, atau
membuang data menggunakan berbagai iterasi dan pengulangan perselisihan data.
19
2.2 Scale up With Python
Python adalah bahasa yang ditafsirkan; itu menjalankan pembacaan skrip dari
memori dan mengeksekusinya selama runtime, sehingga mengakses sumber daya yang
diperlukan (file, objek dalam memori, dan sebagainya). Selain ditafsirkan, aspek penting
lainnya yang perlu dipertimbangkan saat menggunakan Python untuk analisis data dan
pembelajaran mesin adalah bahwa Python adalah single-threaded. Menjadi single-threaded
berarti bahwa program Python apa pun dijalankan secara berurutan dari awal hingga akhir
skrip dan Python tidak dapat memanfaatkan kekuatan pemrosesan ekstra yang ditawarkan
oleh beberapa prosesor yang mungkin ada di komputer (sebagian besar komputer saat ini
multi-core). Mengingat situasi seperti itu, peningkatan skala menggunakan Python dapat
dicapai dengan strategi yang berbeda:
1) Mengompilasi skrip Python untuk mencapai kecepatan eksekusi yang lebih tinggi.
Pemikiran yang dengan mudah dapat digunakan, misalnya, PyPy - kompiler Just-in-
Time (JIT) yang dapat ditemukan di http://pypy.org/, benar-benar menggunakan
solusi seperti itu karena memerlukan menulis algoritma dengan Python dari awal.
2) Menggunakan Python sebagai bahasa pembungkus; Jadi menyusun operasi yang
dijalankan oleh Python dengan eksekusi pustaka dan program eksternal, beberapa
mampu memproses banyak inti. Akan menemukan banyak contoh saat memanggil
perpustakaan khusus seperti Library for Support Vector Machines (LIBSVM) atau
program seperti Vowpal Wabbit (VW), XGBoost, atau H2O untuk menjalankan
aktivitas pembelajaran mesin.
3) Secara efektif menggunakan teknik vektorisasi, yaitu pustaka khusus untuk
perhitungan matriks. Ini dapat dicapai dengan menggunakan NumPy atau p s,
keduanya menggunakan komputasi dari GPU. GPU sama seperti CPU multicore,
masing-masing dengan memori dan kemampuannya sendiri untuk memproses
penghitungan secara paralel (Yang dapat mengetahui bahwa mereka memiliki
beberapa inti kecil). Terutama saat bekerja dengan jaringan neural, teknik vektorisasi
berdasarkan GPU dapat mempercepat komputasi secara luar biasa. Namun, GPU
memiliki batasannya sendiri.
20
4) Dari semua, memori mereka yang tersedia memiliki I / O tertentu dalam meneruskan
data ke memori mereka dan mendapatkan hasilnya kembali ke CPU, dan mereka
memerlukan pemrograman paralel melalui API khusus, seperti CUDA untuk GPU
yang diproduksi NVIDIA (jadi memiliki untuk menginstal driver dan program yang
sesuai).
5) Mengurangi masalah besar menjadi beberapa bagian dan menyelesaikan setiap
bagian satu per satu di memori. Ini mengarah ke partisi atau sub sampling data dari
memori atau disk dan mengelola perkiraan solusi masalah pembelajaran mesin, yang
cukup efektif. Penting untuk diperhatikan bahwa partisi dan subsampling dapat
beroperasi untuk kasus dan fitur (dan keduanya). Jika data asli disimpan di
penyimpanan disk, Kendala I / O akan menjadi faktor penentu performa yang
dihasilkan.
6) Memanfaatkan multiprosesing dan multithreading secara efektif, bergantung pada
algoritma pembelajaran yang akan digunakan. Beberapa algoritma secara alami akan
dapat membagi operasinya menjadi yang paralel. Dalam kasus seperti itu, satu-
satunya batasan adalah CPU dan memori (karena data harus direplikasi untuk setiap
pekerja paralel yang akan digunakan). Beberapa algoritma lain justru akan
memanfaatkan multithreading, sehingga mengelola lebih banyak operasi pada waktu
yang sama pada blok memori yang sama.
Sebelum memulai, penting untuk mengetahui bahwa ada dua cabang utama Python: versi 2
dan 3. Karena banyak fungsi inti telah berubah, skrip yang dibuat untuk satu versi terkadang
tidak kompatibel dengan versi lainnya (tidak akan berfungsi tanpa menimbulkan kesalahan
dan peringatan). Meskipun versi ketiga adalah yang terbaru, versi yang lebih lama masih
merupakan versi yang paling banyak digunakan di bidang ilmiah dan versi default untuk
banyak sistem operasi (terutama untuk kompatibilitas dalam peningkatan). Ketika versi 3
dirilis (pada 2008), sebagian besar paket ilmiah belum siap sehingga komunitas ilmiah tetap
menggunakan versi sebelumnya. Untungnya, sejak itu, hampir semua paket telah diperbarui
dan hanya menyisakan sedikit (lihat http://py3readiness.org untuk tinjauan kompatibilitas)
sebagai kompatibilitas Python 3.
21
Terlepas dari pertumbuhan popularitas Python 3 baru-baru ini (yang, tidak boleh
dilupakan, adalah masa depan Python), Python 2 masih banyak digunakan di kalangan
ilmuwan data dan analis data. Selain itu, untuk waktu yang lama Python 2 telah menjadi
instalasi Python default (misalnya, di Ubuntu), jadi ini adalah versi yang paling mungkin
dimiliki oleh sebagian besar pengguna. Untuk semua alasan ini, akan mengadopsi Python 2.
Ini bukan hanya cinta untuk teknologi lama, itu hanya pilihan praktis untuk membuat
Machine Learning Skala Besar dengan Python dapat diakses oleh audiens terbesar. Untuk
mengonversi skrip bekerja di bawah versi Python karena kode yang ditulis mudah dikonversi
dan dapat diunduh secara gratis. Jika belum pernah menggunakan, maka harus mengunduh
penginstal terlebih dahulu dari situs https://www.Python.org / downloads dan instal di
komputer lokal. Menjadi bahasa pemrograman multiplatform, penginstal untuk komputer
yang berjalan pada sistem operasi mirip Windows atau Linux- / Unix. Ingatlah bahwa
beberapa distribusi Linux (seperti Ubuntu) sudah memiliki Python 2 yang dikemas dalam
repositori, yang membuat proses instalasi menjadi lebih mudah.
1) Buka shell Python, ketik Python di terminal, atau klik ikon Python.
2) Kemudian, untuk menguji penginstalan, jalankan kode berikut di shell interaktif
Python atau antarmuka Read-Eval-Print Loop (REPL) yang disediakan oleh IDE st r
Python atau solusi lain seperti Spyder atau PyCharm:
>>> impor sys
>>> print sys.version
Jika kesalahan sintaks muncul, itu berarti menjalankan Python 2, bukan Python 3.
Jika tidak mengalami kesalahan dan dapat membaca bahwa versi Python adalah 3.4.x atau
3.5.x. Untuk memperjelas, ketika sebuah perintah diberikan di baris perintah terminal, maka
memberi awalan perintah dengan $. Sebaliknya, jika itu untuk REPL Python, itu diawali
dengan >>>. Untuk menginstal paket apa pun yang dibutuhkan, dapat menggunakan
perintah pip atau easy_install. Namun, easy_install akan dihentikan di masa mendatang dan
pip memiliki keunggulan penting di atasnya. Pip adalah alat untuk menginstal paket Python
yang mengakses Internet secara langsung dan mengambilnya dari Indeks Paket Python
(https://pypi.Python.org/pypi). PyPI adalah repositori yang berisi paket open source pihak
22
ketiga, yang terus-menerus dipelihara dan disimpan dalam repositori oleh pembuatnya.
Lebih disukai menginstal semuanya menggunakan pip karena alasan berikut:
1) Ini adalah paket yang disukai untuk Python dan dimulai dengan Python 2.7.9 dan
Python 3.4, ini disertakan secara default dengan installer biner Python
2) Ini menyediakan fungsionalitas uninstall
3) Ini memutar kembali dan membiarkan sistem bersih jika, karena alasan apa pun,
instalasi paket gagal
Perintah pip berjalan di baris perintah dan mempermudah proses instalasi, peningkatan,
dan penghapusan paket Python. Menjalankan setidaknya Python 2.7.9 atau Python 3.4,
perintah pip seharusnya sudah ada. Untuk memastikan alat mana yang telah diinstal pada
mesin lokal, uji langsung dengan perintah berikut jika ada kesalahan yang muncul:
$ pip –V
Di beberapa instalasi Linux dan Mac, Python 3 dan bukan Python 2 yang diinstal, perintahnya
mungkin ada sebagai pip 3, jadi jika menerima kesalahan saat mencari pip , coba jalankan
perintah berikut:
$ pip 3 –V
Jika demikian, ingatlah bahwa pip 3 hanya cocok untuk menginstal paket pada Python 3.
Saat bekerja dengan Python 2 (kecuali menggunakan Python 3.4 terbaru), pip harus selalu
menjadi pilihan untuk menginstal paket. Sebagai alternatif, dapat menguji apakah perintah
easy_install lama tersedia:
$ easy_install –version
Jika pengujian ada kesalahan, maka perlu menginstal pip dari awal (dan dalam
melakukannya, juga easy_install pada saat yang sama). Untuk menginstal pip , cukup ikuti
instruksi yang diberikan di https://pip .pypa.io/en/ stable / installation /. Cara teraman
adalah mengunduh skrip get-pip .py dari https://bootstrap.pypa.io/get-pip .py dan
kemudian menjalankannya menggunakan yang berikut ini:
23
$ Python get-pip .py
Skrip juga akan menginstal alat penyiapan dari https: //pypi.Python. org / pypi / setuptools,
yang berisi easy_install. Sebagai alternatif, jika menjalankan sistem mirip Debian / Ubuntu
Unix, maka pintasan cepatnya adalah menginstal semuanya menggunakan apt-get:
$ sudo apt-get install Python3-pip
Setelah memeriksa persyaratan dasar ini, sekarang siap untuk menginstal semua paket yang
diperlukan untuk menjalankan contoh yang diberikan. Untuk menginstal generic <pk>,
hanya perlu menjalankan perintah berikut:
$ pip instal <pk>
Sebagai alternatif, jika lebih suka menggunakan easy_install, juga dapat menjalankan
perintah berikut:
$ easy_install <pk>
Setelah ini, paket <pk> dan semua dependensinya akan diunduh dan diinstal. Jika tidak yakin
apakah perpustakaan telah diinstal atau belum, coba impor modul di dalamnya. Jika
interpreter Python memunculkan kesalahan ImportError, dapat disimpulkan bahwa paket
tersebut belum diinstal. Mari ambil contoh. Inilah yang terjadi ketika perpustakaan NumPy
telah ada terpasang:
>>> impor numpy
Inilah yang terjadi jika tidak dipasang:
>>> impor numpy
Traceback (panggilan terakhir terakhir):
File "<stdin>", baris 1, di <module> ImportError: Tidak ada modul bernama numpy
24
Dalam kasus terakhir, sebelum mengimpornya, harus menginstalnya melalui pip
atau easy_install. Berhati-hatilah agar tidak membingungkan paket dengan modul. Dengan
pip , menginstal sebuah paket; dengan Python, perlu mengimpor modul. Terkadang, paket
dan modul memiliki nama yang sama, tetapi dalam banyak kasus, keduanya tidak cocok.
Misalnya, modul sklearn disertakan dalam paket bernama Scikit-learn. Paket pertama yang
disarankan untuk coba adalah Anaconda ( https: // www. Continuum.io/downloads ), yang
merupakan distribusi Python yang ditawarkan oleh Continuum Analytics yang mencakup
hampir 200 paket, termasuk NumPy, SciPy, pandas, IPython, matplotlib, Scikit-learn, dan
StatsModels. Ini adalah distribusi lintas platform yang dapat diinstal pada mesin dengan
distribusi dan versi Python lain yang ada, dan versi dasarnya gratis. Pengaya tambahan yang
berisi fitur-fitur canggih dikenakan biaya secara terpisah. Anaconda memperkenalkan conda
, pengelola paket biner, sebagai alat baris perintah untuk mengelola penginstalan paket.
Seperti yang dinyatakan di situsnya, tujuan Anaconda adalah menyediakan

distribusi Python yang siap untuk perusahaan untuk pemrosesan skala besar, analitik
prediktif, dan komputasi ilmiah. Sebagai saran kedua, jika bekerja di Windows dan
menginginkan distribusi portabel, WinPython ( http://winPython.sourceforge.net/ ) bisa
menjadi alternatif yang cukup menarik (tidak ada versi Linux atau MacOS). WinPython juga
merupakan distribusi Python open source gratis yang dikelola oleh komunitas. Ini juga
dirancang dengan mempertimbangkan para ilmuwan, dan itu mencakup banyak paket
penting seperti NumPy, SciPy, matplotlib, dan IPython (pada dasarnya sama dengan
Anaconda). Ini juga menyertakan Spyder sebagai IDE, yang dapat berguna jika memiliki
pengalaman menggunakan bahasa dan antarmuka MATLAB.
IPython dimulai pada tahun 2001 sebagai proyek gratis oleh Fernando Perez,
mengatasi kekurangan tumpukan Python untuk penyelidikan ilmiah menggunakan
antarmuka pemrograman pengguna yang dapat menggabungkan pendekatan ilmiah
(terutama bereksperimen dan menemukan secara interaktif) dalam proses pengembangan
perangkat lunak. Jupyter (IPython adalah kernel nol, yang asli awal) dapat secara sederhana
digambarkan sebagai alat untuk tugas-tugas interaktif yang dapat dioperasikan oleh konsol
atau notebook berbasis web, yang menawarkan perintah khusus yang membantu
25
pengembang lebih memahami dan membangun kode yang sedang tertulis. Berlawanan
dengan IDE, yang dibangun di ser gagasan menulis skrip, menjalankannya setelahnya dan
mengevaluasi hasilnya. Jupyter memungkinkan menulis kode dalam potongan bernama sel ,
menjalankan masing-masing secara berurutan, dan mengevaluasi hasil masing-masing satu
secara terpisah, memeriksa keluaran tekstual dan grafis. Selain integrasi grafis, ini memberi
bantuan lebih lanjut, berkat perintah yang dapat disesuaikan, (dalam format JSON), dan
paralelisme komputasi untuk peningkatan kinerja saat menangani komputasi numerik yang
berat .
Pendekatan semacam itu juga sangat bermanfaat untuk tugas-tugas yang melibatkan
pengembangan kode berdasarkan data karena secara otomatis menyelesaikan tugas yang
sering diabaikan untuk mendokumentasikan dan menggambarkan bagaimana analisis data
telah dilakukan, premis dan asumsinya, serta hasil antara dan akhirnya. Jika bagian dari
pekerjaan juga mempresentasikan atau eksternal untuk proyek tersebut, Jupyter benar-
benar dapat melakukan keajaiban dengan sedikit upaya tambahan. Ada banyak contoh di
https://github.com/iPython/iPython/wiki/A-gallery-of-exciting-IPython-Notebooks.Beberapa
di antaranya mungkin menginspirasi pekerjaan. Jupyter menawarkan fitur-fitur berikut:
1) Melihat hasil menengah (debugging) untuk setiap langkah analisis
2) Menjalankan hanya beberapa bagian (atau sel) kode
3) Menyimpan hasil antara dalam format JSON dan memiliki kemampuan untuk
melakukan kontrol versi padanya
4) Mempresentasikan karya (ini akan menjadi kombinasi teks, kode, dan gambar),
membagikannya melalui layanan Jupyter Notebook Viewer ( http: // nbviewer.
Jupyter.org/ ), dan mengekspornya dengan mudah ke HTML, PDF, atau bahkan
tayangan slide
Jupyter adalah pilihan favorit dan digunakan untuk menggambarkan operasi secara jelas dan
efektif dengan skrip dan data serta hasil konsekuensinya. Setelah instance Jupyter dibuka di
browser, klik tombol New , dan di bagian Notebooks, pilih Python 3 :
26
Gambar 4 Jupyter Notebook
Misalnya, mulai mengetik yang berikut di dalam sel:

In: print ("This is a test")
Setelah menulis di sel, cukup menekan tombol putar (di bawah tab Sel ) untuk
menjalankannya dan mendapatkan keluaran. Kemudian, sel lain akan muncul untuk
masukan. Saat menulis di dalam sel, jika menekan tombol plus pada bilah menu di atas,
akan mendapatkan sel baru, dan dapat berpindah dari sel ke sel lain menggunakan panah
pada menu. Sebagian besar fungsi lainnya cukup intuitif dan mengundang untuk
mencobanya. Untuk mengetahui lebih baik cara kerja Jupyter, dapat menggunakan
panduan memulai cepat seperti http://jupyter-notebook-beginner-
guide.readthedocs.io/en/latest/ .Paket-paket yang akan diperkenalkan jika tidak
menggunakan distribusi ilmiah, menawarkan panduan tentang versi apa yang harus
putuskan dan cara menginstalnya dengan cepat dan berhasil.
NumPy, yang merupakan kreasi Travis Oliphant, merupakan inti dari setiap solusi
analitik dalam bahasa Python. Ini menyediakan pengguna dengan array multidimensi
bersama dengan sekumpulan besar fungsi untuk mengoperasikan beberapa operasi
27
matematika pada array ini. Array adalah blok data yang disusun sepanjang beberapa
dimensi, yang menerapkan vektor dan matriks matematika. Array berguna tidak hanya
untuk menyimpan data, tetapi juga untuk operasi matriks cepat (vektorisasi), yang sangat
diperlukan ketika ingin menyelesaikan masalah sains data ad hoc.
- Situs web: http://www.numpy.org/
- Versi pada saat penulisan: 1.11.1
- Perintah instal yang disarankan:
$ pip instal numpy
SciPy yaitu proyek orisinal oleh Travis Oliphant, Pearu Peterson, dan Eric Jones, SciPy
melengkapi fungsionalitas NumPy, menawarkan variasi yang lebih besar dari algoritma
ilmiah untuk aljabar linier, matriks renggang, pemrosesan sinyal dan gambar,
pengoptimalan, transformasi Fourier cepat, dan banyak lagi.
- Situs web: http://www.scipy.org/
$ pip instal scipy
Panda berurusan dengan semua hal yang tidak dapat dilakukan oleh NumPy dan SciPy.
Secara khusus, terima kasih untuk struktur data objek spesifiknya, DataFrames, dan Seri,
memungkinkan penanganan tabel data kompleks dari berbagai jenis (sesuatu yang tidak
dapat dilakukan oleh array NumPy) dan deret waktu. Berkat kreasi Wes McKinney, akan
dapat dengan mudah dan lancar memuat data dari berbagai sumber, dan kemudian
memotong, memotong, menangani elemen yang hilang, menambah, mengganti nama,
menggabungkan, membentuk kembali, dan akhirnya memvisualisasikannya sesuka .
- Situs web: http://pandas.pydata.org/
$ pip install panda
28
Scikit-learn dimulai sebagai bagian dari SciKits (SciPy Toolkits), Scikit-learn adalah inti dari
operasi ilmu data dengan Python. Ia menawarkan semua yang butuhkan dalam hal
praproses data, pembelajaran yang diawasi dan tidak diawasi, pemilihan model, validasi,
dan metrik kesalahan. Scikit-learn dimulai pada 2007 sebagai proyek Google Summer of
Code oleh David Cournapeau. Sejak 2013, telah diambil alih oleh para peneliti di Inria
(French Institute for Research in Computer Science and Automation). Scikit-learn
menawarkan modul untuk pemrosesan data ( sklearn.preprocessing dan
sklearn.feature_extraction ), pemilihan dan validasi model ( sklearn.cross_ validation ,
sklearn.grid_search , dan sklearn.metrics ), dan satu set lengkap metode (
sklearn.linear_model ) di dimana nilai target, berupa angka atau probabilitas, diharapkan
menjadi kombinasi linier dari variabel input.
- Situs web: http://scikit-learn.org/stable/
$ pip instal scikit-learn
Paket matplotlib awalnya dikembangkan oleh John Hunter, matplotlib adalah perpustakaan
yang berisi semua blok bangunan untuk membuat plot berkualitas dari array dan
memvisualisasikannya secara interaktif, dapat menemukan semua kerangka kerja plot
seperti MATLAB di dalam modul PyLab.
- Situs web: http://matplotlib.org/
- $ pip instal matplotlib
Gensim, diprogram oleh Radim Řehůřek, adalah paket open source yang cocok untuk
menganalisis koleksi tekstual besar dengan menggunakan algoritma online yang dapat
didistribusikan secara paralel. Di antara fungsionalitas lanjutan, ini mengimplementasikan
Semantik Laten Analysis ( LSA ), pemodelan topik oleh Latent Dirichlet Allocation ( LDA ), dan
29
Google word2vec , algoritma yang kuat untuk mengubah teks menjadi fitur vektor untuk
digunakan dalam pembelajaran mesin yang diawasi dan tidak diawasi.
- Situs web: http://radimrehurek.com/gensim/
$ pip instal gensim
H2O adalah kerangka kerja sumber terbuka untuk analisis data besar yang dibuat oleh
H2O.ai start-up (sebelumnya bernama 0xdata). Ini dapat digunakan oleh bahasa
pemrograman R, Python, Scala, dan Java. H2O dengan mudah memungkinkan penggunaan
mesin mandiri (memanfaatkan multiprosesing) atau cluster Hadoop (misalnya, cluster di
lingkungan AWS), sehingga membantu meningkatkan dan memperkecil.
- Situs web: http://www.h2o.ai
- Versi pada saat penulisan: 3.8.3.3
Untuk menginstal paket tersebut, pertama harus mendownload dan menginstal Java di
sistem , ( harus menginstal Java Development Kit ( JDK ) 1.8 karena H2O berbasis Java.) Lalu
dapat merujuk ke petunjuk online yang disediakan di http: //www.h2o. ai / unduh / h2o /
Python
XGBoost adalah pustaka peningkatan gradien yang dapat diskalakan, portabel, dan
terdistribusi (algoritma pembelajaran mesin ansambel pohon). Ini tersedia untuk Python, R,
Java, Scala, Julia, dan C ++ dan dapat bekerja pada satu mesin (memanfaatkan
multithreading), baik di cluster Hadoop dan Spark.
- Situs web: https://xgboost.readthedocs.io/en/latest/
- Versi pada saat penulisan: 0.4
Instruksi terperinci untuk menginstal XGBoost di sistem dapat ditemukan di
https://github.com/dmlc/xgboost/blob/master/doc/build.md . Instalasi XGBoost di Linux dan
Mac OS cukup mudah, sedangkan untuk pengguna Windows sedikit lebih rumit. Untuk
alasan ini, disediakan langkah-langkah penginstalan khusus agar XGBoost berfungsi di
Windows:
30
Pertama-tama, unduh dan instal Git untuk Windows https: // git-for-
windows.github.io/. Maka memerlukan kompiler GNU Minimalis untuk Windows ( MinGW
) yang ada di sistem, dapat mengunduhnya dari http://www.mingw.org/ sesuai dengan
karakteristik sistem. Dari baris perintah, jalankan yang berikut ini:
$ git clone --recursive https://github.com/dmlc/xgboost
$ cd xgboost
$ git submodule init
$ git pembaruan submodule
Kemudian, dari baris perintah, salin konfigurasi untuk sistem 64-bit yang akan dibuat
yang default:
$ copy buat \ mingw64.mk config.mk
Atau, dapat menyalin versi 32-bit biasa:
$ copy buat \ mingw.mk config.mk
Setelah menyalin file konfigurasi, dapat menjalankan kompilator, mengaturnya ke
gunakan empat utas untuk mempercepat prosedur kompilasi:
$ make -j4
Terakhir, jika kompilator menyelesaikan pekerjaannya tanpa kesalahan, dapat menginstal
paket dalam Python dengan menjalankan perintah berikut :
$ cd Python-package
$ Python setup.py install
Theano adalah pustaka Python yang memungkinkan untuk mendefinisikan,

mengoptimalkan, dan mengevaluasi ekspresi matematika yang melibatkan array
multidimensi secara efisien. Pada dasarnya, ini memberi semua blok bangunan yang
butuhkan untuk membuat jaringan neural dalam.
- Situs web: http://deeplearning.net/software/theano/
- Rilis pada saat penulisan: 0.8.2
Instalasi Theano harus mudah karena sekarang menjadi paket di PyPI:
$ pip instal Theano
31
Jika menginginkan versi terbaru dari paket tersebut, bisa mendapatkannya dengan kloning
GitHub:
$ git clone git: //github.com/Theano/Theano.git
Kemudian dapat melanjutkan dengan instalasi Python langsung:
$ cd Theano
$ Python setup.py install
Untuk menguji instalasi , dapat menjalankan perintah berikut dari shell / CMD dan
memverifikasi laporannya:
$ pip install nose
$ pip install nose-parameterized
$ nosetests theano
Jika menggunakan OS Windows dan petunjuk sebelumnya tidak berfungsi, dapat mencoba
langkah-langkah ini:
1. Instal TDM-GCC x64 ( http://tdm-gcc.tdragon.net/ ).
2. Buka prompt perintah Anaconda dan jalankan yang berikut ini:
$ conda update conda
$ conda update –semua
$ conda instal mingw libPython
$ pip instal git + git: //github.com/Theano/Theano.git
Theano membutuhkan libPython, yang belum kompatibel dengan versi 3.5, jadi jika
penginstalan Windows tidak berfungsi, kemungkinan itu penyebabnya. Selain itu, situs web
Theano memberikan beberapa informasi kepada pengguna Windows dapat mendukung
ketika semuanya gagal: http://deeplearning.net/software/theano/install_windows.html
Persyaratan penting bagi Theano untuk meningkatkan skala pada GPU adalah menginstal
driver NVIDIA CUDA dan SDK untuk pembuatan dan eksekusi kode pada GPU. Jika tidak tahu
terlalu banyak tentang CUDA Toolkit, sebenarnya dapat memulai dari halaman web ini
untuk lebih memahami tentang teknologi yang digunakan:
https://developer.nvidia.com/cuda-toolkit. Oleh karena itu, jika komputer memiliki GPU
NVIDIA, dapat menemukan semua yang diperlukan instruksi untuk menginstal CUDA
32
menggunakan halaman tutorial ini dari NVIDIA itu sendiri:
http://docs.nvidia.com/cuda/cuda-quick-start-guide/index. html # axzz4A8augxYy
TensorFlow sama seperti Theano, TensorFlow adalah pustaka perangkat lunak open
source lain untuk komputasi numerik menggunakan grafik aliran data, bukan hanya array.
Node seperti itu grafik mewakili operasi matematika, sedangkan tepi grafik mewakili array
data multidimensi (yang disebut tensor) bergerak di antara node. Awalnya, peneliti Google,
menjadi bagian dari Tim Otak Google, mengembangkan TensorFlow dan baru-baru ini
mereka menjadikannya open source untuk publik.
- Situs web: https://github.com/tensorflow/tensorflow
- Rilis pada saat penulisan: 0.8.0
Untuk penginstalan TensorFlow di komputer , ikuti petunjuk yang terdapat di link berikut:
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/ g3doc / get_started /
os_setup.md
Dukungan Windows tidak ada saat ini tetapi ada dalam peta jalan saat ini:
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/ g3doc / resources /
roadmap.md
Untuk pengguna Windows, kompromi yang baik adalah menjalankan paket pada mesin
virtual berbasis Linux atau mesin Docker. (Halaman pengaturan OS sebelumnya
menawarkan petunjuk untuk melakukannya.)
The sknn perpustakaan (untuk ekstensi, scikit-neuralnetwork ) adalah pembungkus

untuk Pylearn2, membantu untuk menerapkan jaringan saraf yang mendalam tanpa harus
menjadi seorang ahli Theano. Sebagai bonus, pustaka tersebut kompatibel dengan Scikit-
learn API.
- Situs web: https://scikit-neuralnetwork.readthedocs.io/en/latest/
- Rilis pada saat publikasi: 0.7
Untuk menginstal perpustakaan, cukup gunakan perintah berikut :
$ pip install scikit-neuralnetwork
33
Secara opsional, jika ingin memanfaatkan fitur paling canggih seperti konvolusi,
penggabungan, atau peningkatan skala, harus menyelesaikan penginstalan sebagai berikut:
$ pip instal -r https://raw.githubusercontent.com/aigamedev/scikit- neuralnetwork /
master / requirement.txt.
Setelah instalasi, juga harus menjalankan yang berikut ini:
$ git clone https://github.com/aigamedev/scikit-neuralnetwork.git
$ cd scikit-neuralnetwork
$ Python setup.py develop
Seperti yang terlihat pada XGBoost, ini akan membuat paket sknn tersedia di instalasi
Python .
Theanets paket adalah pembelajaran yang dalam dan saraf toolkit jaringan ditulis
dalam Python dan menggunakan Theano untuk mempercepat perhitungan. Hanya sebagai
dengan sknn, itu mencoba untuk membuat hal lebih mudah untuk berinteraksi dengan
fungsi Theano di rangka untuk menciptakan model pembelajaran yang mendalam.
- Situs web: https://github.com/lmjohns3/theanets
Prosedur instalasi yang disarankan :
$ pip instal theanets
Juga dapat mengunduh versi saat ini dari GitHub dan menginstal paket langsung dengan
Python:
$ git clone https://github.com/lmjohns3/theanets
$ cd theanets
$ Python setup.py develop
Keras adalah pustaka jaringan neural minimalis yang sangat modular yang ditulis
dengan Python dan mampu berjalan di atas TensorFlow atau Theano.
- Situs web: http://keras.io/
Instalasi yang disarankan dari PyPI:
34
$ pip install keras
Dapat menginstal versi terbaru yang tersedia (disarankan karena paket dalam
pengembangan berkelanjutan) menggunakan perintah berikut:
$ pip instal git + git: //github.com/fchollet/keras.git
Mengakhiri banyak paket yang menutup dengan tiga paket sederhana, namun cukup
berguna, yang memerlukan sedikit presentasi tetapi perlu diinstal pada sistem : profiler
memori , iklim , dan NeuroLab .
1) Profiler memori adalah paket yang memantau penggunaan memori oleh suatu
proses. Ini juga membantu membedah konsumsi memori oleh skrip Python tertentu,
baris demi baris. Itu dapat diinstal sebagai berikut:
$ pip install -U memory_profiler
2) Iklim hanya terdiri dari beberapa utilitas baris perintah dasar untuk Python. Bisa jadi
segera dipasang sebagai berikut:
$ pip menginstal iklim
3) Akhirnya, NeuroLab adalah paket jaringan saraf yang sangat dasar yang secara
longgar didasarkan pada Neural Network Toolbox ( NNT ) di MATLAB. Ini didasarkan
pada NumPy dan SciPy, bukan Theano; Oleh karena itu, jangan mengharapkan
penampilan yang menakjubkan tetapi ketahuilah bahwa ini adalah kotak peralatan
pembelajaran yang baik. Itu dapat dengan mudah dipasang sebagai berikut:
$ pip instal neurolab
35
RANGKUMAN
Python adalah bahasa tujuan umum, ditafsirkan, berorientasi objek, paket khusus untuk
pemrosesan dan analisis data. Ini memungkinkan untuk memiliki eksperimen yang tak
terhitung dan cepat, pengembangan teori yang mudah, dan penerapan aplikasi ilmiah yang
cepat.
DAFTAR PUSTAKA
1) Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca Massaron,
2) Machine Learning Tingkat Dasar dan Lanjut, 2018. Suyanto, Informatika Bandung
3) https://towardsdatascience.com/beyond-accuracy-precision-and-recall-
3da06bea9f6c
LATIHAN
1. Tugas praktikum. Download dan install beberapa software berikut dengan
menggunakan perintah comment line.

- NumPy
- SciPy
- Panda
- Scikit-learn
2. Cari dataset yang memiliki min 3 atribut dan praktekkan dengan software yang telah
diinstall
3. Jelaskan perbedaan Tensor Flow dengan Keras, dan lakukan Analisa pada algoritma
klasifikasi dataset yang telah didapatkan.
36
BAB III
PERSIAPAN DATA MACHINE LEARNING
- Mahasiswa mampu mengevaluasi model klasifikasi pada pembelajaran Machine

Learning.
- Mahasiswa mampu mendemostrasikan data base SQLite di Python 3 untuk pembelajaran
Machine Learning.
- Mahasiswa mampu mengkode data base SQLite dengan bahasa pemrograman Python.
- Mahasiswa mampu mempraktekkan data base SQLite pada Jupyter Notebook.
MATERI
3.1 Pendahuluan
Memuat set data ke dalam memori, menyiapkan matriks data, melatih algoritma
pembelajaran mesin, dan menguji kemampuan generalisasinya menggunakan observasi di
luar sampel sering kali bukan masalah besar mengingat komputer yang cukup canggih dan
terjangkau saat ini. Namun, semakin sering, skala data yang akan diuraikan begitu besar
sehingga memuatnya ke memori inti komputer tidak mungkin dilakukan dan, meskipun
dapat dikelola, hasilnya tidak dapat dipecahkan baik dalam hal pengelolaan data dan
pembelajaran mesin . Strategi alternatif di luar pemrosesan memori inti dimungkinkan:
membagi data menjadi sampel, menggunakan paralelisme, dan akhirnya belajar dalam
batch kecil atau dengan contoh tunggal. Bab ini akan berfokus pada solusi out-of-the-box
yang ditawarkan paket Scikit-learn: streaming batch mini instance dari penyimpanan data
dan pembelajaran tambahan berdasarkan padanya. Solusi seperti itu disebut pembelajaran
out-of-core.
37
Mengolah data dengan mengerjakan bagian yang dapat dikelola dan belajar secara
bertahap adalah ide bagus. Namun, saat mencoba menerapkannya, hal itu juga terbukti
menantang karena keterbatasan dalam algoritma pembelajaran yang tersedia dan
streaming data dalam suatu aliran akan mengharuskan untuk berpikir secara berbeda
dalam hal pengelolaan data dan ekstraksi fitur. Selain menghadirkan fungsionalitas Scikit-
learn untuk pembelajaran out-of-core, juga akan berusaha memberikan solusi Python untuk
masalah yang tampaknya menakutkan yang dapat hadapi ketika dipaksa untuk mengamati
hanya sebagian kecil dari data. Pembelajaran out-of-core mengacu pada sekumpulan
algoritma yang bekerja dengan data yang tidak dapat masuk ke dalam memori satu
komputer, tetapi dapat dengan mudah masuk ke dalam beberapa penyimpanan data seperti
hard disk lokal atau repositori web. RAM yang tersedia, memori inti pada mesin tunggal ,
mungkin memang berkisar dari beberapa gigabyte (terkadang 2 GB, lebih umum 4 GB, tetapi
berasumsi bahwa memiliki maksimum 2 GB) hingga 256 GB pada mesin server besar. Server
besar seperti yang bisa dapatkan di layanan komputasi awan seperti Amazon Elastic
Compute Cloud ( EC2 ), sedangkan kemampuan penyimpanan dapat dengan mudah
melebihi kapasitas terabyte hanya dengan menggunakan drive eksternal (kemungkinan
besar ser 1 TB tetapi dapat mencapai hingga 4 TB).
Karena pembelajaran mesin didasarkan pada pengurangan fungsi biaya secara
global, banyak algoritma pada awalnya dianggap berfungsi menggunakan semua data yang
tersedia dan memiliki akses untuk itu di setiap iterasi proses pengoptimalan. Hal ini
terutama berlaku untuk semua algoritma berdasarkan pembelajaran statistik yang
mengeksploitasi kalkulus matriks, misalnya, matriks pembalik, tetapi juga algoritma yang
didasarkan pada pencarian serakah perlu mengevaluasi data sebanyak mungkin sebelum
mengambil langkah berikutnya. Oleh karena itu, algoritma seperti regresi out-of-the-box
yang paling umum (kombinasi fitur linier berbobot) memperbarui koefisiennya mencoba
meminimalkan kesalahan gabungan dari seluruh kumpulan data. Dengan cara yang sama,
karena sangat peka terhadap gangguan yang ada dalam kumpulan data, pohon keputusan
harus memutuskan pemisahan terbaik berdasarkan semua data yang tersedia untuk
menemukan solusi yang optimal.
38
Jika data tidak dapat muat dalam memori inti dari komputer di seperti sebuah
situasi, tidak memiliki banyak kemungkinan solusi. dapat meningkatkan dengan memori
yang tersedia (tergantung pada keterbatasan dari motherboard, setelah itu, akan memiliki
untuk mengubah ke didistribusikan sistem seperti seperti Hadoop dan Spark, sebuah solusi
akan menyebutkan dalam bab terakhir) atau hanya mengurangi dataset di rangka untuk
memiliki itu sesuai dengan memori. Jika data jarang, artinya, memiliki banyak nilai nol
dalam kumpulan data , dapat mengubah matriks padat menjadi matriks jarang. Ini khas
dengan data tekstual dengan banyak kolom karena masing-masing adalah kata tetapi
dengan sedikit nilai yang mewakili jumlah kata karena dokumen tunggal biasanya
menampilkan pilihan kata yang terbatas. Terkadang, menggunakan matriks renggang dapat
menyelesaikan masalah yang memungkinkan memuat dan memproses kumpulan data lain
yang cukup besar, tetapi ini bukan obat mujarab (maaf, tidak ada makan siang gratis, yaitu,
tidak ada solusi yang dapat menyesuaikan semua masalah) karena beberapa matriks data ,
meskipun jarang, dapat memiliki ukuran yang menakutkan.
Dalam situasi seperti itu, selalu dapat mencoba mengurangi kumpulan data dengan
memotong jumlah instans atau membatasi jumlah fitur, sehingga mengurangi dimensi
matriks kumpulan data dan area yang ditempati di dalam memori. Mengurangi ukuran
kumpulan data, dengan memilih hanya sebagian dari pengamatan, adalah solusi yang
disebut subsampling (atau hanya pengambilan sampel). Subsampling sebenarnya tidak salah
tetapi memiliki kelemahan serius dan perlu diingat sebelum memutuskan arah analisis.
Klasterisasi adalah salah satu teknik unsupervised learning dimana tidak perlu melatih
metode tersebut atau dengan kata lain, tidak ada fase learning. Masuk dalam pendekatan
unsupervised learning adalah metode-metode yang tidak membutuhkan label atau output
dari setiap titik data yang investigasi. Sebaliknya supervised learning adalah metode yang
memerlukan training (melatih) dan testing (menguji). Masuk dalam kategori ini adalah
regresi, Artificial neural network (ANN), analisis diskriminan (LDA) dan support vector
machine. Model klasifikasi dapat dibangun berdasarkan pengetahuan seorang pakar (ahli).
Namun mengingat himpunan data yang sangat besar, model klasifikasi lebih sering dibangun
menggunakan teknik pembelajaran dalam bidang Machine Learning. Proses pembelajaran
secara otomatis terhadap suatu data mampu menghasilkan model klasifikasi (fungsi target)
39
yang memetakan objek data x (input) ke salah satu kelas y yang telah didefinisikan
sebelummnya. Jadi, proses pebelajaran memelukan masukan (input) berupa himpunan data
latih (training set) yang berlabel (memiliki atribut kelas) dan mengeluarkan output yang
berupa sebuah model klasifikasi. Ukuran Evaluasi Model Klasifikasi
Tabel 1 Model Klasifikasi
Dimana FP adalah true positives, TN adalah true negative, FP adalah false positives, P
adalah jumlah sample positif, dan N adalah jumlah sampel negatif. Istilah tersebut dapat
diilustrasikan dengan menggunakan confusion matrix. Confusion matrix sangat berguna
untuk menganalisis kualitas model klasifikasi dalam mengenali tuple-tuple dari kelas yang
ada.
Confusion Matrix
40
Binary Classification Problem, dalam kasus binary classification seperti contoh prediksi
kredit macet pinjaman bank, hasil prediksi berupa True Positive (TF), True Negative (TN),
False Positive (FP), False Negative (FN).
Tabel 2.Confusion Matrix
Confusion Matrix merepresentasikan prediksi dan kondisi sebenarnya(aktual) dari data yang
dihasilkan oleh algoritma ML. Berdasarkan Confusion Matrix, bisa menentukan Precision
dan Recall. Recall dapat didefinisikan sebagai rasio dari jumlah total contoh positif yang
diklasifikasikan bernilai benar dibagi dengan jumlah total contoh positif. High Recall
menunjukkan kelas dikenali dengan baik (FN rendah).
Precision merupakan pembagian dari jumlah total contoh positif yang diklasifikasikan
bernilai benar dengan jumlah total contoh positif yang diprediksi. High Precision
menunjukkan contoh berlabel positif memang positif (FP rendah).
High Recall, Low Precision
41
Gambar 5. Precision
Ini berarti sebagian besar data positif dikenali dengan baik (FN rendah) tetapi ada
banyak False Positive (FP tinggi). Low Recall, High Precision:
Gambar 6. Precision 2
Model dapat mengklasifikasikan lebih sedikit data bernilai positif (FN tinggi) tetapi
model mengklasifikasikan data positif benar-benar bernilai positif (FP rendah). Sejak tahun
1987, di University of California, Irvine ( UCI ), UCI Machine Learning Repository telah
dihosting, yang merupakan repositori besar kumpulan data untuk pengujian empiris
algoritma pembelajaran mesin oleh komunitas pembelajaran mesin. Di saat penulisan ini,
repositori berisi ser 350 kumpulan data dari domain dan tujuan yang sangat berbeda, dari
regresi dan klasifikasi yang diawasi hingga tugas-tugas yang tidak diawasi. dapat melihat
42
kumpulan data yang tersedia di https: // archive.ics.uci.edu/ml/. Maka telah memilih
beberapa kumpulan data yang akan berguna di sepanjang buku ini, mengusulkan masalah
yang menantang kepada dengan komputer RAM 2 GB yang tidak biasa, tetapi masih dapat
dikelola, dan sejumlah besar baris atau kolom.
Tabel 3.UCI Machine Learning Repository
Nama kumpulan data URL kumpulan data Jenis masalah Baris dan kolom
Dataset berbagi https: //archive.ics. Regresi 17389, 16

sepeda uci.edu/ml/datasets/ Bike +
Sharing + Dataset
Dataset https: //archive.ics. Regresi 60021, 281
BlogFeedback uci.edu/ml/datasets/
BlogFeedback
Buzz di set data https: //archive.ics. Regresi dan 140000, 77
media sosial uci.edu/ml/datasets/ Buzz + klasifikasi
di + media + sosial +
Dataset Sensus https: //archive.ics. Klasifikasi 299285, 40
Pendapatan (KDD) uci.edu/ml/datasets/ dengan data
Sensus-Pendapatan +% yang hilang
28KDD% 29
Dataset covertype https: //archive.ics. Klasifikasi 581012, 54
uci.edu/ml/datasets/
Covertype
Piala KDD 1999 https: //archive.ics. Klasifikasi 4000000, 42
Himpunan data uci.edu/ml/datasets/ KDD +
Cup + 1999 + Data
43
Untuk mengunduh dan menggunakan kumpulan data dari repositori UCI, harus pergi
ke halaman yang didedikasikan untuk kumpulan data tersebut dan ikuti tautan di bawah
judul Folder Data. Beberapa skrip untuk mengunduh data secara otomatis yang akan
ditempatkan tepat di direktori tempat bekerja dengan Python, sehingga membuat akses
data menjadi lebih mudah. Berikut adalah beberapa fungsi yang telah persiapkan dan akan
diingat sepanjang bab ketika perlu mengunduh salah satu dataset dari UCI:
In: import urllib2 # import urllib.request sebagai urllib2 dalam permintaan impor Python3,
io, os, StringIO
impor numpy sebagai np
impor tarfile, zipfile, gzip
def unzip_from_UCI (UCI_url, dest = ''): "" "
# Mendownload dan membongkar set data dari UCI dalam format zip "" "
response = requests.get (UCI_url) compressed_file = io.BytesIO (response.content) z =
zipfile.ZipFile (compressed_file)
print ('Mengekstrak dalam % s' % os.getcwd () + '\\' + dest) untuk nama dalam z.namelist ():
jika '.csv' dalam nama:

print ('\ tunzipping% s'% name) z.extract (name, path = os.getcwd () + '\\' + dest)
def gzip_from_UCI (UCI_url, dest = ''): "" "
#Mendownload dan mengekstrak set data dari UCI dalam format gzip "" "
response = urllib2.urlopen (UCI_url) compressed_file = io.BytesIO (response.read ())
decompressed_file = gzip.GzipFile (fileobj = compressed_file) nama file = UCI_url.split ('/') [-
1] [: - 3]
dengan open (os.getcwd () + '\\' + nama file, 'wb') sebagai outfile: outfile.write
(decompressed_file.read ())
print ('File% s didekompresi'% nama file) def targzip_from_UCI (UCI_url, dest = '.'):
"" "
#Mengunduh dan membongkar set data dari UCI dalam format tar.gz "" "
respon = urllib2.urlopen (UCI_url)
44
compressed_file = StringIO.StringIO (response.read ())
tar = tarfile.open (mode = "r: gz", fileobj = compressed_file) tar.extractall (path = dest)
dataset = tar.getnames () untuk dataset dalam dataset:
size = os.path.getsize (dest + '\\' + dataset) print ('File% s adalah% i bytes'% (dataset, size))
tar.close ()
def load_matrix (UCI_url): "" "
#Unduh set data dari UCI dalam bentuk matriks "" "
return np.loadtxt (urllib2.urlopen (UCI_url))
3.2 Berbagi Kumpulan Data
Sebagai contoh pertama, akan bekerja dengan kumpulan data bike-sharing. Kumpulan data
terdiri dari dua file CSV yang berisi jumlah sepeda yang disewa per jam dan harian antara
tahun 2011 dan 2012 dalam sistem berbagi capital bike di Washington DC, AS. Data tersebut
menampilkan cuaca yang sesuai dan informasi musiman mengenai hari sewa. Dataset
dihubungkan dengan publikasi oleh Fanaee-T, Hadi, dan Gama, Joao, Pelabelan peristiwa
yang menggabungkan detektor ansambel dan pengetahuan latar belakang, Progress in
Artificial Intelligence (2013): hlm. 1-15, Springer Berlin Heidelberg . Target pertama adalah
menyimpan kumpulan data di hard disk lokal menggunakan fungsi pembungkus yang
nyaman yang didefinisikan hanya beberapa paragraf sebelumnya.
UCI_url = 'https://archive.ics.uci.edu/ml/machine-learningdatabases / 00275 / Bike-
Sharing-Dataset.zip' unzip_from_UCI (UCI_url, dest = 'bikesharing')
Keluar:
Mengekstrak di C: \ scisoft \ WinPython-64bit-2.7.9.4 \ notebooks \ bikesharing
unzip day.csv unzip hour.csv
Jika berhasil dijalankan, kode akan menunjukkan di direktori mana file CSV telah disimpan
dan mencetak nama dari kedua file yang dibuka zip tersebut. Pada titik ini, setelah
menyimpan informasi di perangkat fisik, akan menulis skrip yang merupakan inti dari sistem
pembelajaran out-of-core , menyediakan streaming data dari file. Pertama-tama akan
menggunakan pustaka csv , menawarkan pilihan ganda, untuk memulihkan data sebagai
daftar atau kamus Python.
45
import os, csv local_path = os.getcwd ()
sumber = 'bikesharing \\ hour.csv'
SEP = ',' # Kami mendefinisikan ini untuk dapat dengan mudah mengubahnya seperti yang
dibutuhkan oleh file
dengan open (local_path + '\\' + source, 'rb') sebagai R: iterator = csv.reader (R, delimiter =
SEP) untuk n, baris di enumerate (iterator):
jika n == 0:
header = baris lain:
# Placeholder pengolahan data # pass placeholder pembelajaran mesin print ('Total baris:%
i'% (n + 1))
print ('Header:% s'% ',' .join (header)) print ('Contoh nilai:% s'% ',' .join (baris))
Keluar: Total baris: 17380

Header: instant, dteday, season, thn, mnth, hr, holiday, weekday, working, weathersit, temp,
atemp, hum, windspeed, casual, register, cnt
Nilai sampel: 17379, 2012-12-31, 1, 1, 12, 23, 0, 1, 1, 1, 0,26,
0,2727, 0,65, 0,1343, 12, 37, 49
46
Keluarannya akan melaporkan kepada berapa banyak baris yang telah dibaca,
konten tajuk — baris pertama file CSV (disimpan dalam daftar) —dan konten baris (untuk
kenyamanan, mencetak yang terakhir dilihat) . Fungsi csv.reader membuat iterator yang,
berkat perulangan for , akan melepaskan setiap baris file satu per satu. Perhatikan bahwa
telah menempatkan dua komentar secara internal di cuplikan kode, menunjukkan di mana,
di sepanjang bab ini, akan menempatkan kode lain untuk menangani pemrosesan awal data
dan pembelajaran mesin. Fitur dalam hal ini harus ditangani dengan menggunakan
pendekatan posisi, yaitu mengindeks posisi label di header. Ini bisa menjadi sedikit
gangguan jika harus memanipulasi fitur secara ekstensif. Solusinya bisa dengan
menggunakan csv. DictReader yang menghasilkan kamus Python sebagai output (yang tidak
berurutan tetapi fitur-fiturnya dapat dengan mudah diingat oleh labelnya). Dalam: dengan
open (local_path + '\\' + source, 'rb') sebagai R: iterator = csv.DictReader (R, delimiter = SEP)
untuk n, baris di enumerate (iterator):
# Placeholder PENGOLAHAN DATA # Pass placeholder PEMBELAJARAN MESIN
print ('Total baris:% i'% (n + 1))
print ('Contoh nilai:% s'% str (baris))
Keluar: Total baris: 17379

Nilai sampel: {'mnth': '12', 'cnt': '49', 'holiday': '0', 'instant':
'17379', 'temp': '0.26', 'dteday': '2012-12-31', 'hr': '23', 'season':
'1', 'terdaftar': '37', 'kecepatan angin': '0.1343', 'atemp': '0.2727',
'workingday': '1', 'weathersit': '1', 'weekday': '1', 'hum': '0.65',
'yr': '1', 'casual': '12'}
3.3 Menggunakan I/O Panda
Sebagai alternatif dari modul csv , dapat menggunakan fungsi read_csv pandas . Fungsi
seperti itu, khusus mengupload file csv, merupakan bagian dari cukup banyak fungsi yang
dikhususkan untuk input / output pada format file yang berbeda, seperti yang ditentukan
oleh dokumentasi pandas di http://pandas.pydata.org/pandas-docs/ stable / io.html .
Keuntungan besar menggunakan fungsi I / O pandas adalah sebagai berikut:
47
1) Dapat menjaga kode tetap konsisten jika mengubah jenis sumber , yaitu , hanya
perlu mendefinisikan ulang iterator streaming
2) Dapat mengakses sejumlah besar format berbeda seperti kueri CSV, TXT biasa, HDF,
JSON, dan SQL untuk database tertentu
3) Data dialirkan ke dalam potongan dengan ukuran yang diinginkan sebagai struktur
data dataframe sehingga dapat mengakses fitur dengan cara posisional atau dengan
mengingat labelnya, berkat metode .loc , .iloc , .ix yang tipikal dari pemotongan dan
pemotongan dalam a bingkai data panda.
Berikut adalah contoh yang menggunakan pendekatan yang sama seperti sebelumnya, kali
ini dikembangkan fungsi read_csv panda :
impor panda sebagai pd CHUNK_SIZE = 1000
dengan open (local_path + '\\' + source, 'rb') sebagai R: iterator = pd.read_csv (R, chunksize
= CHUNK_SIZE) untuk n, data_chunk in enumerate (iterator):
print ('Ukuran potongan yang diunggah:% i instance,% i features'% (data_chunk.shape))
# Placeholder PENGOLAHAN DATA # Pass placeholder PEMBELAJARAN MESIN
print ('Contoh nilai: \ n% s'% str (data_chunk.iloc [0]))
Keluaran
Ukuran daridiunggah bingkah:2379 contoh, 17 fitur
Ukuran daridiunggah bingkah:2379 contoh, 17 fitur
Ukuran daridiunggah bingkah:2379 contoh, 17 Fitur
48
Dteday 2012-09-22
Musim 3
Thn 1
Mnth 9
Hr 5
liburan 0
hari kerja 6
hari kerja 0
weathersit 1
Suhu 0,56
Atemp 0,5303
bersenandung 0.83
kecepatan angin 0,3284
Santai 2
terdaftar 15
Cnt 17
Nama: 0, dtype: object
Di sini, sangat penting untuk diperhatikan bahwa iterator dibuat dengan menentukan
ukuran chunk, yaitu jumlah baris yang harus dikembalikan oleh iterator pada setiap iterasi.
The chunksize parameter dapat mengasumsikan nilai-nilai dari 1 sampai nilai apapun,
meskipun jelas ukuran mini-batch (potongan yang diambil) secara ketat terhubung ke
memori yang tersedia untuk menyimpan dan memanipulasi dalam tahap preprocessing
berikutnya.
49
RANGKUMAN
Dalam bab ini, pembelajaran dapat dilakukan secara out-of-core dengan mengalirkan
data, tidak peduli seberapa besar, dari file teks atau database pada hard disk.
Memperkenalkan implementasi Scikit-learn dari SGD, membatasi pada fungsi kerugian
regresi linier dan logistik. Persiapan data, memperkenalkan trik hashing dan strategi validasi
untuk aliran, dan menyelesaikan pengetahuan yang diperoleh tentang SGD yang cocok
dengan dua model yang berbeda klasifikasi dan regresi.
DAFTAR PUSTAKA
1) Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca Massaron,
2) Machine Learning Tingkat Dasar dan Lanjut, 2018. Suyanto, Informatika
Bandung
3) https://towardsdatascience.com/beyond-accuracy-precision-and-recall-
3da06bea9f6c
LATIHAN
1. Download dataset dan unggah file CSV yang berisi kumpulan data berbagi sepeda ke
database SQLite! Peraktekkan kode pengunggahan database seperti dibawah!
Di: import os, sys import
sqlite3, csv, glob
SEP = ','
def define_field (s): coba:
int (s)
kembalikan
'integer' kecuali
ValueError:
50
mencoba:
float (s) return 'real'
kecuali:
kembalikan 'teks'
def create_sqlite_db (db = 'database.sqlite', file_pattern = ''): conn = sqlite3.connect (db)
conn.text_factory = str # memungkinkan data utf-8 disimpan c
= conn.cursor ()
# melintasi direktori dan memproses setiap file .csv yang berguna
untuk membangun db
target_files = glob.glob (file_pattern)
print ('Membuat% i tabel menjadi% s dari file:% s'% (len (target_files), db, ',' .join
(target_files)))
untuk k, csvfile di enumerate (target_files):
# hapus jalur dan ekstensi dan gunakan yang tersisa sebagai tabel
nama
tablename = os.path.splitext (os.path.basename (csvfile)) [0] dengan open (csvfile,
"rb") sebagai f:
reader = csv.reader (f, pembatas = SEP)
f. mencari (0)
untuk n baris di enumerate (reader): if n == 11:
types = map (define_field, row) lain:
jika n> 11:
istirahat
f. mencari (0)
untuk n baris enumerate (reader): if n == 0:
sql = "DROP TABLE JIKA ADA% s"% tablename
c.execute (sql)
sql = "BUAT TABEL% s (% s)"% (nama tab, \ "," .join (["% s%
s"% (col, ct) \
untuk col, ct di zip (row, types)]))
cetak ('% i)% s'% (k + 1, sql))
c. eksekusi (sql)
string
# Membuat indeks untuk bergabung lebih cepat dalam waktu lama
untuk kolom di baris:

jika column.endswith ("_ ID_hash"): index = "% s % s"% \
(tablename, kolom)
sql = "BUAT INDEKS% s pada% s (% s)"% \
(indeks, tablename, kolom)
c. eksekusi (sql)
51
(tablename,
insertsql = "INSERT INTO% s VALUES (% s)"%
"," .join (["?" untuk kolom di baris]))

rowlen = len (baris)
lain:
# memunculkan kesalahan jika ada baris yang tidak
memiliki jumlah bidang yang benar
jika len (baris) == rowlen: c.execute
(sisipkan, baris)
lain:
print ('Kesalahan pada baris% i dalam file% s')%
(n, csvfile)
masalah di baris% i '% n)
meningkatkan ValueError ('Houston, memiliki file
conn.commit ()
print ('*% i baris disisipkan'% n)
c.close ()
conn.close ()
2. Lakukan evaluasi pada dataset Sepeda, seperti tingkat akurasi, recall, false positif,
false ngatif, true positive, false postisive dan precession.
52
BAB IV
FAST-LEARNING SVMS PYTHON
- Mahasiswa mampu menjelaskan cara kerja algoritma Fast-Learning SVMs Python

- Mahasiswa mampu mendemostrasikan Fast-Learning SVMs Python 3 untuk pembelajaran
Machine Learning.
- Mahasiswa mampu mengkode Fast-Learning SVMs dengan bahasa pemrograman Python.
- Mahasiswa mampu mempraktekkan Fast-Learning SVMs Machine Learning pada Jupyter
Notebook.
- Mahasiswa mampu menguji Fast-Learning SVMs pada Jupyter Notebook.
MATERI
4.1 Fast-Learning SVMs
Merupakan metode yang berusaha menemukan fungsi-fungsi pendekatan yang bernilai

diskrit. Banyak digunakan dalam data mining untuk klasifikasi. Dua fase:
Learning/pembelajaran dan pengujian. Decicion tree learning adalah suatu metode belajar
yang sangat populer dan banyak digunakan secara praktis. Metode ini merupakan
metode yang berusaha menemukan fungsi-fungsi pendekatan yang bernilai diskrit dan
tahan terhadap data-data yang terdapat kesalahan (noise data) serta mampu
mempelajari ekspresi-ekspresi disjungtive. Iterative Dichotomiser3 (ID3), Assistant dan
C4.5 merupakan jenis dari decision tree learning. Dalam membangun decision tree
learning dibutuhkan evaluasi semua atribut yang ada menggunakan suatu
ukuran statistik untuk mengukur efektifitas suatu atribut dalam mengklasifikasikan
kumpulan sampel data. Dalam hal ini information gain adalah yang paling banyak
digunakan. Setelah bereksperimen dengan pembelajaran gaya online di bab sebelumnya,
53
mungkin terkejut dengan kesederhanaan namun efektivitas dan skalabilitasnya
dibandingkan dengan pembelajaran batch. Meskipun belajar hanya satu contoh dalam satu
waktu, SGD dapat memperkirakan hasil seperti halnya jika semua data berada di memori inti
dan menggunakan algoritma batch. Yang butuhkan hanyalah streaming benar-benar
stokastik (tidak ada tren dalam data) dan pelajar disesuaikan dengan masalahnya
(kecepatan pemelajaran sering kali menjadi parameter kunci yang harus diperbaiki).
Bagaimanapun, memeriksa pencapaian seperti itu dengan cermat, hasilnya masih
dapat dibandingkan dengan model linier batch tetapi tidak untuk peserta didik yang lebih
canggih dan dicirikan oleh varian yang lebih tinggi daripada bias, seperti SVM, jaringan saraf,
atau mengantongi dan meningkatkan ansambel pohon keputusan.Untuk masalah tertentu,
seperti data tinggi dan lebar tetapi jarang, kombinasi linier saja mungkin cukup sesuai
dengan pengamatan bahwa algoritma sederhana dengan lebih banyak data sering kali
menang daripada algoritma yang lebih kompleks yang dilatih dengan lebih sedikit data.
Namun, bahkan menggunakan model linier dan dengan menggunakan pemetaan secara
eksplisit fitur yang ada menjadi yang berdimensi lebih tinggi (menggunakan urutan interaksi
yang berbeda, perluasan polinomial, dan perkiraan kernel), dapat mempercepat dan
meningkatkan pembelajaran hubungan non linear kompleks antara respons dan fitur. Oleh
karena itu, dalam bab ini, pertama-tama akan memperkenalkan SVM linier sebagai
alternatif algoritma pembelajaran mesin untuk model linier, yang didukung oleh pendekatan
berbeda untuk masalah pembelajaran dari data. Kemudian, akan mendemonstrasikan
bagaimana dapat membuat fitur yang lebih kaya dari yang sudah ada untuk menyelesaikan
tugas pembelajaran mesin dengan cara yang lebih baik ketika menghadapi data skala besar,
terutama data yang tinggi (yaitu, kumpulan data memiliki banyak kasus untuk dipelajari).
4.2 Data Collection

Seperti pada bab sebelumnya, akan menggunakan dataset dari UCI Machine Learning
Repository, khususnya dataset bike-sharing (masalah regresi) dan Data Covertype Hutan
(masalah klasifikasi multikelas). Fungsi yang dibutuhkan adalah unzip_
from_UCI dan gzip_from_UCI . Keduanya memiliki koneksi Python ke repositori UCI; unduh
file terkompresi dan unzip di direktori Python yang berfungsi. Jika memanggil fungsi dari sel
54
IPython, akan menemukan direktori dan file baru yang diperlukan persis di mana IPython
akan mencarinya. Jika fungsinya tidak bekerja untuk, akan memberi tautan untuk unduhan
langsung. Setelah itu, yang harus lakukan adalah membongkar data di direktori Python yang
berfungsi saat ini, yang dapat temukan dengan menjalankan perintah berikut pada
antarmuka Python (IPython atau IDE apa pun):
In: UCI_url = 'https://archive.ics.uci.edu/ml/machine-learningdatabases/00275/Bike-
Sharing-Dataset.zip'
unzip_from_UCI(UCI_url, dest='bikesharing')
Out: Extracting in C:\scisoft\WinPython-64bit-2.7.9.4\notebooks\
bikesharing
unzipping day.csv
unzipping hour.csv
Dataset terdiri dari dua file dalam format CSV yang berisi hitungan per jam dan
harian dari sepeda yang disewa antara tahun 2011 dan 2012 di Ibukota. Sistem berbagi-
sepeda di Washington DC, AS. Sebagai pengingat, data menampilkan cuaca yang sesuai dan
informasi musiman mengenai hari persewaan. Cuplikan kode berikut akan
menyimpan set data di hard disk lokal menggunakan fungsi pembungkus unzip_from_UCI :
Dalam:
UCI_url = 'https://archive.ics.uci.edu/ml/machine-learningdatabases / 00275 / Bike-
Sharing-Dataset.zip' unzip_from_UCI (UCI_url, dest = 'bikesharing')
Keluar:
Mengekstrak di C: \ scisoft \ WinPython-64bit-2.7.9.4 \ notebooks \ bikesharing
unzip day.csv unzip hour.csv
Jika berhasil dijalankan, kode akan menunjukkan di direktori mana file CSV telah disimpan
dan mencetak nama dari kedua file yang dibuka zip tersebut. Jika tidak berhasil, cukup
unduh file dari https://archive.ics.uci.edu/ml/machine-learningdatabases / 00275 / Bike-
Sharing-Dataset.zip dan unzip kedua file tersebut, day.csv dan hour.csv , di direktori
bernama bikesharing yang sebelumnya buat di direktori kerja Python .
55
Dataset rahasia disumbangkan oleh Jock A. Blackard, Dr. Denis J. Dean, Dr. Charles
W. Anderson, dan Colorado State University, kumpulan data rahasia berisi 581.012 contoh
dan serangkaian 54 variabel kartografi, mulai dari ketinggian hingga jenis tanah, diharapkan
dapat memprediksi tipe tutupan hutan yang terdiri dari tujuh jenis (jadi ini masalah
multikelas). Untuk memastikan komparasi dengan studi akademis pada data yang sama,
instruksi merekomendasikan penggunaan 11.340 catatan pertama untuk pelatihan, 3.780
catatan berikutnya untuk validasi, dan terakhir 565.892 catatan yang tersisa.
sebagai contoh uji:
UCI_url = 'https://archive.ics.uci.edu/ml/machine-learningdatabases / covtype /
covtype.data.gz'
gzip_from_UCI (UCI_url)
Jika ada masalah dalam menjalankan kode atau jika lebih suka menyiapkan file sendiri,
cukup buka situs web UCI, unduh kumpulan data dari https: //
arsip. ics.uci.edu/ml/machine-learning-databases/covtype/covtype.data.gz , dan ekstrak ke
direktori yang sedang dikerjakan Python.
4.3 Mesin Vektor

Support Vector Machines ( SVM ) adalah sekumpulan teknik pembelajaran yang diawasi
untuk klasifikasi dan regresi (dan juga untuk deteksi pencilan), yang cukup fleksibel karena
dapat disesuaikan dengan model linier dan non linear berkat ketersediaan fungsi khusus —
fungsi kernel. Keistimewaan dari fungsi kernel tersebut adalah untuk dapat memetakan fitur
masukan menjadi vektor fitur baru yang lebih kompleks menggunakan jumlah komputasi
yang terbatas. Fungsi kernel menggabungkan kembali fitur asli secara non linear,
memungkinkan pemetaan respons dengan fungsi yang sangat kompleks. Dalam pengertian
seperti itu, SVM dapat dibandingkan dengan jaringan saraf sebagai aproksimator universal,
dan dengan demikian dapat membanggakan kekuatan prediksi yang sama dalam banyak
masalah. Berlawanan dengan model linier yang terlihat pada bab sebelumnya, SVM dimulai
sebagai file metode untuk memecahkan masalah klasifikasi, bukan masalah regresi.
SVM ditemukan di laboratorium AT&T pada tahun 90-an oleh ahli matematika, Vladimir
Vapnik, dan ilmuwan komputer, Corinna Cortes (tetapi ada juga banyak kontributor lain
56
yang bekerja dengan Vapnik pada algoritma). Intinya, SVM berusaha untuk memecahkan
masalah klasifikasi dengan menemukan bidang-hiper tertentu yang memisahkan kelas-kelas
dalam ruang fitur.
Hyperplane tertentu harus dicirikan sebagai salah satu yang memiliki margin
pemisah terbesar antara batas-batas kelas (margin dimaksudkan sebagai celah, ruang antara
kelas itu sendiri, kosong dari contoh apa pun). Intuisi semacam itu menyiratkan dua
konsekuensi:
1) Secara empiris, SVM mencoba meminimalkan kesalahan pengujian dengan
menemukan solusi dalam set pelatihan yang tepat di tengah kelas
yang diamati , sehingga solusinya jelas bersifat komputasi (ini adalah
pengoptimalan berdasarkan pemrograman kuadrat—
https://en.wikipedia.org/wiki/Quadratic_ programming ).
2) Karena solusinya hanya didasarkan pada batas-batas kelas seperti yang ditetapkan
oleh contoh-contoh yang berdampingan (disebut vektor pendukung), contoh-contoh
lain dapat diabaikan, membuat teknik ini tidak peka terhadap pencilan dan kurang
intensif memori daripada metode berdasarkan inversi matriks seperti itu sebagai
model linier.
Dengan gambaran umum tentang algoritma, akan menghabiskan beberapa halaman yang
menunjukkan formulasi kunci yang menjadi ciri SVM. Meskipun penjelasan lengkap dan
mendetail tentang metode ini berada di luar cakupan buku ini, membuat sketsa cara
kerjanya memang dapat membantu mencari tahu apa yang terjadi di balik tudung teknik
dan memberikan dasar untuk memahami bagaimana hal itu dapat dibuat skalabel ke data
besar. Secara historis, SVM dianggap sebagai pengklasifikasi hard-margin , seperti
perceptron. Faktanya, SVM pada awalnya mencoba menemukan dua hyperplanes yang
memisahkan kelas yang jarak timbal-baliknya semaksimal mungkin. Pendekatan seperti itu
bekerja sempurna dengan data sintetis yang dapat dipisahkan secara linier. Dalam versi
hard-margin, ketika SVM menghadapi data yang dipisahkan non linearly, itu bisa hanya
berhasil.
Menggunakan non linear transformasi dari satu fitur. Namun, mereka yang selalu
dianggap untuk gagal ketika kesalahan klasifikasi kesalahan adalah karena kebisingan di
57
data, bukan non linearitas. Untuk alasan seperti itu, softmargins diperkenalkan melalui
fungsi biaya yang memperhitungkan seberapa serius kesalahan itu (karena margin keras
terus melacak hanya jika terjadi kesalahan), sehingga memungkinkan toleransi tertentu
untuk kasus yang salah klasifikasi yang kesalahannya tidak terlalu besar. karena mereka
ditempatkan di sebelah hyperplane pemisah. Sejak diperkenalkannya softmargins, SVM juga
mampu menahan non-separabilitas yang disebabkan oleh noise. Softmargins hanya
diperkenalkan oleh membangun fungsi biaya di variabel slack yang mendekati jumlah
contoh yang salah diklasifikasikan. Variabel slack tersebut disebut juga dengan risiko empiris
(risiko salah klasifikasi jika dilihat dari sudut pandang data pelatihan). Dalam formulasi
matematika, diberikan matriks dataset X dari n contoh dan fitur m dan vektor respon yang
menyatakan milik kelas dalam hal +1 (milik) dan -1 (tidak termasuk), klasifikasi biner SVM
berusaha untuk meminimalkanfungsi biaya. Dalam fungsi sebelumnya, w adalah vektor
koefisien yang menyatakan hyperplane pemisah bersama dengan bias b , mewakili offset
dari titik asal. Ada juga lambda ( λ > = 0 ) yang merupakan parameter regularisasi. Untuk
pemahaman yang lebih baik tentang bagaimana fungsi biaya bekerja, perlu untuk
membaginya menjadi dua bagian. Bagian pertama adalah istilah regularisasi. Istilah
regularisasi mengontraskan proses minimisasi ketika vektor w mengasumsikan nilai
tinggi. Istilah kedua disebut istilah kerugian atau variabel kendor, dan sebenarnya
merupakan inti dari prosedur minimisasi SVM.
Istilah kerugian menghasilkan nilai perkiraan kesalahan klasifikasi. Faktanya,
penjumlahan akan cenderung menambahkan nilai satuan untuk setiap kesalahan klasifikasi,
yang totalnya dibagi n, jumlah contoh, akan memberikan perkiraan proporsi kesalahan
klasifikasi. Seringkali, seperti dalam implementasi Scikit-learn, lambda dihapus dari istilah
regularisasi dan diganti dengan parameter kesalahan klasifikasi C yang mengalikan istilah
kerugian. Ini hanya masalah kesepakatan, karena perubahan dari parameter lambda ke C
pada rumus pengoptimalan tidak menyiratkan hasil yang berbeda. Dampak istilah kerugian
dimediasi oleh hyperparameter C. Nilai C yang tinggi memberikan hukuman yang tinggi pada
kesalahan, sehingga memaksa SVM untuk mencoba mengklasifikasikan semua contoh
pelatihan dengan benar. Akibatnya, nilai C yang lebih besar cenderung memaksa margin
menjadi lebih rapat dan mempertimbangkan lebih sedikit vektor pendukung. Pengurangan
58
margin seperti itu berarti peningkatan bias dan pengurangan varians. Ini menuntun untuk
menentukan peran pengamatan tertentu sehubungan dengan orang lain; pada
kenyataannya, mendefinisikan sebagai vektor pendukung contoh-contoh yang salah
klasifikasi atau tidak diklasifikasikan dengan pasti karena mereka berada di dalam margin
(pengamatan berisik yang membuat pemisahan kelas tidak mungkin). Pengoptimalan
dimungkinkan hanya dengan mempertimbangkan contoh-contoh seperti itu, menjadikan
SVM teknik yang hemat memori. Pada visualisasi sebelumnya, dapat melihat proyeksi dua
kelompok titik (biru dan putih) pada dua dimensi fitur. Solusi SVM dengan hyperparameter
C yang disetel ke 1.0 dapat dengan mudah menemukan garis pemisah (dalam plot
direpresentasikan sebagai garis kontinu), meskipun ada beberapa kasus yang salah
diklasifikasikan di kedua sisi. Selain itu, margin dapat divisualisasikan (ditentukan oleh dua
garis putus-putus), yang dapat diidentifikasi berkat vektor dukungan dari masing-masing
kelas lebih jauh dari garis pemisah. Pada grafik, vektor pendukung ditandai dengan lingkaran
luar dan benar-benar dapat memperhatikan bahwa beberapa vektor pendukung berada di
luar margin; Hal ini karena kasus tersebut salah diklasifikasikan dan SVM harus melacaknya
untuk tujuan pengoptimalan karena kesalahannya dianggap dalam istilah kerugian.
Meningkatkan nilai C, margin cenderung membatasi karena SVM memperhitungkan
lebih sedikit vektor dukungan dalam proses pengoptimalan. Akibatnya kemiringan garis
pemisah juga berubah. Sebaliknya, nilai C yang lebih kecil cenderung mengendurkan margin,
sehingga meningkatkan varians. Nilai C yang sangat kecil bahkan dapat membuat SVM
mempertimbangkan semua titik contoh di dalam margin. Nilai C yang lebih kecil ideal jika
ada banyak contoh yang berisik. Pengaturan seperti itu memaksa SVM untuk mengabaikan
banyak contoh yang salah diklasifikasikan dalam definisi margin (Kesalahan diberi bobot
lebih sedikit, sehingga lebih ditoleransi saat mencari margin maksimum ). Melanjutkan
contoh visual sebelumnya, jika menurunkan hyperparameter C, margin sebenarnya
mengembang karena jumlah vektor pendukung bertambah. Akibatnya, margin menjadi
berbeda, SVM memutuskan untuk garis pemisah yang berbeda. Tidak ada nilai C yang dapat
dianggap benar sebelum diuji pada data; nilai yang benar harus selalu ditemukan secara
empiris dengan validasi silang. Sejauh ini, C dianggap sebagai hyperparameter terpenting
dalam SVM, untuk disetel setelah memutuskan fungsi kernel yang akan digunakan. Fungsi
59
kernel memetakan fitur asli ke dalam ruang berdimensi lebih tinggi dengan
menggabungkannya secara non linear. Dengan cara demikian, grup yang tampaknya tidak
dapat dipisahkan dalam ruang fitur asli dapat berubah menjadi dapat dipisahkan dalam
representasi berdimensi lebih tinggi. Proyeksi seperti itu tidak memerlukan komputasi yang
terlalu rumit meskipun fakta bahwa proses mengubah secara eksplisit nilai fitur asli menjadi
nilai baru dapat menghasilkan potensi ledakan dalam jumlah fitur saat memproyeksikan ke
dimensi tinggi. Alih-alih melakukan perhitungan yang tidak praktis, fungsi kernel dapat
dengan mudah dicolokkan ke fungsi keputusan, sehingga menggantikan produk titik asli
antara fitur dan vektor koefisien dan mendapatkan hasil pengoptimalan yang sama seperti
yang akan diperoleh dari pemetaan eksplisit. (Penyumbatan seperti itu disebut trik kernel
karena ini benar-benar trik matematika.)
Fungsi kernel standar adalah fungsi linier (tidak menunjukkan transformasi), fungsi
polinomial, fungsi basis radial ( RBF ), dan fungsi sigmoid. Pada dasarnya, RBF dan kernel
lainnya hanya menancapkan dirinya langsung ke varian fungsi yang terlihat sebelumnya
untuk diminimalkan. Fungsi optimisasi yang terlihat sebelumnya disebut formulasi primal
sedangkan ekspresi ulang analog disebut formulasi ganda. Meskipun meneruskan dari
formulasi primal ke formulasi ganda cukup menantang tanpa demonstrasi matematis,
penting untuk memahami bahwa trik kernel, mengingat fungsi kernel yang membandingkan
contoh oleh pasangan, hanyalah masalah sejumlah kalkulasi yang terbatas terkait ke ruang
fitur berdimensi tak hingga itu itu bisa terungkap. Gamma adalah hyperparameter bagi
untuk mendefinisikan a-priori. Transformasi kernel menciptakan semacam gelembung
klasifikasi di vektor pendukung, sehingga memungkinkan definisi bentuk batas yang sangat
kompleks dengan menggabungkan gelembung itu sendiri.
Di sini, selain gamma, r juga harus dipilih untuk hasil terbaik. Jelas, solusi
berdasarkan sigmoid, RBF, dan polinomial, (Ya, secara implisit melakukan ekspansi
polinomial yang akan bicarakan di paragraf berikut.) Kernel menyajikan lebih banyak varian
daripada bias perkiraan, sehingga membutuhkan validasi yang parah saat memutuskan
adopsi mereka. Meskipun SVM resisten terhadap overfitting, SVM tidak kebal terhadapnya.
Mendukung regresi vektor terkait untuk mendukung klasifikasi vektor. Ini bervariasi hanya
untuk notasi (lebih mirip dengan regresi linier, menggunakan beta daripada vektor koefisien
60
w) dan fungsi kerugian. Terlihat, satu-satunya perbedaan yang signifikan adalah fungsi
kerugian L-epsilon, yang tidak sensitif terhadap kesalahan (sehingga tidak menghitungnya)
jika contoh berada dalam jarak tertentu epsilon dari bidang hiper regresi. Minimisasi fungsi
biaya seperti itu mengoptimalkan hasil untuk masalah regresi, nilai keluaran dan bukan
kelas. Pertama, akan memuat dataset Iris:
In: from sklearn import datasets
iris = datasets.load_iris()
X_i, y_i = iris.data, iris.target
Kemudian, akan memasang SVC dengan kernel RBF (C dan gamma dipilih sebagai basis
contoh lain yang diketahui di Scikit-learn) dan uji hasilnya menggunakan cross_val_fungsi
skor.
from sklearn.svm import SVC
from sklearn.cross_validation import cross_val_score
import numpy as np
h_class = SVC(kernel='rbf', C=1.0, gamma=0.7, random_state=101)
scores = cross_val_score(h_class, X_i, y_i, cv=20, scoring='accuracy')
print 'Accuracy: %0.3f' % np.mean(scores)
Output: Accuracy: 0.969
Model yang dipasang dapat memberi indeks yang menunjukkan apa saja dukungannya
vektor di antara contoh pelatihan :
In: h_class.fit(X_i,y_i)
print h_class.support_
Out: [ 13 14 15 22 24 41 44 50 52 56 60 62 63 66 68 70
72 76 77 83 84 85 98 100 106 110 114 117 118 119 121 123 126 127
129 131 133 134 138 141 146 149]
Untuk menguji regressor SVM, mencoba SVR dengan kumpulan data Boston.
Pertama, mengunggah kumpulan data di memori inti dan kemudian mengacak urutannya
61
contoh, terlihat, kumpulan data seperti itu sebenarnya diurutkan dengan cara yang halus,
dengan demikian membuat hasil dari validasi silang yang tidak diacak menjadi tidak valid:
In: import numpy as np
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
boston = load_boston()
shuffled = np.random.permutation(boston.target.size)
X_b = scaler.fit_transform(boston.data[shuffled,:])
y_b = boston.target[shuffled]
RANGKUMAN
Dalam bab ini, memperluas diskusi awal tentang algoritma out-of-core dengan
menambahkan SVM ke model linier berbasis regresi sederhana. Sebagian besar waktu,
berfokus pada implementasi Scikit-learn — kebanyakan SGD — dan diakhiri dengan ikhtisar
alat eksternal yang dapat diintegrasikan dengan skrip Python, seperti Vowpal Wabbit oleh
John Langford. Sepanjang jalan, menyelesaikan ikhtisar tentang peningkatan model dan
teknis validasi saat bekerja di luar inti dengan membahas pengambilan sampel reservoir,
regularisasi, transformasi non linear eksplisit dan implisit, serta pengoptimalan
hyperparameter.
Di bab berikutnya, akan terlibat dengan pendekatan pembelajaran yang lebih kompleks dan
kuat sembari menyajikan pembelajaran mendalam dan jaringan saraf dalam masalah skala
besar. Jika proyek berkisar pada analisis gambar dan suara, apa yang telah lihat sejauh ini
mungkin belum menjadi solusi ajaib yang cari. Bab selanjutnya akan memberikan semua
solusi yang diinginkan.
62
DAFTAR PUSTAKA
Putra
LATIHAN
1. Lakukan proses installasi Vowpal Wabbit (VW) yang diperoleh dari GitHub secara
online versioning repositori (https: //. Github com / JohnLangford / vowpal_wabbit),
di mana itu bisa Git-kloning atau hanya download dalam bentuk sebuah zip.
2. Jelaskan tentang hyperland pada algoritma Support Vector Machine dan apa
perbedaannya dengan algoritma klasifikasi dengan lainnya.
63
BAB V
ARTIFICIAL NEURAL NETWORK
- Mahasiswa mampu menjelaskan artificial neural network dalam Machine Learning.

- Mahasiswa mampu menguraikan artificial neural network dalam Machine Learning.
- Mahasiswa mampu merancang forward dan back propagation dalam machine Learning.
- Mahasiswa mampu mendemostrasikan jaringan syaraf tiruan di Python 3 untuk
pembelajaran Machine Learning.
- Mahasiswa mampu mengkode artificial neural network dengan bahasa pemrograman
Python.
- Mahasiswa mampu mempraktekkan algoritma artificial neural network pada Jupyter
Notebook.
- Mahasiswa mampu menguji algoritma-algoritma artificial neural network pada Jupyter
Notebook.
MATERI
5.1 Pendahuluan Artificial Neural Network
Jaringan saraf tiruan (Artifial Neural Network) merupakan salah satu sistem pemprosesan
informasi yang di desain dengan menirukan cara kerja otak manusia dalam menyelesaikan
suatu masalah dengan mulakukan proses belajar melalui perubahan bobot sinapsisnya.
Jaringan saraf tiruan mampu melakukan pengenalan kegiatan berbasis data masa lalu.
64
Data masa lalu akan di pelajari oleh jaringan syaraf tiruan sehingga mempunyai kemampuan
untuk memberikan keputusan terhadap data yang belum pernah dipelajari. Sejak
ditemukan pertamakali oleh Mc.Culloch dan Pitts sistem jaringan syaraf tiruan
berkembang pesat dan banyak di gunakan oleh banyak aplikasi, jaringan syaraf tiruan
(Artificial Nural Network) adalah suatu jaringan untuk memodelkan cara kerja sistem syaraf
manusia (otak) dalam melaksanakan tugas tertentu. Pemodelan ini didasari oleh
kemampuan otak manusia dalam mengorganisasi sel – sel penyusunan (neuron),
sehingga memiliki kemampuan untuk melaksanakan tugas –tugas tertentu khususnya
pengenalan pola dengan efektifitas jaringan tertinggi. Sekarang mari fokus pada
bagaimana jaringan neural diatur, mulai dari arsitektur dan beberapa definisi. Jaringan
tempat aliran pembelajaran diteruskan hingga keluaran one pass disebut sebagai jaringan
neural feedforward. Jaringan neural feedforward dasar dapat dengan mudah digambarkan
oleh diagram jaringan.
5.2 Forward propagation
Pada prediksi akhir dengan melakukan langkah-langkah berikut:

1) Melakukan produk titik pada input dengan bobot di antara yang pertama dan lapisan
kedua dan mengubah hasil dengan fungsi aktivasi .
2) Melakukan produk titik pada keluaran dari lapisan tersembunyi pertama dengan
bobot antara lapisan kedua dan ketiga. Hasil ini kemudian diubah dengan fungsi
aktivasi pada setiap unit lapisan tersembunyi kedua .
3) Akhirnya, sampai pada prediksi dengan mengalikan vektor dengan yang fungsi
aktivasi (softmax untuk klasifikasi).
65
Gambar 7. Forward propagation
Jaringan saraf dengan dua lapisan tersembunyi dengan NumPy :

import numpy as np
import math
b1=0 #bias unit 1
b2=0 #bias unit 2
def sigmoid(x): # sigmoid function
return 1 /(1+(math.e**-x))
def softmax(x): #softmax function
l_exp = np.exp(x)
sm = l_exp/np.sum(l_exp, axis=0)
return sm
# input dataset with 3 features
X = np.array([ [.35,.21,.33],
[.2,.4,.3],
[.4,.34,.5],
66
[.18,.21,16] ])
len_X = len(X) # training set size
input_dim = 3 # input layer dimensionality
output_dim = 1 # output layer dimensionality
hidden_units=4
np.random.seed(22)
# create random weight vectors
theta0 = 2*np.random.random((input_dim, hidden_units))
theta1 = 2*np.random.random((hidden_units, output_dim))
# forward propagation pass
d1 = X.dot(theta0)+b1
l1=sigmoid(d1)
l2 = l1.dot(theta1)+b2
#let's apply softmax to the output of the final layer
output=softmax(l2)
5.3 Backpropagation
Dengan contoh feedforward sederhana, telah mengambil langkah pertama dalam melatih
model. Jaringan neural dilatih sangat mirip dengan metode penurunan gradien yang telah
lihat pada algoritma pembelajaran mesin lainnya. Yaitu, meningkatkan parameter model
untuk menemukan minimum global dari fungsi kesalahan. Sebuah perbedaan penting
dengan jaringan neural adalah sekarang harus menangani beberapa unit di seluruh jaringan
yang perlu latih secara mandiri. Ringkasan langkah-langkah berikut dalam algoritma
propagasi mundur:
1) Umpan maju: Kami secara acak menginisialisasi vektor bobot dan mengalikannya
masukan dengan vektor bobot berikutnya menuju keluaran akhir.
2) Hitung kesalahan: Kami menghitung kesalahan / kehilangan output dari langkah maju
umpan.
3) Inisialisasi vektor bobot secara acak.
67
4) Propagasi mundur ke lapisan tersembunyi terakhir (sehubungan dengan keluaran). Kami
menghitung gradien kesalahan ini dan mengubah bobot ke arah gradien. Kami
melakukan ini dengan mengalikan vektor bobot j dengan gradien dilakukan.
5) Perbarui bobot hingga kriteria penghentian tercapai (kesalahan minimum atau jumlah
putaran pelatihan ):
Sekarang telah membahas umpan maju dari jaringan saraf dua lapis yang berubah-ubah;
mari terapkan backpropagation dengan SGD di NumPy ke input yang sama yang gunakan
contoh sebelumnya:
import numpy as np
import math
def sigmoid(x): # sigmoid function
return 1 /(1+(math.e**-x))
def deriv_sigmoid(y): #the derivative of the sigmoid function
return y * (1.0 - y)
alpha=.1 #this is the learning rate
X = np.array([ [.35,.21,.33],
[.2,.4,.3],
[.4,.34,.5],
[.18,.21,16] ])
y = np.array([[0],
[1],
[1],
[0]])
np.random.seed(1)
#We randomly initialize the layers
theta0 = 2*np.random.random((3,4)) - 1
theta1 = 2*np.random.random((4,1)) - 1
for iter in range(205000): #here we specify the amount of training
68
rounds.
# Feedforward the input like we did in the previous exercise
input_layer = X
l1 = sigmoid(np.dot(input_layer,theta0))
l2 = sigmoid(np.dot(l1,theta1))
# Calculate error
l2_error = y - l2
if (iter% 1000) == 0:
print "Neuralnet accuracy:" + str(np.mean(1-(np.abs(l2_
error))))
# Calculate the gradients in vectorized form
# Softmax and bias units are left out for instructional simplicity
l2_delta = alpha*(l2_error*deriv_sigmoid(l2))
l1_error = l2_delta.dot(theta1.T)
l1_delta = alpha*(l1_error * deriv_sigmoid(l1))
theta1 += l1.T.dot(l2_delta)
theta0 += input_layer.T.dot(l1_delta)
RANGKUMAN
Jaringan saraf tiruan (Artifial Neural Network) merupakan salah satu sistem pemprosesan
informasi yang di desain dengan menirukan cara kerja otak manusia dalam menyelesaikan
suatu masalah dengan mulakukan proses belajar melalui perubahan bobot sinapsisnya.
Jaringan saraf tiruan mampu melakukan pengenalan kegiatan berbasis data masa lalu.
Data masa lalu akan di pelajari oleh jaringan syaraf tiruan sehingga mempunyai kemampuan
untuk memberikan keputusan terhadap data yang belum pernah dipelajari.
69
DAFTAR PUSTAKA
Putra
LATIHAN
1. Lakukan proses instalasi dan praktekkan algoritma Neural Network pada aplikasi
Neurolab, lakukan coding seperti berikut:
> $ pip instal neurolab
Dengan contoh ini, akan menghasilkan fungsi kosinus non linear sederhana
dengan numpy dan melatih jaringan saraf untuk memprediksi fungsi kosinus dari
suatu variabel. Beberapa arsitektur jaringan saraf untuk melihat seberapa baik
setiap arsitektur dapat memprediksi variabel target kosinus:
impor neurolab sebagai

nl impor numpy sebagai
np
dari sklearn import preprocessing
import matplotlib.pyplot sebagai plt
plt.style.use ('ggplot')
# Buat sampel kereta
x = np.linspace (-10,10, 60) y =

np.cos (x) * 0,9
70
size = len (x)
x_train = x.reshape (ukuran, 1)

y_train = y.reshape (ukuran, 1)
d = [[1,1], [45,1], [45,45,1], [45,45,45,1]]
untuk saya dalam jangkauan (4):
net = nl.net.newff ([[- 10, 10]], d [i]) train_net = nl.train.train_gd (net,

x_train, y_train, epochs = 1000,
tampilkan = 100)
outp = net.sim (x_train)
# Hasil plot (plot ganda dengan kurva kesalahan dan nilai prediksi) impor
matplotlib.pyplot
plt.subplot (2, 1, 1)
plt.plot (train_net) plt.xlabel

('Epochs') plt.ylabel ('kesalahan
kuadrat')
x2 = np.linspace (-10.0,10.0,150)
y2 = net.sim (x2.reshape (x2.size, 1)). reshape (x2.size) y3 =

outp.reshape (ukuran)
plt.subplot (2, 1, 2)
plt.suptitle ([i, 'hidden layers']) plt.plot (x2, y2, '-',

x, y, '.', x, y3, 'p') plt.legend (['y predict' ,
'y_target']) plt.show ()
2. Lakukan analisis pada hasil code program diatas, dan jelaskan konsep dari algoritma
neural Network
71
BAB VI
DEEP LEARNING
- Mahasiswa mampu menguraikan dan menerangkan tentang Deep Learning.

- Mahasiswa mampu mendemostrasikan deep learning H2O untuk pembelajaran Machine
Learning.
- Mahasiswa mampu mengkode deep learning H2O dengan bahasa pemrograman Python.
- Mahasiswa mampu mempraktekkan deep learning H2O pada Jupyter Notebook.
- Mahasiswa mampu menguji deep learning H2O pada Jupyter Notebook.
MATERI
6.1 Deep Learning Dengan H2o
Pada deep learning H2O, dataset yang akan gunakan untuk melatih adalah dataset MNIST
yang terkenal. Ini terdiri dari intensitas piksel gambar 28 x 28 dari digit tulisan tangan. Set
pelatihan memiliki 70.000 item pelatihan dengan 784 fitur bersama dengan label untuk
setiap rekaman yang berisi digit label target .
Gambar 8. H2O
72
Mari impor kumpulan data gambar digit tulisan tangan terkenal MNIST dari Amazon server
ke cluster H2O:
impor h2o h2o.init (start_h2o = True)

train_url = "https://h2o-public-test-data.s3.amazonaws.com/bigdata/ laptop /
mnist/ train.csv.gz"
test_url = "https://h2o-public-test-data.s3.amazonaws.com/bigdata/ laptop / mnist
/ test.csv.gz"
train = h2o.import_file (train_url) test =
h2o.import_file (test_url)
train.describe
() test.describe ()
y = 'C785'
x = train.names [0: 784] train [y] = train

[y] .asfactor () test [y] = test [y] .asfactor
()
dari h2o.estimators.deeplearning impor H2ODeepLearningEstimator model_cv =
H2ODeepLearningEstimator (distribusi =
'multinomial'
dden = [32,32,32],
, aktivasi = 'RectifierWithDropout', hai

input_dropout_ratio = .2, sparse = True,
l1 = .0005,
zaman = 5)
73
Dalam pembelajaran mendalam H2O, dataset yang akan gunakan untuk melatih
adalah MNIST yang terkenal. Ini terdiri dari intensitas piksel gambar 28 x 28 dari digit tulisan
tangan. Itu set pelatihan memiliki 70.000 item pelatihan dengan 784 fitur bersama dengan
label untuk masing-masing item catatan yang berisi digit label target . Sekarang setelah
74
lebih nyaman dengan mengelola data di H2O, mari lakukan lebih dalam contoh
pembelajaran. Di H2O, tidak perlu mengubah atau menormalkan data masukan; itu standar
secara internal dan otomatis. Setiap fitur diubah menjadi ruang N (0,1). Mari impor
kumpulan data gambar digit tulisan tangan terkenal MNIST dari Amazon server ke cluster
H2O.
import h2o
h2o.init(start_h2o=True)
train_url ="https://h2o-public-test-data.s3.amazonaws.com/bigdata/
laptop/mnist/train.csv.gz"
test_url="https://h2o-public-test-data.s3.amazonaws.com/bigdata/
laptop/mnist/test.csv.gz"
train=h2o.import_file(train_url)
test=h2o.import_file(test_url)
train.describe()
test.describe()
y='C785'
x=train.names[0:784]
train[y]=train[y].asfactor()
test[y]=test[y].asfactor()
from h2o.estimators.deeplearning import H2ODeepLearningEstimator
model_cv=H2ODeepLearningEstimator(distribution='multinomial'
,activation='RectifierWithDropout',hi
dden=[32,32,32],
input_dropout_ratio=.2,
sparse=True,
l1=.0005,
epochs=5)
75
6.2 Deep Learning With Theanets
Neural Networks (Deep Learning), yaitu keluarga algoritma yang dikenal sebagai jaringan
saraf baru-baru ini mengalami kembali namanya "pembelajaran mendalam". Sementara
pembelajaran mendalam menunjukkan janji besar di banyak mesin. Aplikasi pembelajaran,
algoritma pembelajaran yang dalam sering disesuaikan dengan sangat hati-hati untuk kasus
penggunaan khusus. Di sini, hanya akan membahas beberapa metode yang relatif
sederhana, yaitu multilayer perceptrons untuk klasifikasi dan regresi, yang dapat berfungsi
sebagai permulaan poin untuk metode pembelajaran mendalam yang lebih terlibat.
Multilayer perceptrons (MLP) adalah juga dikenal sebagai (vanilla) feed-forward neural
network, atau terkadang hanya neural jaringan. MLPs can be viewed as generalizations of
linear models that perform multiple stages of processing to come to a decision. Ingat bahwa
prediksi oleh regressor linier diberikan sebagai:
ŷ = w [0] * x [0] + w [1] * x [1] + ... + w [p] * x [p] + b
Dalam bahasa Inggris sederhana, ŷ adalah jumlah bobot dari fitur masukan x [0] hingga x [p],
berbobot dengan koefisien dipelajari w [0] ke w [p]. Kami dapat memvisualisasikan ini
secara grafis.
Gambar 9. Neural network model
Di sini, setiap node di sebelah kiri mewakili fitur masukan, mewakili garis
penghubung koefisien yang dipelajari, dan simpul di sebelah kanan mewakili keluaran, yaitu
jumlah input yang tertimbang. Dalam MLP, proses penghitungan jumlah tertimbang ini
diulangi beberapa kali, pertama menghitung unit tersembunyi yang mewakili langkah
76
pemrosesan menengah, yaitu digabungkan lagi menggunakan jumlah tertimbang untuk
menghasilkan hasil akhir.Untuk topik selanjutnya, di mana akan mendalami lebih dalam
metode pembelajaran mendalam, membutuhkan perpustakaan lain. Dalam bab ini, akan
fokus theanets. Karena kemudahan penggunaan dan stabilitasnya, sangat halus dan paket
yang dirawat dengan baik yang dikembangkan oleh Lief Johnson di University of Texas.
Untuk informasi lebih lanjut, dapat mengunjungi http: //theanets.readthedocs.org / id /
stable /.
Yang harus lakukan adalah menginstal theanets dengan pip :
$ pip instal theanets
Karena theanets dibangun di atas Theano, juga harus memiliki Theano dengan benar
terpasang.
import climate # This package provides the reporting of iterations
from sklearn.metrics import confusion_matrix
import numpy as np
from sklearn import datasets
from sklearn.cross_validation import train_test_split
from sklearn.metrics import mean_squared_error
import theanets
import theano
import numpy as np
import matplotlib.pyplot as plt
import climate
import theanets
from sklearn import preprocessing
from sklearn.metrics import accuracy_score
from sklearn import datasets
climate.enable_default_logging()
digits = datasets.load_digits()
77
digits = datasets.load_digits()
X = np.asarray(digits.data, 'float32')
Y = digits.target
Y=np.array(Y, dtype=np.int32)
#X = (X - np.min(X, 0)) / (np.max(X, 0) + 0.0001) # 0-1 scaling
X_train, X_test, y_train, y_test = train_test_split(X, Y,
test_size=0.2,
random_state=0)
# Build a classifier model with 64 inputs, 1 hidden layer with 100
units and 10 outputs.
net = theanets.Classifier([64,100,10])
# Train the model using Resilient backpropagation and momentum.
net.train([X_train,y_train], algo='sgd', learning_rate=.001,
momentum=0.9,patience=0,
validate_every=N,
min_improvement=0.8)
# Show confusion matrices on the training/validation splits.
print(confusion_matrix(y_test, net.predict(X_test)))
print (accuracy_score(y_test, net.predict(X_test)))
RANGKUMAN
Neural Networks (Deep Learning), yaitu keluarga algoritma yang dikenal sebagai jaringan
saraf baru-baru ini mengalami kebangkitan kembali Namanya. Multilayer perceptrons untuk
klasifikasi dan regresi, yang dapat berfungsi sebagai permulaan poin untuk metode
pembelajaran mendalam yang lebih terlibat. Multilayer perceptrons (MLP) adalah juga
dikenal sebagai (vanilla) feed-forward neural network, atau terkadang hanya neural jaringan.
78
DAFTAR PUSTAKA
1 Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca
Massaron, Alberto Boschetti. ISBN 978-1-78588-721-5
2 Machine Learning Tingkat Dasar dan Lanjut, 2018. Suyanto, Informatika Bandung
3 Introduction to Machine Learning with Python A Guide for Data Scientists, 2017.
Andreas C. Müller and Sarah Guido
LATIHAN
1. Buatlah koding deep learning dengan theanets dan lakukan pengujian dataset
dengan aplikasi Rafid Miner.
2. Lakukan pengujian, evaluasi dan buatlah laporan outputnya!
79
BAB VII
TENSOR FLOW
- Mahasiswa mampu menerangkan tentang operasi tensorflow dasar.

- Mahasiswa mampu memperluas tentang operasi tensorflow dasar.
- Mahasiswa mampu mendemostrasikan instalasi tensor flow Python 3 untuk
pembelajaran Machine Learning.
- Mahasiswa mampu mengkode tensorflow Machine Learning dengan bahasa
pemrograman Python.
- Mahasiswa mampu mempraktekkan tensorflow Machine Learning pada Jupyter
Notebook.
- Mahasiswa mampu menguji tensorflow Machine Learning pada Jupyter Notebook.
.
MATERI
7.1 Metode TensorFlow
TensorFlow dimulai oleh Tim Google Brain yang terdiri dari sebagian besar peneliti yang
mengerjakan pengembangan penting dalam pembelajaran mendalam dalam dekade
terakhir (Geoffrey Hinton, Samy Bengio, dan lainnya). Ini pada dasarnya adalah
pengembangan generasi berikutnya dari kerangka kerja generasi sebelumnya yang disebut
DistBelief, platform untuk jaringan neural dalam terdistribusi. Berlawanan dengan
TensorFlow, DistBelief bukanlah open source. Contoh menarik dari proyek DistBelief yang
sukses adalah mesin pencari gambar terbalik, mimpi mendalam Google, dan pengenalan
ucapan di aplikasi Google. DistBelief memungkinkan pengembang Google menggunakan
80
ribuan inti (baik CPU maupun GPU) untuk pelatihan terdistribusi. TensorFlow adalah
peningkatan dari DistBelief yang sekarang sepenuhnya open source dan bahasa
pemrogramannya tidak terlalu abstrak. TensorFlow mengklaim lebih fleksibel dan memiliki
aplikasi yang lebih luas. Pada saat penulisan (akhir 2015), framework TensorFlow masih
dalam tahap awal dan paket ringan menarik yang dibangun di atas TensorFlow telah muncul.
Mirip dengan Theano, TensorFlow beroperasi dengan komputasi simbolis pada tensor; ini
berarti bahwa sebagian besar dari yang perhitungan yang didasarkan pada vektor-dan
matriks perkalian. Bahasa pemrograman reguler menentukan variabel yang berisi nilai atau
karakter yang dapat diterapkan operasi.
Gambar 10. Tensorflow
Tensorflow memiliki fitur dan aplikasi berikut:

1) TensorFlow dapat diparalelkan (secara horizontal) dengan beberapa GPU
2) Kerangka pengembangan juga tersedia untuk penyebaran seluler
3) TensorBoard adalah dasbord untuk visualisasi (pada tahap prematur )
4) Ini adalah antarmuka untuk beberapa bahasa pemrograman (Python Go, Java, Lua,
JavaScript, R, C ++, dan segera Julia)
5) Ini memberikan integrasi untuk solusi skala besar seperti Spark dan Google Cloud
Platform ( https://cloud.google.com/ml/ )
7.2 Penginstalan TensorFlow
Versi TensorFlow yang akan gunakan dalam bab ini adalah 0.8 jadi pastikan
menginstal versi ini. Karena TensorFlow sedang dalam pengembangan besar,
81
perubahan kecil akan terjadi. Menginstal TensorFlow dengan cukup mudah dengan
penginstalan pip , terlepas dari sistem operasi mana yang gunakan:
pip instal tensorflow
Sekarang setelah TensorFlow diinstal, dapat mengujinya di terminal:
$ Python
impor tensorflow sebagai tf
hello = tf.constant ('Halo, TensorFlow!') sess = tf.Session

() print (sess.run (halo))
Output Halo, TensorFlow!
Perbedaan penting adalah dengan TensorFlow, pertama-tama perlu menginisialisasi variabel

sebelum dapat menerapkan operasi padanya. TensorFlow beroperasi pada C ++ backend
untuk melakukan komputasi jadi, untuk terhubung ke backend ini, perlu membuat contoh
sesi terlebih dahulu.
x = tf.constant([22,21,32], name='x')
d=tf.constant([12,23,43],name='d')
y = tf.Variable(x * d, name='y')
model = tf.initialize_all_variables()
with tf.Session() as session:
session.run(model)
print(session.run(y))
Jika ingin melakukan operasi TensorFlow pada GPU, perlu menentukan file alat. Berhati-
hatilah; ini hanya berfungsi dengan pemasangan yang benar, kompatibel dengan CUDA, Unit
GPU NVIDIA:
with tf.device('/gpu:0'):
product = tf.matmul(matrix1, matrix2)
with tf.Session() as sess:
result = sess.run(product)
82
matrix3 = tf.constant([[13, 21,53], [4, 3,6],[3,1,61]])
matrix4 = tf.constant([[13,23,32], [23, 16,2],[35,51,31]])
Sekarang setelah membahas dasar-dasarnya, dapat mulai menulis pembelajaran

mesin pertama algoritma dari awal dalam framework TensorFlow. Nanti, akan menggunakan
lebih banyak aplikasi ringan yang praktis dalam abstraksi yang lebih tinggi selain TensorFlow.
Melakukan regresi linier yang sangat sederhana dengan penurunan gradien stokastik di
untuk memahami cara kerja pelatihan dan evaluasi di TensorFlow. Pertama akan membuat
beberapa variabel untuk dikerjakan untuk menguraikannya di tempat penampung
mengandung variabel tersebut. Kami kemudian memasukkan x dan y ke fungsi biaya dan
melatih model dengan penurunan gradien:
import tensorflow as tf
import numpy as np
X = tf.placeholder("float") # create symbolic variables
Y = tf.placeholder("float")
X_train = np.asarray([1,2.2,3.3,4.1,5.2])
Y_train = np.asarray([2,3,3.3,4.1,3.9,1.6])
def model(X, w):
return tf.mul(X, w)
w = tf.Variable(0.0, name="weights")
y_model = model(X, w) # our predicted values
cost = (tf.pow(Y-y_model, 2)) # squared error cost
83
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost) #sgd
optimization
sess = tf.Session()
init = tf.initialize_all_variables()
sess.run(init)
for trials in range(50): #
for (x, y) in zip(X_train, Y_train):
sess.run(train_op, feed_dict={X: x, Y: y})
print(sess.run(w))
Sekarang mari lakukan jaringan saraf dalam bahasa TensorFlow dan membedahnya
prosesnya:
import tensorflow as tf
import numpy as np
from sklearn import cross_validation
from sklearn.preprocessing import OneHotEncoder
from sklearn.utils import shuffle
import os
import pandas as pd
from datetime import datetime as dt
import logging
iris = datasets.load_iris()
X = np.asarray(iris.data, 'float32')
Y = iris.target
X= preprocessing.scale(X)
min_max_scaler = preprocessing.MinMaxScaler()
X = min_max_scaler.fit_transform(X)
84
lb = preprocessing.LabelBinarizer()
Y=lb.fit_transform(iris.target)
w_h = init_weights([4, 4])
w_o = init_weights([4, 3])
py_x = model(X, w_h, w_o)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(py_x,
Y)) # compute costs
train_op = tf.train.GradientDescentOptimizer(learning_rate=0.01).
minimize(cost) # construct an optimizer
predict_op = tf.argmax(py_x, 1)
sess = tf.Session()
init = tf.initialize_all_variables()
sess.run(init)
for i in range(500):
for start, end in zip(range(0, len(X_train),1 ), range(1, len(X_
train),1)):
sess.run(train_op, feed_dict={X: X_train[start:end], Y: y_
train[start:end]})
if i % 100 == 0:
print i, np.mean(np.argmax(y_test, axis=1) ==
sess.run(predict_op, feed_dict={X: x_test, Y: y_
test}))
85
RANGKUMAN
TensorFlow adalah pengembangan generasi berikutnya dari kerangka kerja generasi

sebelumnya yang disebut DistBelief, platform untuk jaringan neural dalam terdistribusi.
Framework TensorFlow masih dalam tahap awal dan paket ringan menarik yang dibangun di
atas TensorFlow telah muncul.
Mirip dengan Theano, TensorFlow beroperasi dengan komputasi simbolis pada tensor; ini
berarti bahwa sebagian besar dari yang perhitungan yang didasarkan pada vektor-dan
matriks perkalian. Bahasa pemrograman reguler menentukan variabel yang berisi nilai atau
karakter yang dapat diterapkan operasi.
DAFTAR PUSTAKA
3. Introduction to Machine Learning with Python A Guide for Data Scientists, 2017.
86
LATIHAN
1. Lakukan Praktek dan buatlah laporan outputnya Machine Learning di

TensorFlow dengan SkFlow dan lakukan instalasi langsung dari Git Hub
$ pip instal git + git: //github.com/tensorflow/skflow.git

dari sklearn.metrics impor akurasi_score
impor skflow
import urllib2
url = 'https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/
multiclass / wine.scale'
set1 = urllib2.Request (url)
wine = urllib2.urlopen
(set1)
dari sklearn.datasets impor load_svmlight_file

X_train, y_train = load_svmlight_file (anggur)
X_train = X_train.toarray ()
dari sklearn.cross_validation import train_test_split X_train,

X_test, y_train, y_test = train_test_split (X_train, y_train,
test_size = 0,30, random_state = 4)
classifier = skflow.TensorFlowLinearClassifier (n_classes = 4, learning_ rate =

0.01, optimizer = 'SGD', continue_training = True, langkah = 1000) classifier.fit
(X_train, y_train)
skor = akurasi_ skor (y_train, classifier.predict (X_train)) d = classifier.predict

(X_test)
print ("Akurasi:% f"% skor)
c = akurasi_skor (d, uji_y) cetak ('validasi

/ uji akurasi:% f'% c)
2. Jelaskan secara detail cara kerja TensorFlow dan fitur yang dimiliki ?
87
BAB VIII
KLASIFIKASI DAN REGRESI POHON
- Mahasiswa mampu menerapkan metode skalabel untuk klasifikasi dan regresi pohon.
- Mahasiswa mampu mendemostrasikan regresi dengan XGBoost untuk pembelajaran
Machine Learning.
- Mahasiswa mampu mengkode klasifikasi dan regresi Machine Learning dengan bahasa
pemrograman Python.
- Mahasiswa mampu mempraktekkan klasifikasi dan regresi Machine Learning pada
XGBoost.
- Mahasiswa mampu menguji klasifikasi dan regresi Machine Learning pada XGBoost.
MATERI
8.1 Pendahuluan Klasifikasi Dan Regresi
Proses identifikasi relasi dan pengaruhnya pada nilai-nilai objek. Regresi berusaha
menemukan suatu fungsi yang memodelkan data dengan meminimalkan galat (selisih)
antara nilai prediksi atau peramalan dengan nilai sebenarnya. Regresi sebagai alat ukur
untuk mengetahui adanya korelasi antar variabel. Analisis regresi dapat menentukan tingkat
perubahan suatu variabel terhadap variabel lainnya. Regression umumnya digunakan untuk
prediksi (prediction) dan peramalan (forecasting). Prediksi digunakan untuk memperkirakan
nilai-nilai data bertipe apa saja dan kapan saja (masa lalu, sekarang, dan masa depan)
Peramalan digunakan untuk memperkirakan nilai-nilai data time series di masa depan Ada
satu istilah lain yang mirip dan seringkali rancu dengan prediksi dan peramalan, yaitu
proyeksi (projection). Tujuan dari pohon keputusan adalah untuk mempelajari serangkaian
88
aturan keputusan untuk menyimpulkan label target berdasarkan data pelatihan.
Menggunakan algoritma rekursif, proses dimulai dari akar pohon dan membagi data pada
fitur yang menghasilkan pengotor terendah. Saat ini, aplikasi berbasis pohon terukur yang
paling banyak diterapkan didasarkan pada CART. Diperkenalkan oleh Breiman, Friedman
Stone, dan Ohlson pada tahun 1984, CART merupakan singkatan dari Classification and
Regression Trees.
Untuk mendapatkan intuisi tentang bagaimana proses ini bekerja, mari buat pohon
keputusan dengan Scikit-learn dan visualisasikan dengan grafik. Pertama, buat dataset untuk
melihat apakah bisa memprediksi siapa perokok dan siapa yang bukan berdasarkan IQ
(numerik), usia (numerik), pendapatan tahunan (numerik), pemilik bisnis (Boolean), dan
gelar sarjana (Boolean) . perlu mengunduh perangkat lunak dari http://www.graphviz.org
untuk memuat visualisasi file tree.dot yang akan buat Scikit-learn:
dari pohon impor sklearn iq =

[90.110.100.140.110.100] umur =
[42,20,50,40,70,50] anincome =
[40,20,46,28,100,20]
pemilik bisnis = [0,1,0,1,0,0] gelar
universitas = [0,1,0,1,0,0] merokok =
[1,0,0,1,1,0]
ids = np.column_stack ((iq, age, anincome, businessowner, univdegree)) names =
['iq', 'age', 'income', 'univdegree']
dt = tree.DecisionTreeClassifier (random_state = 99) dt.fit (id,
merokok)
dt.predict (ids) tree.export_graphviz (dt, out_file = 'tree2.dot', feature_
names = names, label = all, max_depth = 5, class_names = True)
Sekarang dapat menemukan file tree.dot di direktori kerja . Setelah menemukan file ini,
dapat membukanya dengan software grafik:
89
Gambar 11. Pohon keputusan
8.2 Bootstrap
Bagging adalah singkatan dari bootstrap aggregation . Teknik bootstrap berasal dari konteks
di mana analis harus berurusan dengan kelangkaan data. Dengan pendekatan statistik ini,
subsampel digunakan untuk memperkirakan parameter populasi ketika distribusi statistik
tidak dapat ditentukan secara apriori. Tujuan bootstrap adalah untuk memberikan perkiraan
yang lebih kuat untuk parameter populasi di mana lebih banyak variabilitas diperkenalkan
ke kumpulan data yang lebih kecil dengan subsampling acak dengan penggantian.
Gambar 12. Bootstrap

90
Sebagai contoh bagaimana menskalakan ansambel pohon inti, akan menjalankan
contoh di mana menerapkan metode hutan acak yang efisien untuk data kredit. Dataset ini
digunakan untuk memprediksi tarif default klien kartu kredit. Data terdiri dari 18 fitur dan
30.000 contoh pelatihan. Karena perlu mengimpor file dalam format XLS, perlu menginstal
yang xlrd paket, dan dapat mencapai ini dengan mengetikkan berikut di command yang
terminal jalur.
$ pip install xlrd
import pandas as pd
import numpy as np
import os
import xlrd
import urllib
#set your path here
os.chdir('/your-path-here')
url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00350/
default%20of%20credit%20card%20clients.xls'
filename='creditdefault.xls'
urllib.urlretrieve(url, filename)
target = 'default payment next month'
data = pd.read_excel('creditdefault.xls', skiprows=1)
target = 'default payment next month'
y = np.asarray(data[target])
features = data.columns.drop(['ID', target])
X = np.asarray(data[features])
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.cross_validation import cross_val_score
from sklearn.datasets import make_classification
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.30,
random_state=101)
91
clf = ExtraTreesClassifier(n_estimators=500, random_state=101)
clf.fit(X_train,y_train)
scores = cross_val_score(clf, X_train, y_train, cv=3,scoring='accuracy',
n_jobs=-1)
print "ExtraTreesClassifier -> cross validation accuracy: mean = %0.3f
std = %0.3f" % (np.mean(scores), np.std(scores))
Sekarang memiliki beberapa estimasi dasar dari akurasi set pelatihan, mari lihat seberapa
baik performanya di set pengujian.
y_pred=clf.predict(X_test)
confusionMatrix = confusion_matrix(y_test, y_pred)
print confusionMatrix
accuracy_score(y_test, y_pred)
OUTPUT:
[[6610 448]
[1238 704]]
Our overall test accuracy:
0.81266666666666665
8.3 XGBoost
XGBoost singkatan untuk Ekstrim Gradient, sebuah open source gradien meningkatkan
algoritma yang telah memperoleh banyak popularitas di kompetisi sains data seperti Kaggle
( https://www.kaggle.com/ ) dan KDD-cup 2015. (Kode ini tersedia di GitHub di
https://github.com/dmlc/XGBoost. Terlepas dari pertunjukan sukses di kedua akurasi dan
efisiensi komputasi, perhatian utama dalam buku ini adalah skalabilitas, dan XGBoost
adalah memang sebuah solusi scalable dari berbagai dari pandangan. XGBoost adalah
generasi baru dari algoritma GBM dengan perubahan penting pada algoritma GBM
pendorong pohon awal .
92
Gambar 13. XGBoost
XGBoost menyediakan pemrosesan paralel; yang skalabilitas yang ditawarkan oleh algoritma
adalah karena cukup beberapa baru tweak dan penambahan dikembangkan:
1) Algoritma yang menerima data renggang, yang dapat memanfaatkan matriks
renggang, menghemat memori (tidak perlu matriks padat) dan waktu komputasi (nilai
nol ditangani dengan cara khusus )
2) Perkiraan pembelajaran pohon (sketsa kwantil berbobot), yang memberikan hasil yang
sama tetapi dalam waktu yang jauh lebih singkat daripada eksplorasi lengkap klasik
dari kemungkinan pemotongan cabang
3) Komputasi paralel pada satu mesin (menggunakan multithreading dalam fase
pencarian pemisahan terbaik) dan komputasi yang didistribusikan secara serupa pada
beberapa mesin
4) Perhitungan out-of-core pada satu mesin yang memanfaatkan solusi penyimpanan
data yang disebut Blok Kolom, yang mengatur data pada disk per kolom, sehingga
menghemat waktu dengan menarik data dari disk seperti yang diharapkan oleh
algoritma pengoptimalan (yang bekerja pada vektor kolom)
Dari sudut pandang praktis, fitur XGBoost sebagian besar memiliki parameter yang sama
dengan GBM. XGBoost juga cukup mampu menangani data yang hilang. Ansambel pohon
lainnya, berdasarkan pohon keputusan standar, memerlukan data yang hilang terlebih
dahulu untuk diperhitungkan menggunakan nilai di luar skala (seperti bilangan negatif yang
besar) untuk mengembangkan percabangan pohon yang sesuai untuk menangani nilai yang
hilang. XGBoost, sebaliknya, pertama-tama cocok dengan semua nilai yang tidak hilang dan,
93
setelah membuat percabangan untuk variabel, ia memutuskan cabang mana yang lebih baik
untuk diambil nilai yang hilang untuk meminimalkan kesalahan prediksi. Pendekatan seperti
itu mengarah ke pohon yang lebih kompak dan strategi imputasi yang efektif yang
mengarah pada kekuatan prediksi yang lebih besar. Parameter XGBoost terpenting adalah
sebagai berikut:
1) Eta (default = 0.3): Ini setara dengan kecepatan pembelajaran di Scikit-learn's
GBM
2) Min_Child_Weight (default = 1): Nilai yang lebih tinggi mencegah overfitting dan
kompleksitas pohon max_depth (default = 6): Ini adalah jumlah interaksi di pohon
3) Subsampel (default = 1): Ini adalah sebagian kecil dari sampel data pelatihan yang
ambil di setiap iterasi
4) Colsample_Bytree (default = 1): Ini adalah pecahan fitur di setiap iterasi
5) Lambda (default = 1): Ini adalah regularisasi L2 (Boolean)
6) Biji (default = 0): ini adalah setara dengan Scikit-belajar ini state random_
parameter, yang memungkinkan reproduktifitas proses di beberapa tes dan
berbeda
Sekarang tahu parameter terpenting XGBoost, mari jalankan XGBoost contoh pada dataset
yang sama yang gunakan untuk GBM dengan parameter yang sama pengaturan (sebanyak
mungkin). XGBoost sedikit lebih mudah digunakan daripada paket Scikit-learn.
import xgboost as xgb
import numpy as np
from sklearn.metrics import classification_report
from sklearn import cross_validation
clf = xgb.XGBClassifier(n_estimators=100,max_depth=8,
learning_rate=.1,subsample=.5)
clf1 = GradientBoostingClassifier(n_estimators=100,max_depth=8,
learning_rate=.1,subsample=.5)
%timeit xgm=clf.fit(X_train,y_train)
%timeit gbmf=clf1.fit(X_train,y_train)
y_pred = xgm.predict(X_test)
94
y_pred2 = gbmf.predict(X_test)
print 'XGBoost results %r' % (classification_report(y_test, y_pred))
print 'gbm results %r' % (classification_report(y_test, y_pred2))
OUTPUT:
1 loop, best of 3: 1.71 s per loop
1 loop, best of 3: 2.91 s per loop
XGBoost results ' precision recall f1-score support\
n\n 0 0.95 0.97 0.96 835\n 1
0.95 0.93 0.94 546\n\navg / total 0.95 0.95
0.95 1381\n'
gbm results ' precision recall f1-score support\n\n
0 0.95 0.97 0.96 835\n 1 0.95
0.92 0.93 546\n\navg / total 0.95 0.95 0.95
1381\n
Metode peningkatan sering digunakan untuk klasifikasi tetapi bisa sangat berguna untuk
tugas regresi juga. Karena regresi sering diabaikan, mari jalankan regresi contoh dan
membahas masalah-masalah utama. Kodingnya :
import numpy as np
import scipy.sparse
import os
import pandas as pd
import numpy as np
from sklearn.datasets import fetch_california_housing
pd=fetch_california_housing()
#because the y variable is highly skewed we apply the log
transformation
95
y=np.log(pd.target)
X_train, X_test, y_train, y_test = train_test_split(pd.data,
y,
test_size=0.15,
random_state=111)
names = pd.feature_names
print names
from xgboost.sklearn import XGBClassifier
from sklearn.grid_search import GridSearchCV
clf=xgb.XGBRegressor(gamma=0,objective= "reg:linear",nthread=-1)
y_pred = clf.predict(X_test)
print 'score before gridsearch %r' % mean_squared_error(y_test, y_
pred)
params = {
'max_depth':[4,6,8],
'n_estimators':[1000],
'min_child_weight':range(1,3),
'learning_rate':[.1,.01,.001],
'colsample_bytree':[.8,.9,1]
,'gamma':[0,1]}
#with the parameter nthread we specify XGBoost for parallelisation
cvx = xgb.XGBRegressor(objective= "reg:linear",nthread=-1)
clf=GridSearchCV(estimator=cvx,param_grid=params,n_jobs=-
1,scoring='mean_absolute_error',verbose=True)
print clf.best_params_
print 'score after gridsearch %r' %mean_squared_error(y_test, y_pred)
96
#Your output might look a little different based on your hardware.
OUTPUT
['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population',
'AveOccup', 'Latitude', 'Longitude']
score before gridsearch 0.07110580252173157
Fitting 3 folds for each of 108 candidates, totalling 324 fits
[Parallel(n_jobs=-1)]: Done 34 tasks | elapsed: 1.9min
RANGKUMAN
Metode CART yang dilatih dengan rutinitas ensemble sangat efektif dalam hal akurasi
prediksi. Namun, mereka dapat menjadi mahal secara komputasi dan telah membahas
beberapa teknik untuk mempercepatnya dalam aplikasi sklearn.
Kami memperhatikan bahwa menggunakan hutan acak yang ekstrim yang disetel dengan
pencarian acak dapat meningkat sepuluh kali lipat jika digunakan dengan benar. Untuk
GBM, bagaimanapun, tidak ada paralelisasi yang diimplementasikan di sklearn, dan di sinilah
XGBoost masuk.
XGBoost hadir dengan algoritma pendorong paralel yang efektif yang mempercepat
algoritma dengan baik. Saat menggunakan file yang lebih besar (> 100k contoh pelatihan),
ada metode out-of-core yang memastikan tidak membebani memori utama saat melatih
model.
Keuntungan terbesar dalam kecepatan dan memori dapat ditemukan dengan H2O; melihat
kemampuan penyetelan yang kuat bersama dengan kecepatan pelatihan yang
mengesankan.
97
DAFTAR PUSTAKA
1. Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca
2. Machine Learning Tingkat Dasar dan Lanjut, 2018. Suyanto, Informatika
Bandung
3. Introduction to Machine Learning with Python A Guide for Data Scientists,
2017. Andreas C. Müller and Sarah Guido
98
LATIHAN
1. Jelaskan cara kerja Regression dalam melakukan proses prediksi dan peramalan dan
bagaimaan memperkirakan nilai-nilai data bertipe masa lalu, sekarang, dan masa
depan) dan cara memperkirakan nilai-nilai data time series di masa depan
2. Praktek dan buatlah laporan output Regresi dengan XGBoost !
Koding sebagai berikut:

import numpy as np
import scipy.sparse
import os
import pandas as pd
import numpy as np
from sklearn.datasets import fetch_california_housing
pd=fetch_california_housing()
#because the y variable is highly skewed we apply the log
transformation
y=np.log(pd.target)
X_train, X_test, y_train, y_test = train_test_split(pd.data,
y,
test_size=0.15,
random_state=111)
names = pd.feature_names
print names
from xgboost.sklearn import XGBClassifier
from sklearn.grid_search import GridSearchCV
99
clf=xgb.XGBRegressor(gamma=0,objective= "reg:linear",nthread=-1)
print 'score before gridsearch %r' % mean_squared_error(y_test, y_
pred)
params = {
'max_depth':[4,6,8],
'n_estimators':[1000],
'min_child_weight':range(1,3),
'learning_rate':[.1,.01,.001],
'colsample_bytree':[.8,.9,1]
,'gamma':[0,1]}
#with the parameter nthread we specify XGBoost for parallelisation
cvx = xgb.XGBRegressor(objective= "reg:linear",nthread=-1)
clf=GridSearchCV(estimator=cvx,param_grid=params,n_jobs=-
1,scoring='mean_absolute_error',verbose=True)
print clf.best_params_
print 'score after gridsearch %r' %mean_squared_error(y_test, y_pred)
100
BAB IX
UNSUPERVISED LEARNING
- Mahasiswa mampu menjelaskan tentang Unsupervised Learning.

- Mahasiswa mampu memecahkan soal tentang Unsupervised Learning.
- Mahasiswa mampu mendemostrasikan metode K-Means di Python 3 untuk pembelajaran
Machine Learning.
- Mahasiswa mampu mengkode algoritma-algoritma K-Means Machine Learning dengan
bahasa pemrograman Python.
- Mahasiswa mampu mempraktekkan algoritma K-Means Machine Learning pada Jupyter
Notebook.
- Mahasiswa mampu menguji algoritma K-Means Machine Learning pada Jupyter
Notebook.
MATERI
9.1 Unsupervised Learning
Dalam jenis sistem pembelajaran mesin ini, dapat menebak bahwa datanya tidak berlabel.
dari setiap titik data yang investigasi. Algoritma tanpa pengawasan yang paling penting:
1) Pengelompokan: k-means, analisis klaster hierarkis
2) Pembelajaran aturan asosiasi: Eclat, apriori
3) Visualisasi dan pengurangan dimensi: kernel PCA, t-didistribusikan, PCA
101
Pembelajaran tanpa pengawasan adalah cabang pembelajaran mesin yang algoritmanya
mengungkapkan kesimpulan dari data tanpa label eksplisit (data tidak berlabel). Tujuan dari
teknik tersebut adalah untuk mengekstrak pola tersembunyi dan mengelompokkan data
serupa. Dalam algoritma ini, parameter kepentingan yang tidak diketahui dari setiap
observasi (keanggotaan grup dan komposisi topik, misalnya) sering dimodelkan sebagai
variabel laten (atau serangkaian variabel tersembunyi), tersembunyi dalam sistem variabel
yang diamati yang tidak dapat diamati secara langsung, tetapi hanya disimpulkan dari
keluaran masa lalu dan sekarang dari sistem. Biasanya, keluaran sistem berisi derau, yang
membuat operasi ini lebih sulit. Pertama-tama, sebelum memulai dengan ilustrasi , mari
impor modul yang nantinya perlu :
In : import matplotlib
import numpy as np
import pandas as pd
from matplotlib import pylab
%matplotlib inline
import matplotlib.cm as cm
import copy
import tempfile
import os
9.2 PCA
PCA adalah algoritma yang biasa digunakan untuk menguraikan dimensi sinyal input dan
hanya menyimpan yang utama . Dari perspektif matematika, PCA melakukan transformasi
ortogonal dari matriks observasi, mengeluarkan sekumpulan variabel linear tak berkorelasi,
bernama komponen utama. Variabel keluaran membentuk basis set, di mana setiap
komponen adalah ortonormal ke yang lain. Juga, dimungkinkan untuk memberi peringkat
komponen keluaran (untuk menggunakan hanya yang utama) sebagai yang pertama
komponen adalah yang berisi kemungkinan varians terbesar dari set data masukan, yang
kedua adalah ortogonal ke yang pertama (menurut definisi) dan berisi kemungkinan varian
102
terbesar dari sinyal sisa, dan yang ketiga adalah ortogonal untuk dua yang pertama dan itu
dibangun di atas varian sisa, dan seterusnya. Dalam contoh ini, akan membuat dummy
dataset yang terdiri dari dua blob titik — satu cantered di (-5, 0) dan yang lainnya di (5, 5).
Mari gunakan PCA untuk mengubah dataset dan memplot outputnya dibandingkan dengan
masukan. Dalam contoh sederhana ini, akan menggunakan semua fitur, yaitu, tidak akan
melakukan pengurangan fitur:
In:from sklearn.datasets.samples_generator import make_blobs
from sklearn.decomposition import PCA
X, y = make_blobs(n_samples=1000, random_state=101, \
centers=[[-5, 0], [5, 5]])
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
pca_comp = pca.components_.T
test_point = np.matrix([5, -2])
test_point_pca = pca.transform(test_point)
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='none')
plt.quiver(0, 0, pca_comp[:,0], pca_comp[:,1], width=0.02, \
scale=5, color='orange')
plt.plot(test_point[0, 0], test_point[0, 1], 'o')
plt.title('Input dataset')
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, edgecolors='none')
plt.plot(test_point_pca[0, 0], test_point_pca[0, 1], 'o')
plt.title('After "lossless" PCA')
plt.show()
103
Gambar 14. PCA
Implementasi PCA yang disediakan oleh H2O.

In: import h2o
from h2o.transforms.decomposition import H2OPCA
h2o.init(max_mem_size_GB=4)
def testH2O_pca(nrows, ncols, k=20):
temp_file = tempfile.NamedTemporaryFile().name
X, _ = make_blobs(nrows, n_features=ncols, random_state=101)
np.savetxt(temp_file, np.c_[X], delimiter=",")
del X
pca = H2OPCA(k=k, transform="NONE", pca_method="Power")
tik = time.time()
pca.train(x=range(100), \
training_frame=h2o.import_file(temp_file))
print "H2OPCA on matrix ", (nrows, ncols), \
" done in ", time.time() - tik, "seconds"
os.remove(temp_file)
testH2O_pca(100000, 100)
testH2O_pca(10000, 2500)
h2o.shutdown(prompt=False)
104
Out:[...]
H2OPCA on matrix (100000, 100) done in 12.9560530186 seconds
[...]
H2OPCA on matrix (10000, 2500) done in 10.1429388523 seconds
105
RANGKUMAN
dari setiap titik data yang investigasi.
Dalam bab ini, telah memperkenalkan tiga tanpa pengawasan populer mampu untuk skala
mengatasi besar data. The pertama, PCA, adalah mampu untuk mengurangi dengan jumlah
dari fitur dengan membuat yang mengandung yang mayoritas dari varians (yang adalah,
yang utama).
DAFTAR PUSTAKA
1 Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca Massaron,
2 Machine Learning Tingkat Dasar dan Lanjut, 2018. Suyanto, Informatika Bandung
3 Introduction to Machine Learning with Python A Guide for Data Scientists, 2017.
LATIHAN
1. Lakukan Praktek k means dalam bahasa Python dan buatlah laporan outputnya
Koding :
In:import matplotlib
import numpy as np
import pandas as pd
106
%matplotlib inline
centers = [[1, 1], [1, -1], [-1, -1], [-1, 1]]
X, y = make_blobs(n_samples=1000, centers=centers,
cluster_std=0.5, random_state=101)
In:plt.scatter(X[:,0], X[:,1], c=y, edgecolors='none', alpha=0.9)
plt.show()
2. Jelaskan perbedaan unsupervised learning dengan supervised learning pada machine

learning
107
BAB X
K-MEANS
- Mahasiswa mampu mengarahkan tentang K-means.

- Mahasiswa mampu menyimpulkan tentang K-means.
- Mahasiswa mampu mendemostrasikan K-means untuk pembelajaran Machine Learning.
- Mahasiswa mampu mengkode algoritma-algoritma K-means dengan bahasa
pemrograman Python.
- Mahasiswa mampu mempraktekkan algoritma-algoritma K-means.
- Mahasiswa mampu menguji algoritma-algoritma Machine Learning pada Hadoop.
MATERI
10.1 K-Means
Data Mining adalah teknik analisa data secara otomatis untuk membuka atau membongkar
hubungan dari banyak data yang tidak diketahui sebelumnya. Data Mining sering
dihubungkan dengan analisa simpanan data di dalam sebuah warehouse. Secara umum ada
tiga teknik utama Data Mining yaitu regresi, klasifikasi dan klastering. Clustering merupakan
bagian dari ilmu Data Mining yang bersifat tanpa arahan (unsupervised). Clustering adalah
proses pembagian data ke dalam kelas atau cluster berdasarkan tingkat kesamaannya.
Clustering merupakan pekerjaan yang memisahkan data atau vektor ke dalam sejumlah
kelompok atau cluster menurut karakteristiknya masing-masing. Data-data yang memiliki
kemiripan karakteristik akan berkumpul dalam kelompok atau cluster yang sama. Data-data
yang memiliki perbedaan karakteristik, aakan berkumpul dalam kelompok atau cluster yang
108
berbeda. Tujuan utama dari metode clustering adalah pengelompokan sejumlah data atau
obyek ke dalam cluster (group) sehingga dalam setiap cluster akan berisi data yang semirip
mungkin. K-means merupakan salah satu Teknik pengelompokan yang bekerja berdasarkan
partitioned clustering. Prinsip kerja dari pengelompokan hierarchical clustering dilakukan
secara bertahap. Dan disetiap iterasi dari pengelompokan hierarchical clustering hanya ada
satu pemilihan penggabungan suatu item terhadap item lainnya. Sedangkan prinsip kerja
dari pengelompokan partitioned clustering adalah mengelompokkan item secara acak
karena dipengaruhi centroid. Dan disetiap iterasi dari pengelompokkan partitioned
clustering dapat memungkinkan untuk terjadinya lebih dari satu pemilihan item yang akan
digabungkan.
Langkah-langkah pada proses clustering dengan menggunakan algoritma K-Means, adalah
sebagai berikut:
1) Menentukan Jumlah Cluster
Jumlah cluster yang ditentukan untuk mengelompokan data pada penelitian ini
sebanyak N cluster.
2) Menentukan Centroid
Pusat awal cluster (centroid)ditentukan secara random atau acak.
3) Menghitung Jarak dari Centroid
Menghitung jarak antara titik centroid dengan titik tiap objek dengan menggunakan
Euclidian Distance.
4) Alokasikan masing-masing objek ke centroid terdekat. Untuk mengalokasikan objek
ke dalam masing-masing cluster dengan cara mengelompokkan berdasarkan jarak
minimum objek ke pusat cluster.
K-means adalah algoritma tanpa pengawasan yang menciptakan K kelompok titik terputus-
putus dengan varian yang sama, meminimalkan distorsi (juga dinamai inersia). Diberikan
hanya satu parameter K, yang mewakili jumlah cluster yang akan dibuat, algoritma K-means
membuat kumpulan K titik S 1 , S 2 ,…, S K , masing-masing diwakili oleh pusatnya: C 1 , C 2 ,
..., C K . Centroid generik, C i , hanyalah mean dari sampel titik-titik yang terkait dengan
cluster Si untuk meminimalkan jarak intra-cluster. Output dari sistem tersebut adalah
sebagai berikut:
109
1) Komposisi cluster S 1 , S 2 ,…, S K , yaitu, himpunan poin yang menyusun set
pelatihan yang terkait dengan cluster nomor 1, 2,…, K.
2) The centroid dari setiap cluster, C 1 , C 2 , ..., C K . Centroid dapat digunakan untuk
asosiasi di masa mendatang.
3) Distorsi yang diperkenalkan oleh clustering, dihitung sebagai berikut.
Persamaan ini menunjukkan pengoptimalan yang secara intrinsik dilakukan dalam

algoritma K-means: sentroid dipilih untuk meminimalkan distorsi intra-kluster, yaitu jumlah
norma Euclidean dari jarak antara setiap titik input dan sentroid kluster tempat titik
dikaitkan dengan. Dengan kata lain, algoritma mencoba menyesuaikan kuantisasi vektorial
terbaik.
In:import matplotlib
import numpy as np
import pandas as pd
%matplotlib inline
centers = [[1, 1], [1, -1], [-1, -1], [-1, 1]]
In:pylab.rcParams['figure.figsize'] = (10.0, 8.0)
from sklearn.cluster import KMeans
for n_iter in range(1, 5):
cls = KMeans(n_clusters=4, max_iter=n_iter, n_init=1,
init='random', random_state=101)
cls.fit(X)
# Plot the voronoi cells
plt.subplot(2, 2, n_iter)
110
h=0.02
xx, yy = np.meshgrid(np.arange(-3, 3, h), np.arange(-3, 3, h))
Z = cls.predict(np.c_[xx.ravel(), \
yy.ravel()]).reshape(xx.shape)
plt.imshow(Z, interpolation='nearest', cmap=plt.cm.Accent, \
extent=(xx.min(), xx.max(), yy.min(), yy.max()), \
aspect='auto', origin='lower')
plt.scatter(X[:,0], X[:,1], c=cls.labels_, \
edgecolors='none', alpha=0.7)
plt.scatter(cls.cluster_centers_[:,0], \
cls.cluster_centers_[:,1], \
marker='x', color='r', s=100, linewidths=4)
plt.title("iter=%s, distortion=%s" %(n_iter, \
int(cls.inertia_)))
plt.show()
K-means mengandalkan asumsi bahwa setiap cluster memiliki bentuk bola (hyper-), artinya,
tidak memiliki bentuk memanjang (seperti panah), semua cluster memiliki ekstensi varian
yang sama secara internal, dan ukurannya sebanding (atau sangat jauh). Semua hipotesis ini
dapat dijamin dengan langkah pemrosesan awal fitur yang kuat; PCA, Kernel PCA,
normalisasi fitur, dan pengambilan sampel bisa menjadi awal yang baik.
from sklearn.datasets import make_moons
# Oblong/elongated sets
X, _ = make_moons(n_samples=1000, noise=0.1, random_state=101)
cls = KMeans(n_clusters=2, random_state=101)
y_pred = cls.fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pred, edgecolors='none')
plt.scatter(cls.cluster_centers_[:,0], cls.cluster_centers_[:,1],
111
plt.title("Elongated clusters")
# Different variance between clusters
centers = [[-1, -1], [0, 0], [1, 1]]
X, _ = make_blobs(n_samples=1000, cluster_std=[0.1, 0.4, 0.1],
centers=centers, random_state=101)
plt.title("Unequal Variance between clusters")
# Unevenly sized blobs
centers = [[-1, -1], [1, 1]]
centers.extend([[0,0]]*20)
X, _ = make_blobs(n_samples=1000, centers=centers,
plt.title("Unevenly Sized Blobs")
plt.show()
Ada beberapa metode untuk mendeteksi K terbaik jika asumsi di balik K-means
bertemu. Beberapa di antaranya didasarkan pada validasi silang dan metrik pada keluaran;
mereka dapat digunakan di semua metode pengelompokan, tetapi hanya jika kebenaran
112
dasar tersedia (mereka dinamai metrik yang diawasi). Beberapa lainnya didasarkan pada
parameter intrinsik dari algoritma pengelompokan dan dapat digunakan secara independen
oleh ada atau tidaknya kebenaran dasar (juga disebut metrik yang tidak diawasi).
Sayangnya, tidak satupun dari mereka memastikan akurasi 100% untuk menemukan hasil
yang benar. Metrik yang diawasi membutuhkan kebenaran dasar (berisi asosiasi sebenarnya
dalam set) dan biasanya digabungkan dengan analisis gridsearch untuk memahami K.
Beberapa metrik ini berasal dari klasifikasi yang setara, tetapi memungkinkan memiliki
jumlah set tidak berurutan yang berbeda sebagai label yang diprediksi. Yang pertama itu
yang akan lihat dinamai homogenitas ; seperti yang harapkan, ini memberikan ukuran
berapa banyak cluster yang diprediksi hanya berisi poin dari satu kelas. Itu ukuran
berdasarkan entropi, dan itu adalah cluster yang setara dengan presisi dalam klasifikasi. Ini
adalah ukuran yang terikat antara 0 (terburuk) dan 1 (terbaik); formulasi matematisnya
adalah sebagai berikut:
from sklearn.metrics import homogeneity_completeness_v_measure
centers = [[1, 1], [1, -1], [-1, -1], [-1, 1]]
Ks = range(2, 10)
HCVs = []
for K in Ks:
y_pred = KMeans(n_clusters=K, random_state=101).fit_predict(X)
HCVs.append(homogeneity_completeness_v_measure(y, y_pred))
plt.plot(Ks, [el[0] for el in HCVs], 'r', label='Homogeneity')
plt.plot(Ks, [el[1] for el in HCVs], 'g', label='Completeness')
plt.plot(Ks, [el[2] for el in HCVs], 'b', label='V measure')
plt.ylim([0, 1])
plt.legend(loc=4)
plt.show()
113
10.2 Pemilihan K
Ada beberapa metode untuk mendeteksi K terbaik jika asumsi di balik K-means terpenuhi.
Beberapa di antaranya didasarkan pada validasi silang dan metrik pada keluaran; mereka
dapat digunakan pada semua metode pengelompokan, tetapi hanya jika kebenaran dasar
tersedia (mereka dinamai metrik yang diawasi). Beberapa lainnya didasarkan pada
parameter intrinsik dari algoritma pengelompokan dan dapat digunakan secara independen
dengan ada atau tidak adanya kebenaran dasar (juga disebut metrik yang tidak diawasi).
Sayangnya, tidak ada satupun yang memastikan akurasi 100% untuk menemukan hasil yang
benar . Metrik yang diawasi memerlukan kebenaran dasar (berisi asosiasi sebenarnya dalam
set) dan biasanya digabungkan dengan analisis gridsearch untuk memahami yang terbaik K.
Beberapa metrik ini berasal dari klasifikasi yang setara, tetapi metrik tersebut
memungkinkan memiliki jumlah unordered yang berbeda. ditetapkan sebagai label yang
diprediksi. Yang pertama yang akan lihat diberi nama homogenitas ; seperti yang harapkan,
ini memberikan ukuran berapa banyak cluster yang diprediksi hanya berisi poin dari satu
kelas. Ini adalah ukuran berdasarkan entropi, dan ini setara dengan cluster dengan presisi
dalam klasifikasi.
RANGKUMAN
K-means adalah algoritma tanpa pengawasan yang menciptakan K kelompok titik terputus-
putus dengan varian yang sama, meminimalkan distorsi (juga dinamai inersia). Diberikan
hanya satu parameter K, yang mewakili jumlah cluster yang akan dibuat. Algoritma K-means
membuat kumpulan K titik S 1 , S 2 ,…, S K , masing-masing diwakili oleh pusatnya: C 1 , C 2 , ..., C K .
Centroid generik, C i , hanyalah mean dari sampel titik-titik yang terkait dengan cluster Si untuk
meminimalkan jarak intra-cluster.
114
DAFTAR PUSTAKA
4. Pemanfaatan Data Mining Dengan Metode Clustering Untuk Evaluasi Biaya Dokumen
Ekspor Di Pt Winstar Batam, 2017. Yuli Siyamto
LATIHAN
1. Lakukan Instalasi Rapid Miner dan lakukana analisis datadengna algoritma k means
dengan data sampel yang diberikan dan Analisa keluaran rapid miner!
2. Jelaskan Langkah-langkah pada proses clustering dengan menggunakan algoritma K-
Means
115
BAB XI
HADOOP
- Mahasiswa mampu mengarahkan tentang Hadoop.

- Mahasiswa mampu menyimpulkan tentang Hadoop.
- Mahasiswa mampu mendemostrasikan instalasi Hadoop untuk pembelajaran Machine
Learning.
- Mahasiswa mampu mengkode algoritma-algoritma Machine Learning dengan bahasa
pemrograman Python.
- Mahasiswa mampu mempraktekkan algoritma-algoritma Machine Learning pada
Hadoop.
- Mahasiswa mampu menguji algoritma-algoritma Machine Learning pada Hadoop.
MATERI
11.1 A Bunch Of Nodes
Jumlah data yang disimpan di dunia meningkat secara eksponensial. Saat ini, bagi data
scientist, harus memproses beberapa Terabyte data dalam sehari bukanlah permintaan
yang tidak biasa. Untuk membuatnya lebih kompleks, biasanya data berasal dari berbagai
macam sistem heterogen dan bisnis yang diharapkan adalah menghasilkan model dalam
waktu yang singkat. Oleh karena itu, menangani big data bukan hanya masalah ukuran, ini
sebenarnya a fenomena tiga dimensi. Sebenarnya, menurut model 3V, sistem beroperasi
pada data besar dapat diklasifikasikan menggunakan tiga kriteria (ortogonal):
116
1) Kriteria pertama adalah kecepatan yang diarsipkan oleh sistem untuk memproses
data. Meskipun beberapa tahun yang lalu, kecepatan menunjukkan seberapa cepat
sebuah sistem dapat memproses sebuah batch; saat ini, kecepatan menunjukkan
apakah suatu sistem dapat memberikan keluaran waktu nyata pada data streaming
2) Kriteria kedua adalah volume, yaitu berapa banyak informasi yang tersedia untuk
diproses. Ini dapat diekspresikan dalam jumlah baris, fitur, atau hanya hitungan byte.
Untuk mengalirkan data, volume menunjukkan throughput data yang tiba di sistem.
3) Kriteria terakhir adalah variasi, yang adalah, yang tipe dari sumber data. Beberapa
tahun yang lalu, berbagai itu dibatasi oleh dataset terstruktur; Saat ini, data dapat
terstruktur (tabel, gambar, dan sebagainya ), semi-terstruktur (JSON, XML, dan
sebagainya ), dan tidak terstruktur (halaman web, data sosial, dan sebagainya ).
Biasanya, besar sistem data mencoba untuk proses sebagai banyak sumber yang
relevan sebagai mungkin, pencampuran semua jenis dari sumber.
Di luar kriteria ini, banyak lain telah muncul dalam beberapa tahun terakhir, mencoba
menjelaskan fitur lain dari data besar. Beberapa di antaranya adalah sebagai berikut:
- Veracity (memberikan indikasi ketidaknormalan, bias, dan noise yang terkandung
dalam data; pada akhirnya, keakuratannya)
- Volatilitas (menunjukkan berapa lama data dapat digunakan untuk mengekstrak
informasi yang berarti)
- Validitas (kebenaran data)
- Nilai (menunjukkan laba atas investasi data)
Dalam beberapa tahun terakhir, semua telah meningkat secara dramatis; sekarang banyak
perusahaan menemukan bahwa data yang mereka simpan memiliki nilai yang sangat besar
yang dapat dimonetisasi dan mereka ingin mengekstrak informasi darinya. Tantangan teknis
telah berpindah ke memiliki penyimpanan dan kekuatan pemrosesan yang cukup agar dapat
mengekstrak wawasan yang berarti dengan cepat, dalam skala besar, dan menggunakan
aliran data masukan yang berbeda . Komputer saat ini, bahkan yang terbaru dan termahal,
memiliki jumlah disk, memori, dan CPU yang terbatas .
117
Tampaknya sangat sulit untuk memproses terabyte (atau petabyte) informasi per
hari, menghasilkan model cepat. Selain itu, mandiri server yang mengandung kedua Data
dan pengolahan perangkat lunak kebutuhan untuk dapat direplikasi; jika tidak, ini bisa
menjadi satu-satunya titik kegagalan sistem. Oleh karena itu, dunia big data telah berpindah
ke cluster: mereka terdiri dari sejumlah variabel node yang tidak terlalu mahal dan berada
pada koneksi Internet berkecepatan tinggi. Biasanya, beberapa cluster didedikasikan untuk
menyimpan data (hard disk besar, CPU kecil, dan jumlah memori rendah), dan yang lain
dikhususkan untuk memproses data (CPU yang kuat, jumlah memori sedang hingga besar,
dan hard disk kecil disk). Selain itu, jika cluster disetel dengan benar, cluster dapat
memastikan keandalan (tidak ada titik kegagalan tunggal) dan ketersediaan tinggi.
Perhatikan bahwa, ketika menyimpan data dalam lingkungan terdistribusi (seperti cluster),
harus mempertimbangkan batasan teorema CAP; dalam sistem, memastikan dua dari tiga
properti berikut:
- Konsistensi: Semua node dapat mengirimkan data yang sama pada waktu yang sama
ke klien
- Ketersediaan: Klien yang meminta data dijamin untuk selalu menerima respons, baik
untuk permintaan yang berhasil maupun yang gagal
- Toleransi partisi: Jika jaringan mengalami kegagalan dan semua node tidak dapat
dihubungi, sistem dapat tetap berfungsi
11.2 Virtual Box
Virtual Box adalah perangkat lunak sumber terbuka yang digunakan untuk memvirtualisasi
sistem operasi satu-ke-banyak tamu pada mesin host Windows, macOS, dan Linux. Dari
sudut pandang pengguna, mesin virtual terlihat seperti komputer lain yang berjalan di
jendela, dengan semua fungsinya. Virtual Box telah menjadi sangat populer karena
kinerjanya yang tinggi, kesederhanaan, dan antarmuka pengguna grafis ( GUI ) yang bersih.
Memulai, menghentikan, mengimpor, dan mengakhiri mesin virtual dengan Virtual Box
hanya dengan satu klik. Secara teknis, Virtual Box adalah hypervisor, yang mendukung
pembuatan dan pengelolaan beberapa mesin virtual ( VM ) termasuk banyak versi Windows,
Linux, dan distribusi mirip BSD.
118
Mesin tempat Virtual Box dijalankan diberi nama host , sedangkan mesin virtualisasi
diberi nama tamu . Perhatikan bahwa tidak ada batasan antara tuan rumah dan tamu;
misalnya, host Windows dapat berjalan Windows (versi yang sama, versi sebelumnya, atau
terbaru) serta distribusi Linux dan BSD yang kompatibel dengan Virtual Box. Virtual Box
sering digunakan untuk menjalankan software Operative-System tertentu; beberapa
perangkat lunak hanya berjalan di Windows atau versi Windows tertentu, beberapa hanya
tersedia di Linux, dan seterusnya. Aplikasi lainnya adalah untuk mensimulasikan fitur-fitur
baru pada lingkungan produksi kloning; sebelum mencoba modifikasi di lingkungan langsung
(produksi), pengembang perangkat lunak biasanya mengujinya pada klon, seperti yang
berjalan di Virtual Box.
Gambar 15. Virtual Box
11.3 Vagrant
Vagrant adalah perangkat lunak yang mengkonfigurasi lingkungan virtual pada level tinggi.
Bagian inti dari Vagrant adalah kemampuan scripting, yang sering digunakan untuk
119
membuat lingkungan virtual tertentu secara terprogram dan otomatis. Vagrant
menggunakan Virtual Box (tetapi juga virtualizer lain) untuk membangun dan
mengkonfigurasi mesin virtual. Untuk menginstalnya, ikuti instruksi di
https://www.vagrantup.com/ downloads.html .
Gambar 16. Vagrant
11.4 Menggunakan VM
Misalkan diberikan fungsi : R → R yang differentiable. Kemudian perlu dihitung turunan

fungsi tersebut di titik x = x0. Ekspansi Taylor fungsi diser x0 memberikan Dengan Vagrant
dan Virtual Box diinstal, sekarang siap untuk menjalankan node dari lingkungan cluster.
Buat direktori kosong dan masukkan perintah Vagrant berikut ke dalam file baru bernama
Vagrantfile :
Vagrant.configure("2") do |config|
config.vm.box = "Sparkpy/Sparkbox_test_1"
config.vm.hostname = "Sparkbox"
config.ssh.insert_key = false
# Hadoop ResourceManager
config.vm.network :forwarded_port, guest: 8088, host: 8088, auto_
correct: true
# Hadoop NameNode
config.vm.network :forwarded_port, guest: 50070, host: 50070,
auto_correct: true
# Hadoop DataNode
config.vm.network :forwarded_port, guest: 50075, host: 50075,
auto_correct: true
120
# IPython notebooks (yarn and standalone)
correct: true
# Spark UI (standalone)
correct: true
config.vm.provider "virtualbox" do |v|
v.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
v.customize ["modifyvm", :id, "--natdnsproxy1", "on"]
v.customize ["modifyvm", :id, "--nictype1", "virtio"]
v.name = "Sparkbox_test"
v.memory = "4096"
v.cpus = "2"
end
end
11.5 The Hadoop Ecosystem

Apache Hadoop adalah framework perangkat lunak yang sangat populer untuk
penyimpanan terdistribusi dan pemrosesan terdistribusi pada sebuah cluster. Kekuatannya
ada pada harga (gratis), fleksibilitas (ini open source, dan meskipun ditulis di Java, ini dapat
digunakan oleh bahasa pemrograman lain), skalabilitas (dapat menangani cluster yang
terdiri dari ribuan node), dan ketahanan ( Ini terinspirasi oleh makalah yang diterbitkan dari
Google dan telah ada sejak 2011), menjadikannya standar de facto untuk menangani dan
memproses data besar.
121
Gambar 17.Hadoop
Selain itu, banyak proyek lain dari yayasan Apache yang diperluas fungsinya.
Logikanya, Hadoop terdiri dari dua bagian: penyimpanan terdistribusi (HDFS) dan
pemrosesan terdistribusi (YARN dan MapReduce). Meskipun kodenya sangat kompleks,
keseluruhan arsitekturnya cukup mudah dipahami. Seorang klien dapat mengakses
keduanya penyimpanan dan pemrosesan melalui dua modul khusus; mereka kemudian
bertanggung jawab mendistribusikan pekerjaan ke semua node yang berfungsi:
Gambar 18. YARN dan MapReduce
In:
with open('mapper_hadoop.py', 'w') as fh:
122
fh.write("""#!/usr/bin/env Python
import sys
for line in sys.stdin:
print "chars", len(line.rstrip('\\n'))
print "words", len(line.split())
print "lines", 1
""")
with open('reducer_hadoop.py', 'w') as fh:
fh.write("""#!/usr/bin/env Python
import sys
counts = {"chars": 0, "words":0, "lines":0}
for line in sys.stdin:
kv = line.rstrip().split()
counts[kv[0]] += int(kv[1])
for k,v in counts.items():
print k, v
""")
In:!chmod a+x *_hadoop.py
In:!hdfs dfs -mkdir -p /tmp

!hdfs dfs -rm -f -r /tmp/mr.out
!hadoop jar /usr/local/hadoop/share/hadoop/tools/lib/hadoop-streaming -
2.6.4.jar \
-files mapper_hadoop.py,reducer_hadoop.py \
-mapper mapper_hadoop.py -reducer reducer_hadoop.py \
-input /datasets/hadoop_git_readme.txt -output /tmp/mr.out
Out:[...]
16/02/04 17:12:22 INFO mapreduce.Job: Running job:
job_1454605686295_0003
16/02/04 17:12:29 INFO mapreduce.Job: Job job_1454605686295_0003
123
running in uber mode : false
16/02/04 17:12:29 INFO mapreduce.Job: map 0% reduce 0%
16/02/04 17:12:47 INFO mapreduce.Job: Job job_1454605686295_0003
completed successfully
[...]
Shuffle Errors
BAD_ID=0
CONNECTION=0
IO_ERROR=0
WRONG_LENGTH=0
WRONG_MAP=0
WRONG_REDUCE=0
[...]
16/02/04 17:12:47 INFO streaming .StreamJob: Output directory: /tmp/
mr.out
Dengan Hadoop 2 (cabang saat ini pada 2016), lapisan telah diperkenalkan di atas
HDFS yang memungkinkan beberapa aplikasi berjalan, misalnya, MapReduce adalah salah
satunya mereka (menargetkan pemrosesan batch). Nama layer ini adalah Yet Another
Resource Negotiator ( YARN ) dan tujuannya adalah untuk mengelola manajemen sumber
daya di cluster. YARN mengikuti paradigma master / slave dan terdiri dari dua layanan:
Manajer Sumber Daya dan Manajer Node. Resource Manager adalah masternya dan
bertanggung jawab atas dua hal: penjadwalan (mengalokasikan sumber daya) dan
manajemen aplikasi (menangani pengajuan pekerjaan dan melacak status mereka). Setiap
Node Manager, arsitektur, adalah file kerangka kerja per pekerja yang menjalankan tugas
dan melaporkan ke Manajer Sumber Daya. Lapisan YARN yang diperkenalkan dengan
Hadoop 2 memastikan hal-hal berikut:
124
- Multitenancy, yaitu memiliki banyak mesin untuk menggunakan Hadoop
- Pemanfaatan cluster yang lebih baik karena alokasi tugas bersifat dinamis dan dapat
dijadwalkan
- Skalabilitas yang lebih baik; YARN tidak menyediakan algoritma pemrosesan, itu
hanya manajer sumber daya cluster
- Kompatibilitas dengan MapReduce (lapisan yang lebih tinggi di Hadoop 1)
RANGKUMAN
Apache Hadoop adalah framework perangkat lunak yang sangat populer untuk
penyimpanan terdistribusi dan pemrosesan terdistribusi pada sebuah cluster. Kekuatannya
ada pada harga (gratis), fleksibilitas (ini open source, dan meskipun ditulis di Java, ini dapat
digunakan oleh bahasa pemrograman lain), skalabilitas (dapat menangani cluster yang
terdiri dari ribuan node), dan ketahanan menjadikannya menangani dan memproses data
besar.
125
DAFTAR PUSTAKA
LATIHAN
1) Buatlah tutorial instalasi Hadoop!

2) Lakukan simulasi penyimpanan terdistribusi pada cluster dengan Hadoop!
126
BAB XII
MACHINE LEARNING WITH SPARK
- Mahasiswa mampu memperjelas tentang Spark.

- Mahasiswa mampu mendemostrasikan instalasi Spark untuk pembelajaran Machine
Learning.
- Mahasiswa mampu mengkode algoritma-algoritma Machine Learning dengan bahasa
pemrograman Python.
- Mahasiswa mampu mempraktekkan algoritma-algoritma Machine Learning pada Spark.
- Mahasiswa mampu menguji algoritma-algoritma Machine Learning pada Spark.
MATERI
12.1 Machine Learning With Spark
Apache Spark adalah evolusi dari Hadoop dan menjadi sangat populer dalam beberapa
tahun terakhir. Berbeda dengan Hadoop dan desain yang berfokus pada Java dan batch,
Spark mampu menghasilkan algoritma berulang dengan cara yang cepat dan mudah. Selain
itu, ia memiliki rangkaian API yang sangat kaya untuk berbagai bahasa pemrograman dan
secara native mendukung berbagai jenis pemrosesan data (pembelajaran mesin, streaming ,
analisis grafik, SQL, dan sebagainya). Apache Spark adalah kerangka kerja cluster yang
dirancang untuk pemrosesan data besar yang cepat dan bertujuan umum. Salah satu
peningkatan dalam kecepatan diberikan oleh fakta bahwa data, setelah setiap pekerjaan,
disimpan dalam memori dan tidak disimpan pada sistem file (kecuali jika mau) seperti yang
akan terjadi dengan Hadoop, MapReduce, dan HDFS. Hal ini membuat pekerjaan iteratif
(seperti algoritma clustering K-means) lebih cepat dan lebih cepat karena latensi dan
bandwidth yang disediakan oleh memori lebih berkinerja daripada disk fisik. Oleh karena itu,
127
cluster yang menjalankan Spark membutuhkan memori RAM dalam jumlah besar untuk
setiap node.
Gambar 19. Spark
Meskipun Spark telah dikembangkan di Scala (yang berjalan di JVM, seperti Java),
Spark memiliki API untuk beberapa bahasa pemrograman, termasuk Java, Scala, Python, dan
R. Spark dapat beroperasi dengan dua cara berbeda:
- Mode Standalone: Ini berjalan di komputer lokal . Dalam hal ini, paralelisasi
maksimum adalah jumlah inti mesin lokal dan jumlah memori yang tersedia persis
sama dengan yang lokal .
- Cluster mode: Ini berjalan pada sekelompok node, menggunakan manajer cluster
seperti YARN. Dalam hal ini, paralelisasi maksimum adalah jumlah core di semua
node yang menyusun cluster dan jumlah memori adalah jumlah memori setiap node.
Untuk menggunakan fungsi Spark (atau pySpark, yang berisi API Python dari Spark), perlu
membuat instance objek khusus bernama SparkContext. Ini memberitahu Spark cara
mengakses cluster dan berisi beberapa parameter khusus aplikasi. Dalam Notebook IPython
disediakan di mesin virtual, variabel ini sudah tersedia dan dinamai sc (ini adalah opsi
default saat Notebook IPython dimulai), sekarang lihat apa isinya
In:sc._conf.getAll()
Out:[(u'Spark.rdd.compress', u'True'),
(u'Spark.master', u'yarn-client'),
(u'Spark.serializer.objectStreamReset', u'100'),
(u'Spark.yarn.isPython', u'true'),
(u'Spark.submit.deployMode', u'client'),
128
(u'Spark.executor.cores', u'2'),
(u'Spark.app.name', u'PySparkShell')]
Karena pembelajaran mesin membutuhkan banyak daya komputasi, untuk
menghemat beberapa sumber daya (terutama memori) akan menggunakan lingkungan
Spark yang tidak didukung oleh YARN dalam bab ini. Mode operasi ini bernama mandiri dan
membuat node Spark tanpa fungsionalitas cluster; semua proses akan dilakukan di mesin
driver dan tidak akan dibagikan. Untuk mengoperasikannya, lakukan langkah-langkah
berikut:
1. Nyalakan mesin virtual menggunakan perintah vagrant up .
2. Akses mesin virtual jika sudah siap, dengan vagrant ssh .
3. Luncurkan Spark dengan IPython Notebook dengan ./start_jupyter.sh .
4. Buka browser yang mengarah ke
http: // localhost: 8888 .
In:from sklearn.datasets import load_iris
bcast_dataset = sc.broadcast(load_iris())
In:from pySpark import AccumulatorParam
class ErrorAccumulator(AccumulatorParam):
def zero(self, initialList):
return initialList
def addInPlace(self, v1, v2):
if not isinstance(v1, list):
v1 = [v1]
if not isinstance(v2, list):
v2 = [v2]
return v1 + v2
errAccum = sc.accumulator([], ErrorAccumulator())
In:
def apply_classifier(clf, dataset):
clf_name = clf.__class__.__name__
129
X = dataset.value.data
y = dataset.value.target
try:
clf.fit(X, y)
y_pred = clf.predict(X)
acc = accuracy_score(y, y_pred)
return [(clf_name, acc)]
except Exception as e:
errAccum.add((clf_name, str(e)))
return []
In:from sklearn.linear_model import SGDClassifier
from sklearn.dummy import DummyClassifier
from sklearn.decomposition import PCA
from sklearn.manifold import MDS
classifiers = [DummyClassifier('most_frequent'),
SGDClassifier(),
PCA(),
MDS()]
(sc.parallelize(classifiers)
.flatMap(lambda x: apply_classifier(x, bcast_dataset))
.collect())
Out:[('DummyClassifier', 0.33333333333333331),
('SGDClassifier', 0.66666666666666663)]
12.2 Data Preprocessing
Memuat data teks dari sistem file lokal dan HDFS. File teks dapat berisi data tidak
terstruktur (seperti dokumen teks) atau data terstruktur (seperti file CSV). Adapun data
semi-terstruktur, seperti file yang berisi objek JSON, Spark memiliki rutinitas khusus yang
130
dapat mengubah file menjadi DataFrame, mirip dengan Data Frame di panda R dan Python.
Data Frames sangat mirip dengan tabel RDBMS, di mana skema ditetapkan.
12.3 File JSON dan Spark DataFrames
Untuk mengimpor file yang sesuai dengan JSON, pertama-tama harus membuat konteks
SQL, membuat objek SQLContext dari Spark Context lokal:
In:from pySpark.sql import SQLContext
sqlContext = SQLContext(sc)
Sekarang, mari lihat konten file JSON kecil (disediakan di mesin virtual Vagrant). Ini adalah
representasi JSON dari tabel dengan enam baris dan tiga kolom, di mana beberapa atribut
hilang (seperti atribut gender untuk pengguna dengan user_id = 0 ):
In:!cat /home/vagrant/datasets/users.json
Out:{"user_id":0, "balance": 10.0}
{"user_id":1, "gender":"M", "balance": 1.0}
{"user_id":2, "gender":"F", "balance": -0.5}
{"user_id":3, "gender":"F", "balance": 0.0}
{"user_id":4, "balance": 5.0}
{"user_id":5, "gender":"M", "balance": 3.0}
Dengan menggunakan metode read.json yang disediakan oleh sqlContext , sudah memiliki
tabel yang diformat dengan baik dan dengan semua nama kolom kanan dalam variabel.
Variabel keluaran diketik sebagai Spark DataFrame. Untuk menampilkan variabel dalam
tabel yang bagus dan diformat, gunakan metode show -nya :
In:
df = sqlContext.read \
.json("file:///home/vagrant/datasets/users.json")
df.show()
Out:
+-------+------+-------+
131
|balance|gender|user_id|
+-------+------+-------+
| 10.0| null| 0|
| 1.0| M| 1|
| -0.5| F| 2|
| 0.0| F| 3|
| 5.0| null| 4|
| 3.0| M| 5|
+-------+------+-------+
Selain itu, dapat menyelidiki skema DataFrame menggunakan metode printSchema, saat
membaca file JSON, setiap jenis kolom telah disimpulkan oleh data (dalam contoh, kolom
user_id berisi bilangan bulat panjang, kolom jenis kelamin disusun oleh string, dan
keseimbangannya adalah floating point ganda):
In:df.printSchema()
Out:root
|-- balance: double (nullable = true)
|-- gender: string (nullable = true)
|-- user_id: long (nullable = true)
Persis seperti tabel di RDBMS, dapat menggeser dan memotong data di DataFrame,
membuat pilihan kolom dan memfilter data berdasarkan atribut. Dalam contoh ini, ingin
mencetak keseimbangan, jenis kelamin, dan user_id dari pengguna yang jenis kelaminnya
bukan hilang dan memiliki saldo lebih besar dari nol. Untuk ini, bisa menggunakan filter
dan pilih metode:
In:(df.filter(df['gender'] != 'null')
.filter(df['balance'] > 0)
.select(['balance', 'gender', 'user_id'])
.show())
Out:
+-------+------+-------+
132
+-------+------+-------+
| 1.0| M| 1|
| 3.0| M| 5|
+-------+------+-------+
In:(df.filter('gender is not null')
.filter('balance > 0').select("*").show())
Out:
+-------+------+-------+
+-------+------+-------+
| 1.0| M| 1|
| 3.0| M| 5|
+-------+------+-------+
In:df.filter('gender is not null and balance > 0').show()
Out:
+-------+------+-------+
+-------+------+-------+
| 1.0| M| 1|
| 3.0| M| 5|
+-------+------+-------+
Agar suatu fungsi diterapkan pada sekelompok baris (persis seperti dalam kasus SQL GROUP
OLEH ), dapat menggunakan dua metode serupa. Dalam contoh berikut, ingin menghitung
keseimbangan rata-rata per jenis kelamin:
In:(df.na.fill({'gender': "U", 'balance': 0.0})
.groupBy("gender").avg('balance').show())
Out:
+------+------------+
133
|gender|avg(balance)|
+------+------------+
| F| -0.25|
| M| 2.0|
| U| 7.5|
+------+------------+
In:sqlContext.sql("""
SELECT gender, AVG(balance)
FROM users
WHERE gender IS NOT NULL
GROUP BY gender""").show()
Out:
+------+-----+
|gender| _c1|
+------+-----+
| F|-0.25|
| M| 2.0|
+------+-----+
MLlib adalah pustaka pembelajaran mesin Spark; meskipun dibangun di Scala dan
Java, fungsinya juga tersedia dengan Python. Ini berisi klasifikasi, regresi, dan rekomendasi
peserta didik, beberapa rutinitas untuk pengurangan dimensi dan fitur seleksi, dan memiliki
banyak fungsi untuk pemrosesan teks. Semuanya mampu mengatasi kumpulan data yang
sangat besar dan menggunakan kekuatan semua node dalam cluster untuk mencapainya
hasil. Sampai sekarang (2016), itu terdiri dari dua paket utama: mllib , yang beroperasi RDD,
dan ml , yang beroperasi pada DataFrames. Sebagai yang terakhir berkinerja baik dan cara
paling populer untuk merepresentasikan data dalam ilmu data, pengembang telah
memilihnya berkontribusi dan meningkatkan cabang ml , membiarkan bekas tetap, tapi
tanpa lebih jauh perkembangan. MLlib tampaknya perpustakaan lengkap pada pandangan
pertama, tetapi setelah dimulai menggunakan Spark, akan melihat bahwa tidak ada pustaka
134
statistik atau numerik di file paket default. Di sini, SciPy dan NumPy datang membantu , dan
sekali lagi, mereka penting untuk ilmu data. Mari lakukan eksplorasi ini menggunakan
kumpulan data dunia nyata: kumpulan data KDD99. Tujuan dari kompetisi ini adalah untuk
menciptakan sistem deteksi intrusi jaringan yang mampu untuk mengenali aliran jaringan
mana yang berbahaya dan mana yang tidak. Apalagi banyakserangan yang berbeda ada
dalam kumpulan data; tujuannya adalah untuk memprediksi mereka secara akurat
menggunakan fitur aliran paket yang terdapat dalam dataset. Sebagai node samping pada
dataset, sangat berguna untuk mengembangkan solusi yang hebat untuk sistem deteksi
intrusi dalam beberapa tahun pertama setelah diluncurkan. Saat ini, sebagai akibatnya,
semua serangan yang termasuk dalam dataset sangat mudah untuk dideteksi dan jadi tidak
digunakan lagi dalam pengembangan IDS.
In:!rm -rf ../datasets/kdd*
# !wget -q -O ../datasets/kddtrain.gz \
# http://kdd.ics.uci.edu/databases/kddcup99/kddcup.data.gz
!wget -q -O ../datasets/kddtrain.gz \
http://kdd.ics.uci.edu/databases/kddcup99/kddcup.data_10_percent.gz
!wget -q -O ../datasets/kddtest.gz \
http://kdd.ics.uci.edu/databases/kddcup99/corrected.gz
!wget -q -O ../datasets/kddnames \
http://kdd.ics.uci.edu/databases/kddcup99/kddcup.names
!gunzip ../datasets/kdd*gz
In:
with open('../datasets/kddnames', 'r') as fh:
header = [line.split(':')[0]
for line in fh.read().splitlines()][1:]
header.append('target')
print "Num features:", len(header)-1
print "First 10:", header[:10]
Out:Num features: 41
135
First 10: ['duration', 'protocol_type', 'service', 'flag', 'src_
bytes', 'dst_bytes', 'land', 'wrong_fragment', 'urgent', 'hot']
In:
def line_parser(line):
def piece_parser(piece):
if "." in piece or piece.isdigit():
return float(piece)
else:
return piece
return [piece_parser(piece) for piece in line[:-1].split(',')]
train_df = sqlContext.createDataFrame(train_rdd.map(line_parser), header)
test_df = sqlContext.createDataFrame(
test_rdd.map(line_parser), header)
Mulai Spark 1.6, daftar ekstensif pengklasifikasi yang menggunakan antarmuka Python
adalah sebagai berikut, klasifikasi ( paket pySpark.ml.classification ):
- Regresi logistik
- DecisionTreeClassifier
- GBTClassifier (implementasi Gradient Boosted untuk klasifikasi berdasarkan pohon
keputusan)
- RandomForestClassifier
- NaiveBayes
- MultilayerPerceptronClassifier
Perhatikan bahwa tidak semuanya mampu beroperasi pada masalah multikelas dan
mungkin memiliki parameter yang berbeda; selalu periksa dokumentasi yang terkait dengan
versi di menggunakan. Di luar pengklasifikasi, pelajar lain diimplementasikan di Spark 1.6
dengan Python antarmuka adalah sebagai berikut:
• Clustering ( paket pySpark.ml.clustering ):
- KMeans
• Regresi ( paket pySpark.ml.regressi ):
136
- AFTSurvivalRegression (Accelerated Failure Time Survival regresi)
- DecisionTreeRegressor
- GBTRegressor
- IsotonicRegression
- Regresi linier
- RandomForestRegressor
• Recommender ( paket pySpark.ml.recommendation ):
- ALS (pemberi rekomendasi pemfilteran kolaboratif, berdasarkan Alternating
In:from pySpark.ml.classification import RandomForestClassifier

clf = RandomForestClassifier(
labelCol="target_cat", featuresCol="features",
maxBins=100, seed=101)
fit_clf = clf.fit(Xy_train)
In:
from pySpark.ml.evaluation import MulticlassClassificationEvaluator
evaluator = MulticlassClassificationEvaluator(
labelCol="target_cat", predictionCol="prediction",
metricName="f1")
print "F1-score train set:", evaluator.evaluate(Xy_pred_train)
print "F1-score test set:", evaluator.evaluate(Xy_pred_test)
Out:F1-score train set: 0.992356962712
F1-score test set: 0.967512379842
137
RANGKUMAN
Apache Spark adalah evolusi dari Hadoop dan menjadi sangat populer dalam beberapa
tahun terakhir. Berbeda dengan Hadoop dan desain yang berfokus pada Java dan batch,
Spark mampu menghasilkan algoritma berulang dengan cara yang cepat dan mudah. Spark
memiliki rangkaian API yang sangat kaya untuk berbagai bahasa pemrograman dan secara
native mendukung berbagai jenis pemrosesan data (pembelajaran mesin, streaming ,
analisis grafik, SQL, dan sebagainya). Apache Spark adalah kerangka kerja cluster yang
dirancang untuk pemrosesan data besar yang cepat dan bertujuan umum.
DAFTAR PUSTAKA
1. Large Scale Machine Learning with Python, 2016. Bastiaan Sjardin, Luca
LATIHAN
2) Buatlah tutorial instalasi Spark!

3) Analisis dan berikan kesimpulan, komparasi antara Hadoop dan Spark untuk
pembelajaran Machine Learning!
138
LEMBAR PENILAIAN SEJAWAT SEBIDANG ATAU PEER REVIEW DIKTAT
Judul diktat : Machine Learning

Jumlah Penulis : 1 Orang
Status Pengusul : Yuli Siyamto, S.Kom., M.Kom
Hasil Penilaian Peer Review : Rahmat Fauzi, S.Kom., M.Kom
Skor dan Kriteria Skor

No Aspek
3 2 1
Kelengkapan unsur isi
diktat
Diktat lengkap dan Diktat lengkap namun tidak Diktat tidak lengkap dan tidak
1 (Calibri, sentence case, 3
terorganisasi dengan baik terorganisasi dengan baik terorganisasi dengan baik
align left, ukuran 8, spasi
1)
Ruang lingkup dan Sesuai dengan RPS dan Beberapa bab tidak relevan Seluruh isi bab tidak sesuai
2. 2
kedalaman pembahasan mendukung CPL dengan RPS dan CPL Prodi dengan RPS dan CPL Prodi
Kecukupan dan
kemuktahiran isi 50 persen referensi yang Seluruh referensi yang
Referensi yang digunakan
3 (berkaitan dengan digunakan berusia lebih dari 10 digunakan berusia lebih dari 10 2
berusia 10 tahun terakhir
keterkinian referensi yang tahun tahun
digunakan
Kualitas diktat (berkenaan Terdapat beberapa penulisan Seluruh penulisan yang tidak
Penulisan rapi dan
dengan penulisan, yang tidak rapi dan tidak rapi dan tidak menggunakan
4 menggunakan Bahasa Indonesia 3
penggunaan Bahasa dan menggunakan Bahasa Indonesia Bahasa Indonesia yang baik dan
yang baik dan benar
lain sebagainya) yang baik dan benar benar
Skor Total 10
Komentar/ Ulasan Peer Review: Secara umum sudah baik dan sesuai panduan, materi dan konten mencukupi
Kelengkapan dan Kesesuaian Unsur Kelengkapan dan kesesuaian unsur sudah baik
Ruang Lingkup dan Kedalaman Materi Kedalaman materi sudah cukup
Kesesuaian dengan RPS dan Sudah sesuai dengan RPS dan CPL
kontribusi dalam pencapaian CPL
Batam, bulan, tahun.

Reviewer
Tanda tangan :………………………………………………………………………….

Nama : Rahmat Fauzi, S.Kom., M.Kom.
NIP : 00700
Unit kerja : Universitas Putera Batam
Bidang Ilmu : Teknik Informatika
Jabatan/Pangkat : Asisten Ahli / Penata Muda Tk. I
139

DIKTAT Machine Learning Rev Kaprodi 14 Maret 2021

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

DIKTAT Machine Learning Rev Kaprodi 14 Maret 2021

Diunggah oleh

Hak Cipta:

Format Tersedia

DIKTAT

UNIVERSITAS PUTERA BATAM

DIKTAT MACHINE LEARNING

Proses Penanggung jawab Tanggal

5. Pengendalian Dr. Realize, S. Ketua Pusat 25 Februari 2021

Batam, Februari 2021

Tabel 1 Model Klasifikasi ....................................................................................... 40

Gambar 1 Konseb Machine Learning ................................................................... 12

- Mahasiswa mampu menjelaskan tentang skalabilitas Machine Learning.

1.1 Definisi Machine Learning

Selama beberapa tahun terakhir, pembelajaran mesin telah tertanam di berbagai

1.2 Klasifikasi Machine Learning

Klasifikasi Machine Learning berdasarkan apa yang diharapkan :

Klasifikasi Machine Learning berdasarkan cara kerjanya :

Klasifikasi Machine Learning berdasarkan kemudahan interpretasi dan metode inferensinya :

Gambar 2 Klasifikasi Machine Learning

Merupakan metode yang berusaha menemukan fungsi-fungsi pendekatan yang

1. Jelaskan tentang skalabilitas Machine Learning

- Mahasiswa mampu menjelaskan tentang software pendukung pembelajaran Machine

2.1 Introducing Python

Sebagai praktisi pembelajaran mesin, tertarik menggunakan Python berbagai alasan:

>>> print sys.version

$ sudo apt-get install Python3-pip

$ pip instal <pk>

>>> impor numpy

Inilah yang terjadi jika tidak dipasang:

>>> impor numpy

Traceback (panggilan terakhir terakhir):

Seperti yang dinyatakan di situsnya, tujuan Anaconda adalah menyediakan

Misalnya, mulai mengetik yang berikut di dalam sel:

Theano adalah pustaka Python yang memungkinkan untuk mendefinisikan,

The sknn perpustakaan (untuk ekstensi, scikit-neuralnetwork ) adalah pembungkus

1. Tugas praktikum. Download dan install beberapa software berikut dengan

menggunakan perintah comment line.

klasifikasi dataset yang telah didapatkan.

- Mahasiswa mampu mengevaluasi model klasifikasi pada pembelajaran Machine

High Recall, Low Precision

Dataset berbagi https: //archive.ics. Regresi 17389, 16

jika '.csv' dalam nama:

3.2 Berbagi Kumpulan Data

Keluar: Total baris: 17380

Keluar: Total baris: 17379

3.3 Menggunakan I/O Panda

# Membuat indeks untuk bergabung lebih cepat dalam waktu lama

untuk kolom di baris:

"," .join (["?" untuk kolom di baris]))

- Mahasiswa mampu menjelaskan cara kerja algoritma Fast-Learning SVMs Python

4.1 Fast-Learning SVMs

Merupakan metode yang berusaha menemukan fungsi-fungsi pendekatan yang bernilai

4.2 Data Collection

4.3 Mesin Vektor

- Mahasiswa mampu menjelaskan artificial neural network dalam Machine Learning.

5.1 Pendahuluan Artificial Neural Network

5.2 Forward propagation

Pada prediksi akhir dengan melakukan langkah-langkah berikut:

Jaringan saraf dengan dua lapisan tersembunyi dengan NumPy :

> $ pip instal neurolab

impor neurolab sebagai

x = np.linspace (-10,10, 60) y =

x_train = x.reshape (ukuran, 1)

d = [[1,1], [45,1], [45,45,1], [45,45,45,1]]

untuk saya dalam jangkauan (4):

net = nl.net.newff ([[- 10, 10]], d [i]) train_net = nl.train.train_gd (net,