3 Library Python Terbaik Untuk Data Science

Banyaknya kelebihan pada pemrograman pythno seperti efisiensei, keterbacaan kode dan kecepatan
telah membuat python menjadi bahasa pemrograman yang banyak digunakan oleh para data
scientist. Pyton menjadi pilihan untuk pada data scientist dan machine learning engineer untuk
mengembangkan model dan berbagai aplikasi terkait data science.

Karena penggunaannya yang luas, Python memiliki banyak library yang memudahkan para ilmuwan
data / data scientist untuk menyelesaikan tugas-tugas rumit tanpa banyak gangguan pengkodean.
Berikut adalah 3 library Python yang paling banyak digunakan untuk data science.

1. NumPy

NumPy (kependekan dari Numerical Python) adalah salah satu library teratas yang dilengkapi
dengan sumber daya yang berguna untuk membantu para data scientist mengubah Python menjadi
alat analisis dan pemodelan ilmiah yang kuat. Libary Open source terpopuler ini tersedia di bawah
lisensi BSD. Ini adalah pustaka Python dasar untuk melakukan tugas dalam komputasi ilmiah. NumPy
adalah bagian dari ekosistem berbasis Python yang lebih besar dari tool open source yang disebut
SciPy.

Perpustakaan memberdayakan Python dengan struktur data substansial untuk mudah melakukan
perhitungan multi-dimensi (multi-dimensional arrays) dan perhitungan matrik. Selain
penggunaannya dalam menyelesaikan persamaan aljabar linier (linear algebra equations) dan
perhitungan matematis lainnya, NumPy juga digunakan sebagai wadah multi-dimensi serbaguna
untuk berbagai jenis data generik.

Lebih hebatnya, NumPy terintegrasi dengan bahasa pemrograman lain seperti C / C ++ dan Fortran.
Fleksibilitas perpustakaan NumPy memungkinkannya untuk dengan mudah dan cepat bergabung
dengan berbagai database dan tools. Sebagai contoh, mari kita lihat bagaimana NumPy (disingkat
np) dapat digunakan untuk mengalikan dua matriks.

Mari memulainya dengan meng-import library ini terlebih dahulu ( disini kita menggunakan Jupyter
notebook untuk contoh)

import numpy as np

Selanjutnya, kita akan menggunakan fungsi eye() untuk menghasilkan matriks identitas dengan
dimensi yang ditetapkan.

matrix_one = np.eye(3)
matrix_one
Outputnya akan seperti dibawah ini :

array([[1., 0., 0.],

[0., 1., 0.],
[0., 0., 1.]])

Mari hasilkan matriks 3x3 lainnya.

Kita akan menggunakan fungsi arange([starting number], [stopping number]) untuk mengatur
nomor. Perhatikan bahwa parameter pertama dalam fungsi adalah nomor awal yang akan didaftar
dan nomor terakhir tidak termasuk dalam hasil yang dihasilkan.

Juga, fungsi reshape() diterapkan untuk memodifikasi dimensi dari matriks yang dihasilkan secara
original ke dimensi yang diinginkan. Agar matrik bisa “multiply-able”, mereka harus memiliki dimensi
yang sama.

matrix_two = np.arange(1,10).reshape(3,3)
matrix_two

Outputnya akan seperti dibawah ini :

array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

Mari gunakan fungsi dot() untuk mengalikan dua matriks.

matrix_multiply = np.dot(matrix_one, matrix_two)

matrix_multiply

Outputnya akan seperti dibawah ini :

array([[1., 2., 3.],

[4., 5., 6.],
[7., 8., 9.]])

Kita telah berhasil melipatgandakan dua matriks tanpa menggunakan vanilla Python.

Berikut ini seluruh kode untuk contoh ini:

import numpy as np
#menghasilkan a 3 by 3 identity matrix
matrix_one = np.eye(3)
matrix_one
#menghasilkan 3 by 3 matrix lainya for perkalian
matrix_two = np.arange(1,10).reshape(3,3)
matrix_two
#mengkalikan dua array
matrix_multiply = np.dot(matrix_one, matrix_two)
matrix_multiply
2. Pandas

Pandas adalah library hebat lain yang dapat meningkatkan keterampilan Python Anda untuk data
science. Sama seperti NumPy, Pandas milik keluarga perangkat lunak open source SciPy dan tersedia
di bawah lisensi perangkat lunak bebas BSD.

Pandas menawarkan alat serbaguna dan kuat untuk struktur data dan melakukan analisis data yang
luas. Library ini berfungsi dengan baik dengan data dunia nyata yang tidak lengkap, tidak terstruktur,
dan tidak teratur — dan dilengkapi dengan tool untuk membentuk, menggabungkan, menganalisis,
dan memvisualisasikan datasets.

Ada tiga jenis struktur data di library ini:

• Series: single-dimensional, array homogen

• DataFrame: two-dimensional dengan kolom yang diketik secara heterogen
• Panel: three-dimensional, array size-mutable

Sebagai contoh, mari kita lihat bagaimana library Panda Python (disingkat pd) dapat digunakan
untuk melakukan beberapa perhitungan statistik deskriptif.

Mari mulai dengan mengimport library pandas ini.

import pandas as pd

Selanjutnya kita buat dictionary yang seri.

d = {'Name':pd.Series(['Alfrick','Michael','Wendy','Paul','Dusan','George','Andreas',
'Irene','Sagar','Simon','James','Rose']),
'Years of Experience':pd.Series([5,9,1,4,3,4,7,9,6,8,3,1]),
'Programming
Language':pd.Series(['Python','JavaScript','PHP','C++','Java','Scala','React','Ruby','Angular',
'PHP','Python','JavaScript'])
}

Selanjutnya buat Data Frame.

df = pd.DataFrame(d)

Output nya akan seperti dibawah ini :

Name Programming Language Years of Experience

0 Alfrick Python 5
1 Michael JavaScript 9
2 Wendy PHP 1
3 Paul C++ 4
4 Dusan Java 3
5 George Scala 4
6 Andreas React 7
7 Irene Ruby 9
8 Sagar Angular 6
9 Simon PHP 8
10 James Python 3
11 Rose JavaScript 1
Berikut ini seluruh kode untuk contoh ini:

import pandas as pd
#creating a dictionary of series
d = {'Name':pd.Series(['Alfrick','Michael','Wendy','Paul','Dusan','George','Andreas',
'Irene','Sagar','Simon','James','Rose']),
'Years of Experience':pd.Series([5,9,1,4,3,4,7,9,6,8,3,1]),
'Programming
Language':pd.Series(['Python','JavaScript','PHP','C++','Java','Scala','React','Ruby','Angular',
'PHP','Python','JavaScript'])
}

#Create a DataFrame
df = pd.DataFrame(d)
print(df)

3. Matplotlib

Matplotlib juga merupakan bagian dari paket inti SciPy dan ditawarkan di bawah lisensi BSD. Ini
adalah library ilmiah Python populer yang digunakan untuk menghasilkan visualisasi yang sederhana
dan kuat. Anda dapat menggunakan kerangka kerja Python untuk ilmu data untuk menghasilkan
grafik, chart, histogram, dan bentuk dan gambar lain yang kreatif — tanpa perlu khawatir menulis
banyak baris kode. Sebagai contoh, mari kita lihat bagaimana perpustakaan Matplotlib dapat
digunakan untuk membuat bar chart sederhana.

Mari memulainya dengan mengimport library

from matplotlib import pyplot as plt

Mari hasilkan nilai untuk sumbu x dan sumbu y.

x = [2, 4, 6, 8, 10]
y = [10, 11, 6, 7, 4]

Mari kita sebut fungsi untuk mem-plot diagram batang.

plt.bar(x,y)

Selanjutnya kita tampilkan plot nya.

plt.show()
Berikut adalah tampilan chart bar:

Berikut ini seluruh kode untuk contoh ini:

#mengimport library Matplotlib Python

from matplotlib import pyplot as plt
#same as import matplotlib.pyplot as plt

#menghasilkan nilai untuk x-axis

x = [2, 4, 6, 8, 10]

#menghasilkan nilai untuk y-axis

y = [10, 11, 6, 7, 4]

#memanggil function untuk plotting the bar chart

plt.bar(x,y)

#menampilkan the plot

plt.show()

Kesimpulan

Bahasa pemrograman Python selalu melakukan pekerjaan yang baik dalam hal data dan persiapan,
tetapi kurang untuk analisis dan pemodelan data ilmiah yang rumit. Untuk itulah munculnya library
Python sangat membantu untuk mengisi celah ini. Dengan adanya library ini akan memungkinkan
Anda untuk melakukan perhitungan matematis yang kompleks dan membuat model canggih yang
membuat data Anda masuk akal.
Tutorial Dasar NumPy Python

NumPy merupakan salah satu library Python yang banyak digunakan dalam proses analisis data
karena fiturnya yang hebat. NumPy hampir menyerupai List pada Python tetapi lebih powerful. Ada
beberap kelebihan NumPy dibandingkan List seperti size, performance dan functionally

Struktur data NumPy lebih membutuhkan ukuran yang lebih kecil dibandingkan dengan List tetapi
mempunyai performa yang lebih cepat

Sebelum menggunakan NumPy di Python, terlebih dahulu library ini harus diimport

import numpy as np

Jika belum ada NumPy dapat diinstall terlebih dahulu menggunakan pip

pip install numpy

Membuat Array NumPy

Kita bisa membuat Array menggunakan NumPy dengan membungkusnya terlebih dahulu
di List dan dirubah menjadi numpy array.

listku = [1,2,3,4,5]

arrku = np.array([listku])

arrku
atau langsung tanpa membuat variabel list terlebih dahulu

arrku = np.array([1,2,3,4,5])

arrku
Hasilnya akan seperti ini

array([1, 2, 3, 4, 5])

Ada beberapa fungsi lagi yang dapat digunakan dalam membuat array antara lain zeros(),
ones(), arange(), linspace(), logspace(),

zeros() -> Membuat array dengan nilai 0

ones() -> Membuat array dengan nilai 1

arange() -> Membuat array dengan nilai dalam range

linspace() -> Membuat array dengan nilai dalam interval

logspace() -> Membuat array dengan nilai log Base10 dalam interval

Berikut contohnya

np.zeros(5) # membuat array dengan nilai 0 sebanyak 5

np.ones(5) # membuat array dengan nilai 1 sebanyak 5

np.arange(1, 10, 2) #arange(start, stop, step)

np.linspace(1, 10, 2) # linespace(start, stop, number)

np.logspace(1, 10, 2) # logspace(start, stop, number)

Hasilnya

[0. 0. 0. 0. 0.]

[1. 1. 1. 1. 1.]

[1 3 5 7 9]

[ 1. 10.]

[1.e+01 1.e+10]

Multidimensional Array
Salah satu fitur menarik dari NumPy adalah dia mampu membuat multidimensional array
dan melakukan manipulasi array dengan mudah dan cepat. Multidimensional array adalah
array yang berbentuk lebih dari 1 dimensi (1D), bisa 2D, 3D, 4D dan seterusnya. Cara
membuat multidimensional array sama dengan membuat array 1 dimensi, perbedaannya
hanya pada parameter yang digunakan.

Berikut contohnya membuat array 2 dimensi

arrku = np.array([[1,2,3,4,5], [2,4,6,8,10]])

Hasilnya

array([[ 1, 2, 3, 4, 5],

[ 2, 4, 6, 8, 10]])

Array diatas adalah berbentuk (2,5) artinya mempunyai 2 baris dan 5 kolom
Kita bisa melihat jumlah elemen di setiap dimensi dengan menggunakan shape

arrku.shape

Indexing dan Slicing

Kita juga dapat melakukan indexing dan slicing terhadap array dengan mudah

Indexing dimulai dari 0 dan dimulai dengan notasi bracket “[ ]”

Misal kita ingin mencari nilai yang berada di index 0, 2, dan 4

arr_A = np.array([1,2,3,4,5])

print(arr_A[0])

print(arr_A[2])

print(arr_A[4])

Hasilnya

Untuk mengambil nilai berderet tambahkan “:”

arr_A = np.array([1,2,3,4,5])

print(arr_A[0:4])
Kita juga dapat melakukan slicing di multidimensional array

arr_A = np.array([[1,2,3,4,5], [2,4,6,8,10]])

print(arr_A)

print(arr_A[1,1])
Nilai pada kolom index ke-1 dan baris index ke-1 adalah 4
Operasi Aritmatika
Kita bisa menggunakan operasi aritmatika seperti penjumlahan, pengurangan, perkalian,
pembagian dan perpangkatan

Operator yang digunakan adalah +, -, *, / dan **

Berikut contoh operasi aritmatika pada array

arr_A = np.array([1,2,3,4,5])

arr_B = np.array([2,2,2,2,2])

print("Penjumlahan = ", arr_A + arr_B)

print("Pengurangan = ", arr_A - arr_B)

print("Perkalian = ", arr_A * arr_B)

print("Pembagian = ", arr_A / arr_B)

print("Perpangkatan = ", arr_A ** arr_B)

Hasilnya adalah

Penjumlahan = [3 4 5 6 7]

Pengurangan = [-1 0 1 2 3]

Perkalian = [ 2 4 6 8 10]

Pembagian = [0.5 1. 1.5 2. 2.5]

Perpangkatan = [ 1 4 9 16 25]

Untuk lebih jelas operasi aritmatika buka halaman ini

Operasi Matematika
NumPy mempunyai fungsi matematika yang dapat digunakan pada Array

Beberapa contoh fungsi statistik antara lain min(), max(), mean(), sum(), std()

arrku = np.array([1,2,3,4,5])

print("Nilai minimal = ", arrku.min())

print("Nilai maksimal = ", arrku.max())

print("Nilai rata-rata = ", arrku.mean())

print("Total nilai = ", arrku.sum())

print("Standar Deviasi = ", arrku.std())

Hasilnya adalah

Nilai minimal = 1

Nilai maksimal = 5

Nilai rata-rata = 3.0

Total nilai = 15

Standar Deviasi = 1.4142135623730951

Ada juga fungsi argmin() dan argmax() untuk mendapatkan index dari nilai minimum dan
maksimum

print("Index nilai niminal = ", arrku.argmin())

print("Index nilai maksimal = ", arrku.argmax())

Hasilnya

Index nilai niminal = 0

Index nilai maksimal = 4

Belajar Numpy Dengan Anaconda :

Memulai Menjalankan Program

Salah satu alasan mengapa banyak orang memilih Python kala hendak mendalami, komputasi
numerik, data sains, ataupun bahkan machine learning adalah tersedianya banyak pustaka Python
yang memang dikhususkan untuk itu.

Salah satunya adalah Numpy, yang merujuk kepada situs resminya disebutkan bahwa

NumPy is the fundamental package for scientific computing with Python.

Numpy adalah paket dasar Python guna keperluan komputasi saintifik. Pada dasarnya
adalah library untuk bahasa pemrograman Python yang mendukung perhitungan operasi array multi
dimensi dan matriks beserta dengan kumpulan fungsi matematika tingkat tinggi.

NumPy berada di dalam lisensi BSD yang memungkinkan programmer menggunakan ulang dengan
beberapa batasan.

• Menginstall Numpy
Untuk mulai menggunakan Numpy, penulis akan menginstall Numpy menggunakan Anaconda.
Diasumsikan pembaca telah mengikuti artikel sebelumnya tentang bagaimana menginstal Anaconda
dan mengatur environment pertama kali. Jika belum, anda bisa membacanya pada tautan ini.

Misalkan programmer telah mengeset environment bernama belajar yang menggunakan Python 3.7

Untuk menginstall package Numpy pastikan centang pilihan numpy. kemudian klik Apply sepert
tangkapan layar berikut
Tunggu beberapa saat ketika Anaconda mengunduh library dari repository. Periksa kembali, jika
package sudah terinstal dengan benar maka hasilnya akan sesuai dengan tangkapan layar berikut

Advertisement

• Anaconda Prompt
Jalankan Anaconda Prompt, lalu pindah ke virtual environment belajar, kemudian navigasi ke direktori
workspace yang diinginkan, setelah itu ketik perintah jupyter notebook untuk melanjalankan Jupyter
Notebook seperti tangkapan layar berikut.

Tunggu beberapa saat hingga Jupyter Notebook dijalankan pada browser.

• Jupyter Notebook
Berikut adalah tampilan Jupyter Notebook saat pertama kali dijalankan
Untuk memulai program baru, klik button New > Python 3

Saat jendela baru Untitled terbuka. Programmer dapat memulai menulis program Python. Misalkan
programmer ingin sekedar memberi judul program (semacam komentar namun bertipe markdown) pilih
drowdown Markdown dan tulis judul pada line [1]

Advertisement

Misalkan saya memberi nama Hello Numpy. Ketik Alt + Enter

Untuk membuat program Python di line berikutnya, pilih jenis inputan berupa Code lalu ketikkan sebagai
berikut

In [ 1 ] import numpy

in [ 2 ] numpy.version.full_version

Akan muncul keluaran pada Out sebagai berikut

Out [2] 1.15.4

Berikut adalah tangkapan layar dari eksperimen yang penulis lakukan

Sampai sini, programmer telah berhasil memanggil library numpy dan mengetahui versi berapa dari
numpy yang sedang dikerjakan. Pada tulisan berikutnya, subrutin akan membahas lebih dalam
bagaimana menggunakan numpy untuk menyeleseikan beberapa operasi dasar pada array dan matrix.
 Belajar Machine Learning Dengan Python
(Bagian 1)
Python adalah bahasa interpeter yang populer dan powerful. Tidak seperti R, Python adalah bahasa
yang memiliki fitur yang lengkap dan memiliki platform yang dapat digunakan baik untuk riset
maupun untuk membangun production system. Ada banyak modul dan library yang dapat
digunakan untuk menerapkan Machine Learning di dalam Python.
Untuk memulai proyek Machine Learning, harus mengetahui langkah-langkah sebagai berikut:
1. Mendefinisikan masalah
2. Menyiapkan Data
3. Mengevaluasi Algoritma
4. Memperbarui Hasil
5. Menyajikan Hasil

Langkah-langkah menerapkan Machine Learning dengan Python

1. Instalasi Platform Python dan Scipy
Untuk mendapatkan software aplikasi Python dan Scipy, dapat mengunjungi situs scipy.org. Disana
akan diberikan petunjuk yang lengkap untuk menginstall python dan library yang dibutuhkan, baik
dalam platform Linux, Mac OS X maupun Windows. Ada 5 library utama yang perlu diinstall untuk
tutorial ini: Scipy, Numpy, Matplotlib, Panda, dan Sklearn.
Memulai Python
Untuk memastikan lingkungan Python sudah berhasil diinstall, berikut langkah-langkah yang bisa
dilakukan:
Buka baris perintah dan memulai python, di console command prompt

1 Python

Ketik atau copy dan paste script berikut:

1 # Check the versions of libraries

2
3 # Python version
4
5 import sys
6
7 print('Python: {}'.format(sys.version))
8
9 # scipy
10
11 import scipy
12
13 print('scipy: {}'.format(scipy.__version__))
14
15 # numpy
16
17 import numpy
18
19 print('numpy: {}'.format(numpy.__version__))
20
21 # matplotlib
22
 23 import matplotlib
24
25 print('matplotlib: {}'.format(matplotlib.__version__))
26
27 # pandas
28
29 import pandas
30
31 print('pandas: {}'.format(pandas.__version__))
32
33 # scikit-learn
34
35 import sklearn
36
37 print('sklearn: {}'.format(sklearn.__version__))
38
39 output yang dihasilkan, seperti contoh berikut:
40
41 Python: 3.6.1 |Anaconda 4.4.0 (64-bit)| (default, May 11 2017, 13:25:24) [MSC v.1900 64 bit (AMD64)]
42
43 scipy: 0.19.0
44
45 numpy: 1.12.1
46
47 matplotlib: 2.0.2
48
49 pandas: 0.20.1
50
51 sklearn: 0.18.1

Data yang Digunakan

Untuk latihan proyek Machine Learning ini menggunakan dataset klasifikasi Bunga Iris. Dataset ini
dikenal dengan dataset “hello world” dalam Machine Learning dan Statistik, yang dipakai oleh
hampir semua orang.
Dataset ini berisi 150 pengamatan bunga Iris. Ada empat kolom pengukuran bunga dalam
centimeter. Kolom kelima adalah spesies bunga yang diamati. Anda dapat mempelajari lebih lajut
tentang dataset ini di Wikipedia.

Impor Library
Sebelum memuat dataset terlebih dahulu impor semua modul, fungsi dan obyek yang akan
digunakan dalam tutorial ini.

1 # Load libraries
2
3 import pandas
4
5 from pandas.tools.plotting import scatter_matrix
6
7 import matplotlib.pyplot as plt
8
9 from sklearn import model_selection
10
11 from sklearn.metrics import classification_report
12
13 from sklearn.metrics import confusion_matrix
14
15 from sklearn.metrics import accuracy_score
16
17 from sklearn.linear_model import LogisticRegression
18
19 from sklearn.tree import DecisionTreeClassifier
20
21 from sklearn.neighbors import KNeighborsClassifier
 22
23 from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
24
25 from sklearn.naive_bayes import GaussianNB
26
27 from sklearn.svm import SVC

2. Memuat Dataset
Untuk memuat dataset, dapat langsung diambil dari alamat repository UCI Machine Learning.
Berikut script untuk memuat dataset:

1 # Load dataset
2
3 url = "http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
4
5 names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
6
7 dataset = pandas.read_csv(url, names=names)

Jika tidak ada koneksi internet, file iris.data dapat download terlebih dahulu, diletakkan di file local.
Untuk memuat data-nya dapat dilakukan dengan metode yang sama, dengan mengubah URL ke
file local.
3. Melakukan Summary Dataset
Pada langkah ini, kita akan melihat data dari beberapa sisi yang berbeda:
• Dimensi Dataset
Hal ini dilakukan untuk mendapatkan gambaran singkat tentang berapa banyak baris dan atribut
data.

1 # shape
2
3 print(dataset.shape)

Selanjutnya akan terlihat output : (150,50)

Yang berarti 150 baris dan 5 atribut data
• Melihat Isi Data
Berikut perintah untuk melihat 20 baris data pertama:

1 # head
2
3 print(dataset.head(20))
• Ringkasan Statistik
Berikut untuk melihat statistik data termasuk count, mean, nilai min dan max serta beberapa
persentase

1 # descriptions
2
3 print(dataset.describe())

• Distribusi Class Data

Sekarang mari kita lihat jumlah baris untk setiap class.

1
# class distribution

print(dataset.groupby(‘class’).size())
Akan terlihat bahwa setiap class memiliki jumlah kasus yang sama (50 atau 33% dari kumpulan
data)

1 class
2
3 Iris-setosa 50
4
5 Iris-versicolor 50
6
7 Iris-virginica 50
 Pada artikel Belajar Machine Learning Dengan Python (Bagian 1) , kita telah membahas
mengenai langkah 1 sampai 3. Artikel ini adalah lanjutan langkah untuk memulai proyek Machine
Learning.
• Visualisasi Data
Dalam melakukan visualisasi data, ada dua jenis plot:
1. Plot Univariate
Kita mulai dengan beberapa plot univariat, yaitu plot dari masing-masing variabel individu.
Mengingat bahwa variabel inputnya numerik, kita bisa membuat jenis plot box.

1 # box and whisker plots

2
3 dataset.plot(kind='box', subplots=True, layout=(2,2), sharex=False, sharey=False)
4
5 plt.show()

Selanjutnya juga bisa membuat histogram masing-masing variabel input untuk mendapatkan ide
tentang distribusi.

1 # histograms
2
3 dataset.hist()
4
5 plt.show()
2. Plot Multivariate
Selanjutnya kita bisa melihat interaksi antar variabel. Pertama, kita lihat scatterplots dari semua
pasang atribut. Hal ini dapat membantu melihat hubungan terstruktur antara variabel input
1 # scatter plot matrix
2
3 scatter_matrix(dataset)
4
5 plt.show()

Dari hasil output dapat dilihat pengelompokan diagonal beberapa pasang atribut. Hal ini
menunjukkan korelasi yang tinggi dan hubungan yang dapat diprediksi.
1. Evaluasi Beberapa Algoritma

Langkah berikutnya adalah membuat beberapa model data dan memperkirakan akurasi mereka
pada data yang tidak terlihat.
Beberapa hal yang dapat dilakukan di langkah ini adalah:
1. Pisahkan dataset validasi
2. Set up test harness untuk menggunakan validasi silang 10 kali lipat
3. Bangun 5 model yang berbeda untuk memprediksi spesies dari pengukuran bunga
4. Pilih model yang terbaik

• Membuat validasi dataset

Validasi ini dilakukan untuk mengetahui bahwa model yang dibuat itu bagus. Kita akan
menggunakan metode statistik untuk memperkirakan keakuratan model yang dibuat pada data yang
tidak terlihat. Juga diinginkan perkiraan yang lebih konkret mengenai keakuratan model teraik pada
data yang tidak terlihat dengan mengevaluasi data aktual yang tidak terlihat.

Artinya, kita akan menahan beberapa data yang tidak dapat dilihat oleh algoritma dan akan
menggunakan data ini untuk mendapatkan informasi tentang seberapa akurat model terbaik
sebenarnya.

Kita akan membagi datateset yang telah dimuat menjadi dua, 80% diantaranya akan digunakan
untuk melatih model dan 20% digunakan untuk data validasi.
 1 # Split-out validation dataset
2
3 array = dataset.values
4
5 X = array[:,0:4]
6
7 Y = array[:,4]
8
9 validation_size = 0.20
10
11 seed = 7
12
13 X_train, X_validation, Y_train, Y_validation = model_selection.train_test_split(X, Y, test_size=validation_size, random_state=seed)

Setelah perintah di atas dieksekusi, kita sudah memiliki dua data yaitu X_train dan Y_train untuk
mempersiapkan model dan rangkaian X_validation dan Y_validation yang dapat digunakan
selanjutnya.

• Test Harness

Kita akan menggunakan validasi silang 10 kali lipat untuk memperkirakan akurasi. Untuk itu dataset
dibagi menjadi 10 bagian, 9 untuk latihan dan 1 untuk pengujian dan ulangi untuk semua kombinasi.

1 # Test options and evaluation metric

2
3 seed = 7
4
5 scoring = 'accuracy'

Perintah di atas menggunakan metrik “accuracy” untuk mengevaluasi model. Ini adalah rasio dari
jumlah kejadia yang diprediksi dengan benar dibagi dengan jumlah total kasus dalam dataset
dikalikan dengan 100 untuk memberikan persentase (misalnya 95% akurat). Kita akan
menggunakan variabel penilaian saat menjalankan build dan mengevaluasi setiap model di langkah
selanjutnya

• Membangun Model
Kita tidak tahu algoritma mana yang bagus dalam masalah ini atau konfigurasi apa yang akan
digunakan. Untuk itu kita evaluasi 6 algoritma yang berbeda:

• Logistic Regression (LR)

• Linear Discriminant Analysis (LDA)
• K-Nearest Neighbors (KNN).
• Classification and Regression Trees (CART).
• Gaussian Naive Bayes (NB).
Support Vector Machines (SVM).

1 # Spot Check Algorithms

2
3 models = []
4
5 models.append(('LR', LogisticRegression()))
6
7 models.append(('LDA', LinearDiscriminantAnalysis()))
8
 9 models.append(('KNN', KNeighborsClassifier()))
10
11 models.append(('CART', DecisionTreeClassifier()))
12
13 models.append(('NB', GaussianNB()))
14
15 models.append(('SVM', SVC()))
16
17
18
19
20
21
22
23 # evaluate each model in turn
24
25 results = []
26
27 names = []
28
29 for name, model in models:
30
31 kfold = model_selection.KFold(n_splits=10, random_state=seed)
32
33 cv_results = model_selection.cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
34
35 results.append(cv_results)
36
37 names.append(name)
38
39 msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
40
41 print(msg)

• Memilih Model Terbaik

Kita sudah memiliki 6 model dan estimasi akurasi untuk masing-masing. Selanjutnya perlu
membandingkan model satu dengan lainnya dan pilih yang paling akurat.

Dari eksekusi script di atas, kita mendapatkan hasil mentah sebagai berikut:

LR: 0.966667 (0.040825)

LDA: 0.975000 (0.038188)
KNN: 0.983333 (0.033333)
CART: 0.975000 (0.038188)
NB: 0.975000 (0.053359)
SVM: 0.991667 (0.025000)

Dari hasil output di atas, kita dapat melihat bahwa SVM memiliki nilai akurasi perkiraan terbesar.
Kita juga dapat membuat plot hasil evaluasi model dan membandingkan penyebaran dan akurasi
rata-rata masing-masing model.

1 # Compare Algorithms
2
3 fig = plt.figure()
4
5 fig.suptitle('Algorithm Comparison')
6
7 ax = fig.add_subplot(111)
8
 9 plt.boxplot(results)
10
11 ax.set_xticklabels(names)
12
13 plt.show()

• Membuat Prediksi

Setelah mengetahui model yang paling akurat yaitu SVM, selanjutnya kita dapat mencoba
melakukan pengujian tentang keakuratan model SVM terhadap data yang ada.

1 # Make predictions on validation dataset

2
3 svm = SVC()
4
5 svm.fit(X_train, Y_train)
6
7 predictions = svm.predict(X_validation)
8
9 print(accuracy_score(Y_validation, predictions))
10
11 print(confusion_matrix(Y_validation, predictions))
12
13 print(classification_report(Y_validation, predictions))
Menghasilkan output :

Confusion matrix memberikan indikasi dari tiga kesalahan yang dibuat.

Akhirnya, laporan klasifikasi (classification report) memberikan rincian setiap kelas (class-species)
dengan precision, recall, f1-score dan support yang menunjukkan hasil yang sangat baik.

Pengenalan dan Panduan Jupyter Notebook untuk

Pemula
Jupyter notebook adalah software sangat sangat populer beberapa tahun terakhir. Mungkin sebagian besar dari
pembaca sudah menggunakannya sehari-hari. Tapi mungkin ada beberapa yang baru mengenal nama saja dan belum
terlalu mengerti. Atau bahkan mungkin baru mendengar. Jangan kuatir, tulisan ini akan mengenalkan Anda kepada
Jupyter notebook dari nol sampai sedikit menguasainya.

Apakah Jupyter Notebook dan Kenapa Dia Begitu Populer

Jupyter (https://jupyter.org/) adalah organisasi non-profit untuk mengembangkan software interaktif dalam
berbagai bahasa pemrograman. Notebook adalah satu software buatan Jupyter, adalah aplikasi web open-source yang
memungkinkan Anda membuat dan berbagi dokumen interaktif yang berisi kode live, persamaan, visualisasi, dan teks
naratif yang kaya.

Mungkin penjelasan di atas kurang jelas. Ilustrasinya begini. Dulu, biasanya kita membagikan kode dan dokumen
secara terpisah. Kode-kode kita satukan dalam sebuah librari/aplikasi/proyek (Visual Studio, Eclipse, dsb), dan
dokumen kita buat dengan penyunting kata. Dalam dokumen bisa tampilkan cuplikan kode, tampilan hasil, dan
visualisasi lainnya dari program kita.

Nah Jupyter Notebook menyatukan semua ini, baik itu teks/narasi, kode hidup, persamaan, tampilan hasil, gambar
statis, dan visualisasi grafis, dalam satu file interaktif. Dan, kelebihan lainnya, notebook dapat dijalankan ulang oleh
siapapun yang membukanya, untuk mereproduksi eksekusi kode di dalamnya.
Contohnya adalah dokumen ini sendiri. Dokumen ini aslinya adalah sebuah Jupyter Notebook. Mungkin Anda
membacanya di blog IndoML, karena notebook ini telah dikonversi menjadi blog WordPress dengan menggunakan
utilitas nb2wp. Anda bisa melihat file aslinya di GitHub, dan akan tampak keluaran yang sama.
Nah keistimewaan dari dokumen ini adalah kemampuannya membawa kode hidup (live code). Seperti di bawah ini.
In [1]:

import datetime
import matplotlib.pyplot as plt

now = datetime.datetime.now()
print('Halo teman. Waktu sekarang adalah {}'.format(now))
Halo teman. Waktu sekarang adalah 2019-09-25 16:56:28.841249

Kode di atas bukan sekedar cuplikan tulisan kode di dokumentasi, tapi adalah kode hidup. Kalau Anda melihat tulisan
ini di blog IndoML atau di GitHub, memang yang Anda lihat adalah tampilan statis dari eksekusi terakhir ketika
notebook ini disimpan. Ibaratnya Anda sedang melihat sebuah dokumen. Tampilannya tidak akan berubah. Tapi kalau
Anda menjalankan file notebook ini di instalasi Jupyter Anda, maka Anda bisa menjalankan kode di atas dan nanti akan
keluar tampilan waktu yang berbeda tentunya!

Jenis keluaran kode yang didukung juga tidak sebatas teks sederhana seperti di atas. Bisa juga grafik seperti ini:
In [2]:

import numpy as np

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))

fig.suptitle('Contoh Beberapa Grafis Acak')
rng = np.random.RandomState(0)
x = rng.randn(100)
y = rng.randn(100)
colors = rng.rand(100)
sizes = 1000 * rng.rand(100)

ax1.scatter(x, y, c=colors, s=sizes, alpha=0.3, cmap='viridis')

ax1.set_xlabel('Sumbu X')
ax1.set_ylabel('Sumbu Y')

x = np.linspace(0, 10, 30)

y = np.sin(x)
ax2.plot(x, y, '-ok')
ax2.set_xlabel('Sumbu X')
ax2.set_ylabel('Sumbu Y')

fig.tight_layout(rect=[0, 0.03, 1, 0.97])

plt.show()
Bisa juga menampilkan tabel/DataFrame pandas misalnya seperti ini:
In [3]:

import pandas as pd

df = pd.DataFrame({
'nama':['joni','meri','peter','japri','budi','lisa'],
'umur':[23,78,22,19,12,33],
'propinsi':['Sumatera Selatan','Jatim','DKI','Bali','Papua','NTT']
})
df
Out[3]:

nama propinsi umur

0 Sumatera
joni 23
Selatan

1 meri Jatim 78

2 peter DKI 22

3 japri Bali 19

4 budi Papua 12

5 lisa NTT 33
Banyak jenis-jenis media lain yang bisa ditampilkan secara hidup, misalnya Markdown, HTML, audio, video, Javascript,
dan sebagainya.

Dengan begitu kayanya interativitas yang disediakan Jupyter notebook, maka Anda bisa melihat potensi
penggunaannya, terutama untuk riset dan kolaborasi. Saya sendiri sering sekali menemukan penggunaan Jupyter
notebook, misalnya di kursus-kursus online (MOOC) sebagai platform bagi murid untuk melakukan pemrograman, di
Kaggle, dan banyak periset-periset yang membagikan karyanya dalam bentuk notebook.

Apakah Jupyter Notebook Hanya Untuk Python?

Tidak. Walaupun Jupyter notebook ditulis dalam bahasa Python, namun kemampuan untuk mendukung suatu
bahasa pemrograman di dalam notebook diimplementasikan secara modular dalam bentuk kernel. Saat ini ada lebih
dari 130 kernel yang mendukung hampir 100 bahasa pemrograman misalnya:

• bash,

• C,

• C++,

• C#,

• Clojure,

• Common LISP,

• Erlang,

• F#,

• Go,

• J,

• Java,

• Julia,

• livescript,

• Lua,

• Matlab,

• NodeJS,

• Perl,

• PHP,

• Prolog,

• Python,

• Q,

• R,

• Ruby,
 • Scala,

• SQL,

• Tcl, dan

• Zsh.

Untuk daftar lengkapnya silakan lihat laman Jupyter Kernels.

Nah sekarang mudah-mudahan Anda semakin tertarik untuk mencoba Jupyter notebook. Mari kita install.

Petunjuk Instalasi Jupyter Notebook

Sebelumnya, semestinya Anda harus mempunyai instalasi Python. Kalau belum, maka Anda perlu menginstalasinya
terlebih dahulu dari https://www.python.org/downloads/. Pilih Python versi 3 terakhir.
Ada beberapa cara untuk menginstall Jupyter, tapi menurut saya yang paling praktis adalah menggunakan pip.
Cukup jalankan perintah ini di Terminal (Mac/Linux) atau Command Prompt (Windows):

pip3 install jupyter

Alternatifnya, kalau Anda mengalami kesulitan menginstall dengan cara di atas, mungkin bisa dicoba cara ini:

python3 -m pip install --upgrade pip

python3 -m pip install jupyter

Setelah terinstall, maka siap dijalankan.

Menjalankan Jupyter Notebook

Untuk menjalankan Jupyter Notebook, jalankan perintah di bawah ini di Terminal (Mac/Linux) atau Command
Prompt (Windows) dari direktori yang menaungi semua direktori proyek-proyek Anda (misalnya Anda mempunyai
dua proyek yaitu di C:\project\project1 dan C:\project\project2, maka jalankan dari
direktori C:\project agar Anda bisa mengakses kedua proyek tersebut dari Jupyter).

jupyter notebook

Setelah beberapa saat, jupyter akan membuka laman http://localhost:8888/ yang merupakan laman depan dari
instalasi Jupyter notebook Anda (disebut laman Notebook Dashboard).

Notebook Dashboard

Laman ini menampilkan semua direktori dan file yang ada di direktori di mana Jupyter dijalankan. Di tempat saya
tampilannya seperti ini:
Sekarang kita siap membuat notebook baru.

Membuat Notebook Baru

Klik tombol New, lalu pilih Python 3 seperti pada gambar di bawah ini:

Sebuah tab (atau window) baru akan muncul di browser Anda, berisi notebook baru yang kosong. Setelah beberapa
saat (tunggu sampai tulisan “Starting” di judul tab hilang), kita siap menyunting notebook tersebut.

Menyunting Notebook

Mari kita kenali bagian-bagian utama dari tampilan notebook.

Judul
Yang pertama harus Anda sunting adalah judul. Masukkan judul dengan mengklik tulisan Untitled di atas. Harap
diperhatikan bahwa judul ini akan menjadi nama file notebooknya juga.

Sel dan Jenis Sel

Setelah itu, bagian penting yang Anda harus ketahui adalah sel (Inggris: cell) (lihat gambar di atas). Sel adalah
tempat Anda menuliskan karya Anda, baik berupa narasi ataupun kode. Nantinya notebook akan berisi banyak sel.
Saat ini notebook hanya mempunyai satu sel. Jenis sel Anda pilih dengan memilih pada dropdown jenis sel seperti
yang ditunjukkan pada gambar. Pada awalnya, jenis sel adalah kode.

Untuk sel pertama, sebaiknya kita isi dengan narasi awal tentang karya kita, misalnya judul, pendahuluan, dsb. Ikuti
petunjuk berikut.

Menulis Narasi dengan Markdown

Untuk menulis narasi, gantilah jenis sel menjadi Markdown dari pilihan dropdown jenis cell di atas. Lalu tulislah
judul dan narasi awal untuk karya Anda, misalnya seperti ini:

Sintaks Markdown akan dijelaskan di bawah, tapi kalau Anda sekarang penasaran Anda bisa melihat detilnya di
laman Markdown cheatsheet.
Ketika kita menyunting sel seperti ini, maka sel disebut sedang dalam mode edit. Perhatikan garis kotak hijau yang
mengelilingi sel. Pada mode ini, untuk sel Markdown kode sumber Markdownnya akan ditampilkan.

Untuk menampilkan hasil tulisan Markdown kita itu, sel harus dijalankan.

Menjalankan Sel

Untuk melihat tampilan sebuah sel, maka sel itu harus kita jalankan, dengan salah satu cara berikut (kalau selnya
masih belum mendapatkan fokus, maka kliklah sekali agar dia fokus):
 Cara
Menjalankan Kunci Pintas Keterangan
dari Menu

Ctrl+Enter
Menu Cell – (atau Cmd+Enter untuk Menjalankan
> Run Cells Mac) sel

Menjalankan
Menu Cell –
sel lalu
> Run Cells Shift+Enter memindahkan
and Select
fokus ke sel
Below
berikutnya

Menjalankan
Menu Cell – Alt+Enter sel lalu
> Run Cells (atau Option+Enter untuk membuat sel
and Insert Mac) baru di
Below
bawahnya

Menjalankan sel mempunyai makna yang berbeda tergantung jenis selnya. Untuk jenis sel Markdown, maka ini akan
merubah kode Markdown itu menjadi tampilan yang diharapkan (dirender). Untuk jenis sel kode, maka kodenya
akan dijalankan oleh kernel, perubahan state akan disimpan oleh kernel, dan hasilnya ditampilkan di notebook.
Sebagai tambahan informasi, ada cara untuk menjalankan semua sel yang bisa Anda lihat di menu Cell:

• Run All

• Run All Above

• Run All Below

Menjalankan Sel Markdown

Mari kita eksekusi sel Markdown kita di atas, dan hasilnya akan seperti ini:

Setelah sel dieksekusi, maka sel disebut ada dalam mode command. Perhatikan garis kotak biru yang mengelilingi
sel.

Menyunting Kembali
Ketika sel dalam mode command, untuk menyunting kembali di mode edit Anda bisa mengklik ganda sel itu atau
mengklik sekali untuk menjadikan sel itu fokus lalu menekan Enter.
Selanjutnya mari kita membuat sel baru bertipe kode. Tambahkan sel baru dengan memilih menu Insert –> Insert
Cell Below, atau dengan menekan tombol + dari toolbar. Secara default, jenis sel baru adalah kode jadi kita tidak
perlu merubah jenisnya.

Menulis dan Menjalankan Kode

Mari kita sunting sel kode seperti di bawah ini:

Perhatikan juga bahwa untuk jenis sel kode, ada braket kotak di sebelah kiri sel, bertuliskan “In [ ]:“. Braket
kotak ini nanti akan diisi angka urutan eksekusi setelah selnya dieksekusi.

Mari kita jalankan. Hasilnya akan seperti ini:

kodenya dijalankan. Perhatikan braket kotaknya sekarang terisi nomor urutan eksekusi (“In [1]:“). Nomor ini
berguna karena urutan eksekusi tidak harus sama dengan urutan sel dalam notebook. Misalnya Anda punya lima sel,
katakanlah sel 1 2 3 4 5, maka bisa saja Anda mengeksekusinya dengan urutan 1 4 2 5 3. Hal ini mungkin terdengar
aneh sekarang. Tapi pada prakteknya ini merupakan hal yang sangat biasa Anda lakukan nantinya. Seperti kalau kita
menyunting dokumen atau kode, maka sering kita menyunting bagian-bagian secara melompat-lompat. Makanya
nomor urutan eksekusi ini sangat berguna untuk diperhatikan.

Lingkup (Scope) Variabel

Variabel-variabel dan fungsi-fungsi yang Anda deklarasikan di sel akan mempunyai lingkup global, dan bisa diakses
dari sel lainnya. Misalnya, mari kita membuat sel baru yang mengakses variabel msg yang kita deklarasikan di sel
kedua tadi (ingat, sel pertama kita adalah Markdown):
Anda bisa mengakses variabel global yang didefinisikan di sel lain, asalkan sel tempat variabel tersebut didefinisikan
telah dieksekusi sebelumnya. Cara melihatnya adalah dengan melihat nomor eksekusi dalam braket kotak di sebelah
kiri sel itu. Karena nomor eksekusinya lebih kecil dari nomor sekarang (nomor eksekusi sel itu 1, dan nomor sekarang
2), dan kernelnya sama, maka berarti sel tersebut telah tereksekusi sebelumnya.

Membuat Narasi yang Lebih Kaya dengan Markdown

Dengan Markdown kita bisa membuat teks narasi yang cukup kaya. Semua fitur-fitur dasar yang dibutuhkan dalam
penyuntingan teks didukung oleh Markdown, misalnya heading/judul, mulai heading 1 sampai heading 6, tipografi
(huruf tebal, miring, huruf tetap, tebal miring, tercoret, dsb.), list:
• item 1
• item 2
o item 2a
o item 2b
• item 3
List bernomor:
1. item 1
2. item 2
1. item 2a
2. item 2b
3. item 3

Dan juga tautan, gambar, tabel, kode, video, dan sebagainya. Banyak fitur-fitur ini yang sudah Anda lihat sendiri
dalam notebook yang sedang Anda baca ini! Kalau dibutuhkan fitur yang belum ada, bisa kita tuliskan dengan
markup HTML.

Referensi lengkap dari Markdown dapat Anda lihat di laman Markdown Cheatsheet.
Harap dibedakan kode yang merupakan bagian dari narasi (di dalam sel Markdown), dengan kode hidup yang ada di
dalam sel kode. Cuplikan kode dalam sel Markdown juga diwarnai sesuai sintaks (syntax coloring), sehingga terlihat
bagus seperti pada cuplikan berikut:
 def katakan(berita):

"""Fungsi untuk mengatakan berita"""

print(berita)

Jangan salah, cuplikan kode di atas hanyalah berupa teks Markdown dan tidak dapat dieksekusi, karena bukan dalam
sel kode.
Cuplikan kode di atas ditulis dengan membungkus kodenya dengan tiga backtick (```), lalu tuliskan bahasa
pemrograman yang diinginkan untuk mengaktifkan pewarnaan sintaks, seperti ini:
```python
def katakan(berita):
"""Fungsi untuk mengatakan berita"""
print(berita)
```

Persamaan Latex

Markdown mendukung Latex untuk menampilkan ekspresi matematika, yang bisa ditampilkan dalam baris yang
sama misalnya: atau dalam baris tersendiri:

Menyimpan dan Membuka Notebook

Menyimpan Notebook

Untuk menyimpan notebook, Anda bisa melakukan salah satu di bawah ini:
• tekan kunci Ctrl+S (atau Cmd+S di Mac)

• pilih dari menu File –> Save and Checkpoint

• tekan tombol disket dari toolbar

Menutup Notebook
Untuk menutup notebook, pilih dari menu File –> Close and Halt.

Kadang-kadang window/tab browser tidak tertutup setelah Anda melakukan itu. Anda bisa menutup tab/window
browser secara manual.

Membuka Kembali Notebook

Anda bisa membuka notebook dari Notebook Dashboard dengan mengklik notebooknya:
Latihan
Sekarang karena Anda sudah mengerti operasi-operasi dasar notebook, mari kita berlatih. Caranya adalah dengan
mengunduh contoh-contoh notebook berikut ini ke direktori di mana jupyter anda jalankan, lalu buka
notebooknya dari Notebook Dashboard. Silakan Anda oprek-oprek notebook itu, lalu kembali ke sini.

• Introduction to Python oleh Bryn Mawr College – dasar-dasar Python [Unduh]

• Introduction to Python oleh Ondrej Lexa – dasar-dasar Python juga [Unduh] (Save-As ke file)

Membagikan Notebook

Kini saatnya untuk membagikan karya gemilang notebook Anda pada orang-orang! Ada banyak cara untuk
membagikan notebook.

Secara Statis dengan Export File

Anda bisa membagikan notebook Anda sebagai file PDF, HTML, Latex, Rst, atau Markdown dengan cara memilih
menu File –> Download as. Cara ini cocok kalau kalau penerimanya kurang mengerti teknis, misalnya bos Anda
hehe.

Secara Statis/Dinamis dengan GitHub/GitLab

Kalau pekerjaan Anda tersimpan di GitHub atau GitLab, maka Anda cukup bagikan link ke file notebook di
GitHub/GitLab itu. Sebagai contoh Anda bisa melihat file notebook ini di tautan ini. Penerima bisa melihat tampilan
dari notebook Anda dari situ, atau mengunduhnya dan menjalankannya sendiri di komputernya.

Menurut saya cara ini adalah cara yang paling praktis untuk membagikan notebook ke kolega Anda.
Secara Dinamis dengan Google Colab

Google Colab (https://colab.research.google.com) adalah layanan gratis untuk kolaborasi Jupyter notebook. Seperti
Google Doc dipakai untuk berkolaborasi dalam penyuntingan dokumen, Google Colab dipakai untuk berkolaborasi
dalam penyuntingan Jupyter notebook.

Colab juga menyediakan fitur eksekusi di GPU (gratis) bagi notebook Anda, sehingga sangat berguna untuk melatih
model pembelajaran mesin Anda.

Colab bisa membuka notebook Anda dari GitHub, tapi kalau notebook Anda membutuhkan file lain (misalnya file
gambar, atau file Python yang diimport oleh notebook Anda) maka mungkin harus ada langkah-langkah lain yang
harus Anda lakukan (saya belum terlalu mencoba).

Secara Statis dengan Nbviewer

Nbviewer (https://nbviewer.jupyter.org/) adalah layanan untuk melihat notebook secara statis. Kalau notebook
Anda dapat terakses dengan sebuah URL, maka cukup berikan URLnya ke Nbviewer untuk melihatnya. Sebagai
contoh, Anda bisa melihat notebook ini di nbviewer di tautan ini.

Cara ini tidak banyak berbeda dengan melihat notebook dengan GitHub/GitLab. Tapi GitHub kadang bermasalah
dalam menampilkan notebook, jadi cara ini bisa menjadi alternatif.

Bagikan File Notebook Beserta Kebutuhannya

Anda juga bisa bagikan saja file notebooknya kepada kolega Anda. Jika Anda ingin kolega Anda bisa menjalankan
notebook itu, jangan lupa untuk mengikutsertakan file-file yang dibutuhkan notebook itu (misalnya file gambar, atau
file Python yang diimport oleh notebook Anda). Tapi kalau kolega Anda hanya ingin melihat tampilannya, maka
cukup dibagikan notebooknya saja.

Cara ini hanya efektif kalau notebook Anda tidak tergantung pada file-file lain.

Tampilkan di WordPress dengan Utilitas nb2wp

Kalau blog Anda di WordPress, cara yang paling tepat untuk mempublikasikan notebook Anda menurut saya adalah
dengan mengkonversinya ke HTML sederhana dengan utilitas nb2wp. Silakan Anda baca tautan nb2wp untuk
informasi lebih lanjut.
WordPress.com (bedakan dengan self-hosted WordPress) memberikan banyak keterbatasan dalam penyuntingan
blog, misalnya tidak bisa menginstall plugin, tidak bisa mengeksekusi skrip dari postingan, tidak bisa memakai CSS,
dan tidak memperbolehkan data: URI. Utilitas nb2wp menghasilkan HTML yang mengatasi keterbatasan-
keterbatasan ini.
Kalau Anda membaca ini di IndoML, maka tulisan ini dibuat dengan nb2wp.

Tampilkan Hasil Export HTML di Web

Unggah file HTML dari hasil export notebook ke web atau blog Anda. Kalau Anda membutuhkan kustomisasi, Anda
bisa edit file HTML-nya, atau rubah template nbconvert (agak panjang ceritanya).
Cara ini lumayan, tapi membutuhkan layanan web atau blog yang memungkinkan Anda mengunggah file HTML
secara utuh. WordPress.com, misalnya, tidak memperbolehkan ini.

Tampilkan Cuplikan di Web/Blog

Cara lain yang mudah adalah meng-embded Gist di laman postingan blog. Caranya:
1. Buka file notebook (yang berekstensi .ipynb) di teks editor

2. Select All –> Copy

3. Buat Gist baru di https://gist.github.com/

4. Paste isi notebook tadi di gist baru ini

5. Beri nama file gist dengan ekstensi .ipynb agar gist ini ditampilkan sebagai Jupyter notebook

6. Embed-kan URL gist ini di web atau blog Anda. WordPress mempunyai fasilitas ini, dan semestinya
penyedia layanan blog lainnya juga (saya belum mencoba yang lain sih).
Dengan cara ini, notebook akan tampil dalam sebuah iframe kecil yang bisa di-scroll.

Cara ini mungkin cocok kalau Anda berniat untuk membuat narasi tersendiri di blog Anda, dan hanya ingin
mereferensi notebook Anda.

Kelebihan cara ini adalah mudah, sedangkan kekurangannya menurut saya:

• Anda harus membuat narasi lagi di postingan blog

• notebook hanya tampil dalam iframe kecil yang lebih sulit dilihat

• mengkopi-paste notebook ke gist sangat tidak praktis

Belajar dari Contoh Hebat

Berikut adalah contoh-contoh notebook bisa Anda pelajari:

• Python for Exploratory Computing – buku pengenalan Python yang dibuat secara interaktif dengan Jupyter
notebook
• Data analysis in R and Python – tutorial Python, Numpy, Pandas, Matplotlib, dsb.
• Tutorial Matplotlib – indah untuk dilihat
• Contoh-contoh dari Jupyter sendiri – agak-agak kurang bagus untuk diikuti karena kurang terstruktur
• Kumpulan notebook-notebook menarik – ini adalah direktori besar yang berisi tautan ke notebook-
notebook menarik dan juga ke direktori notebook lain.