Regression

Regression
Regresi merupakan salah satu teknik untuk meramalkan data di masa yang akan datang.
Lebih mudahnya mari kita lihat kasus di mana perusahaan mendata pegawainya berdasarkan
berapa lama mereka bekerja dan berapa besar gaji mereka saat ini (dalam euro per tahun).
Ilustrasinya tampak pada tabel di bawah ini: Regresi merupakan salah satu teknik untuk
meramalkan data di masa yang akan datang. Lebih mudahnya mari kita lihat kasus di mana
perusahaan mendata pegawainya berdasarkan berapa lama mereka bekerja dan berapa besar
gaji mereka saat ini (dalam euro per tahun). Ilustrasinya tampak pada tabel di bawah ini:
Tabel di atas terdiri dari 2 kolom, yaitu ‘Tahun_bekerja’ dan ‘Gaji’, di mana data diurutkan dari
tahun bekerja kecil ke besar. Dapat dilihat bahwa semakin lama seseorang bekerja
kecenderungannya semakin tinggi pula gajinya. Namun terkadang tahun bekerja yang lama tidak
selalu bergaji lebih besar dari pegawai yang bekerja lebih singkat. Misal kita amati ada pekerja
yang bekerja selama 3.9 tahun bergaji 63K euro, sementara di atasnya pekerja bekerja selama 4.5
tahun bergaji 61K euro.
Pertanyaan yang muncul, apakah memang hubungan antara lama bekerja dengan besarnya gaji
adalah linear? Jika linear, seberapa kuat kelinearitasannya?
Regresi melalui salah satu tekniknya yaitu simple linear regression (SLR) menjawab pertanyaan
di atas. SLR mencari hubungan antara 1 variabel independen (lama bekerja) dengan 1 variabel
dependen. Jika variabel independennya lebih dari satu, maka namanya menjadi multiple linear
regression.
Formula dari SLR diberikan sebagai berikut:
Y adalah variabel dependen, dan X adalah variabel independen. B0 adalah intercept (konstanta),
dan B1 adalah slope (koefisien pengali), sementara epsilon adalah error dari sebuah model
regresi.
Hasil dari model regresi yang kita buat, kurang lebih akan tampak seperti berikut:
Garis merah merupakan model regresi yang terbentuk. Di mana ia menunjukkan tren positif yang
berarti naik ke atas ditunjukkan dengan slope (nilai B1 positif). Jika sebaliknya (tren negatif)
maka ia cenderung menurun ke bawah (B1 negatif).Lalu bagaimana sebuah model regresi
terbentuk? Metode yang sering digunakan adalah Ordinary Least Square, di mana sebuah model
akan membuat sebanyak mungkin garis linear kemudian menghitung selisih kuadrat antara data
sesungguhnya terhadap data prediksi model. Ilustrasinya sebagai berikut:
Garis merah merupakan model regresi yang terbentuk. Sementara data real yang kita miliki
adalah x, dan kita memiliki x sebanyak 9 buah. Data sesungguhnya ini kita notasikan sebagai Yi,
dan data prediksi adalah Yi topi. Selisih keduanya ditandai dengan garis putus-putus warna hijau.
Oleh karena itu metode ordinary least square didefinisikan sebagai berikut:
Model regresi akan membuat garis linear sebanyak mungkin, kemudian dari semua garis tersebut
dihitunglah nilai sum squares nya (formula di atas). Model yang memiliki nilai sum
squares terkecil merupakan model regresi terbaik yang dipilih.
Jika sudah memahami, mari kita belajar bagaimana mengimplementasikan regresi ke dalam
sebuah model machine learning.
 Simple linear regression

 Multiple linear regression
 Polynomial regression
 Support vector regression
 Decision tree regression
 Random forest regression
Machine Learning: Simple Linear
Regression
Kali ini, kita ingin membuat sebuah model regresi, yaitu fungsi antara lamanya bekerja
terhadap besarnya gaji yang didapat. Nantinya output model kita ini (prediksi gaji) akan kita
bandingkan dengan gaji yang sebenarnya, sehingga dapat dilihat apakah model kita sudah cukup
baik (prediksi sangat mendekati kenyataan) atau sebaliknya.
Bahasa Python
# Impor library yang dibutuhkan

1 import numpy as np
2 import matplotlib.pyplot as plt
3 import pandas as pd
4
# Impor dataset
5 dataset = pd.read_csv('Daftar_gaji.csv')
6 X = dataset.iloc[:, :-1].values
7 y = dataset.iloc[:, 1].values
8
9 # Membagi data menjadi Training Set dan Test Set
10 from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 1/3, random_state = 0)
11
12 # Fitting Simple Linear Regression terhadap Training set
13 from sklearn.linear_model import LinearRegression
14 regressor = LinearRegression()
15 regressor.fit(X_train, y_train)
16
# Memprediksi hasil Test Set
17 y_pred = regressor.predict(X_test)
18
19 # Visualisasi hasil Training Set
20 plt.scatter(X_train, y_train, color = 'red')
21 plt.plot(X_train, regressor.predict(X_train), color = 'blue')
22 plt.title('Gaji vs Pengalaman (Training set)')
plt.xlabel('Tahun bekerja')
23 plt.ylabel('Gaji')
24 plt.show()
25
26 # Visualisasi hasil Test Set
27 plt.scatter(X_test, y_test, color = 'red')
plt.plot(X_train, regressor.predict(X_train), color = 'blue')
28
plt.title('Gaji vs Pengalaman (Test set)')
29 plt.xlabel('Tahun bekerja')
31 plt.show()
32
33 from sklearn.metrics import accuracy_score
print('Accuracy score: ', accuracy_score(y_test, y_pred.around())
Penjelasan:
 Line 2 sampai 4 adalah mengimpor library yang diperlukan.

 Line 7 mengimpor data ke python.
 Line 8 menentukan variabel independen (sumbu x) yaitu kolom ke 1 (Tahun_bekerja).
Perlu diperhatikan, ketika melakukan slicing kita menggunakan method .values, hal ini
hanya akan memotong data tanpa headernya. Jika tanpa .values maka header dari slicing
akan diikutkan.
 Line 9 menentukan variabel dependen (xumbu y) yaitu kolom ke 2 (Gaji).
 Line 12 mengimpor library untuk memisahkan menjadi test dan train set.
 Line 13 membagi menjadi test dan train set, di mana train set adalah 2/3 dari dataset
yang ada. Anda bisa klik bagian Variable explorer di spyder untuk melihat hasil pembagian
train dan test set nya.
 Line 16 mengimpor class LinearRegression dari library sklearn.linear_model yang
diperlukan untuk membuat model regresi.
 Line 17 membuat objek regressor sebagai fungsi dari LinearRegression. Cukup menulis
LinearRegression() maka model regresi sudah disiapkan. Jika Anda arahkan kursor pada
LinearRegression dan klik CTRL+i maka akan menampilkan object inspector untuk
LinearRegression. Di sini Anda bisa melihat parameter apa saja yang diperlukan.
 Line 18 membuat model regresi untuk train set dengan menuliskan regressor.fit(X_train,
y_train). Untuk melihat parameter apa saja yang diperlukan untuk metode fit(), cukup
arahkan kursor pada .fit() kemudian klik CTRL+i.
Line ke 18 adalah proses di mana kita membuat model machine learning regresi. Artinya, model
kita sedang belajar untuk mencari hubungan antara X_train dan y_train.
Output di python akan tampak sebagai berikut Out[12]: LinearRegression(copy_X=True,
fit_intercept=True, n_jobs=1, normalize=False).
Setelah machine learning kita belajar mencari tahu hubungan antara X_train dan y_train, maka
langkah selanjutnya adalah kita mencoba membuat prediksi ke depan, di mana prediksi ini
menggunakan hubungan yang sudah dipelajari oleh model kita. Perintah untuk melakukan
prediksi ini dilakukan di line 21.
 Line 21 membuat prediksi dengan menggunakan metode .predict. Untuk menegtahui

parameter apa saja, kita bisa melihatnya melalui object inspector. Parameter yang
diperlukan adalah variabel independen, dalam hal ini adalah X_test dan bukan X_train.
Mengapa demikian? Karena kita ingin memprediksi data baru. Jika menggunakan X_train
maka kita membuat prediksi berdasarkan pemahaman X_train, padahal pemahaman itu
sendiri dibuat berdasarkan X_train. Oleh karena itu, kita menggunakan X_test. Nantinya
prediksi ini kita bandingkan dengan y_test. Jika hasilnya mendekati (jaraknya tidak
terlalu jauh), maka model kita sudah baik.
Jika sudah, mari kita bandingkan hasil y_pred dengan y_test, di mana y_pred adalah prediksi
model kita dan y_test adalah data yang sesungguhnya.
Hasil y_pred dan y_test
Untuk bisa membandingkan hasil antara y_pred dan y_test, akan sangat baik jika dibuat ilustrasi
visualnya. Perlu diperhatikan, agar menampilkan visual yang baik di python, maka block semua
line dari line 24 sampai line 29 kemudian klik CTRL+ENTER.
 Line 24 membuat scatter plot X_train dan y_train dengan warna merah untuk
data poinnya. Tentu saja warnanya bisa dirubah sesuka hati.
 Line 25 membuat line plot nya (garis regresi) dengan warna biru. metode plot()
membutuhkan parameter pertama yaitu data poin untuk sumbu x, dan parameter kedua
adalah data poin untuk sumbu y. Data poin sumbu x adalah X_train karena kita ingin
melihat model regresi dari training set, sementara data poin sumbu y adalah prediksi dari
X_train dengan perintah regressor.predict(X_train). Perlu diingat, data poin sumbu y
bukan y_predict atau regressor.predict(X_test), karena tujuan kita kali ini membuat plot
regresi untuk X_train, bukan X_test. Semisal Anda salah, menggunakan
regressor.predict(X_test), maka garis regresinya tidak akan muncul. Mengapa? Karena
jumlah data poin X_train (20 baris) dan X_test (10 baris) sudah berbeda, maka tidak
mungkin bisa dibuat garis regresinya.
 Line 26 membuat judul yang akan ditampilkan di bagian paling atas grafik.
 Line 27 membuat label untuk sumbu x.
 Line 28 membuat label untuk sumbu y.
 Line 29 mengeksekusi dan menampilkan hasil dari semua perintah dari line 24 sampai
line 28.
Jika sudah, maka hasilnya akan nampak sebagai berikut:

Ilustrasi simple regression
Jika spyder menampilkan gambarnya di bagian console, maka Anda bisa merubahnya untuk
tampil di window (jendela) lain. Caranya masuk ke Tools > preferences > IPython console >
Graphics > Graphics backend > Backend: Automatic.
Titik merah adalah nilai gaji sesungguhnya, sementara garis biru adalah prediksi gaji dari model
regresi kita.
 Line 32 sampai line 37 adalah perintah menampilkan grafik untuk test set. Perhatikan
bahwa di line 33 plot line nya masih menggunakan X_train dan bukan X_test, karena
model regresi kita berbasis pada training set. Walau demikian, sangat kebetulan sekali
seandainya Anda salah menggunakan perintah ini misalnya: plt.plot(X_test,
regressor.predict(X_test), color = ‘blue’), maka hasilnya akan sama. Namun, saya ulang
kembali Anda tetap perlu mengingat bahwa model regresinya adalah menggunakan
X_train dan bukan X_test.
Jika sudah, maka hasil dari test set akan seperti berikut:
Bahasa R
# Mengimpor dataset
dataset = read.csv('Daftar_gaji.csv')
# Membagi dataset menjadi Training set and Test set

# install.packages('caTools') &amp;amp;amp;amp;lt;--
jika belum mempunyai library nya hapus tanda #
library(caTools)
set.seed(123)
split = sample.split(dataset$Gaji, SplitRatio = 2/3)
training_set = subset(dataset, split == TRUE)
test_set = subset(dataset, split == FALSE)
# Feature Scaling
# training_set = scale(training_set)
# test_set = scale(test_set)
# Fitting Simple Linear Regression ke the Training set

regressor = lm(Gaji ~ Tahun_bekerja, data = training_set)
# Memprediksi hasil test set

y_pred = predict(regressor, newdata = test_set)
# Visualising the Training set results

library(ggplot2)
ggplot() +
geom_point(aes(x = training_set$Tahun_bekerja, y = training_set$Gaji), colour = 'red') +
geom_line(aes(x = training_set$Tahun_bekerja, y =
predict(regressor, newdata = training_set)), colour = 'blue') +
ggtitle('Gaji vs Tahun bekerja (Training set)') +
xlab('Tahun bekerja') +
ylab('Gaji')
# Visualising the Test set results

library(ggplot2)
ggplot() +
geom_point(aes(x = test_set$Tahun_bekerja, y = test_set$Gaji), colour = 'red') +
geom_line(aes(x = training_set$Tahun_bekerja, y =
predict(regressor, newdata = training_set)), colour = 'blue') +
ggtitle('Gaji vs Tahun bekerja (Test set)') +
xlab('Tahun bekerja') +
ylab('Gaji')
# Analisis statistik model regresi

summary(regressor)
Penjelasan:
 Line 2 mengimpor datasetnya.

 Line 6 mengimpor library caTools untuk membagi data ke train dan test set.
 Line 7 menentukan bilangan randomnya (Dalam contoh kali ini adalah 123. Tentu saja
angkanya bebas).
 Line 8 mendefinisikan variabel split untuk pembagian train dan test set. Untuk bisa
melihat parameter apa saja yang diperlukan cukup arahkan kursor ke sample.split,
kemudian klik F1. Maka akan muncul dokumentasinya. Parameter pertama adalah
variabel dependennya (Gaji), kemudian secara default rasio splitnya adalah 2/3.
 Line 9 menentukan bagian training set, dari hasil boolean TRUE dari variabel split.
 Line 10 menentukan bagian test set, dari hasil boolean FALSE dari variabel split.
 Line 12 sampai line 14 adalah perintah feature scaling jika diperlukan. Kali ini kita tidak
memerlukannya.
 Line 17 adalah mendefinisikan objek regressor sebagai sebuah model regresi. Di R,
perintah membuat model regresi adalah dengan menggunakan fungsi lm(). Parameter
pertama adalah variabel dependen (Gaji) diikuti dengan simbol ~ (disebut dengan tilde).
Kemudian setelah simbol ~ diikuti dengan variabel independen yaitu Tahun_bekerja, dan
kita definisikan datanya diambil dari training_set.
 Line 20 adalah prediksi pembelajaran machine learning untuk test set. Line 20 ini sama
dengan line 21 y_pred dalam perintah bahasa python di atas.
 Line 23 mengimpor library ggplot2 untuk membuat visualisasi model regresi kita. ggplot2
adalah library yang terkenal di R, karena bisa menampilkan visualisasi yang beragam
dan powerful. Perlu diperhatikan, penulisan ggplot sebenarnya satu baris, namun Anda
bisa melanjutkan penullisan di bawahnya jika layar komputer Anda tidak bisa
menampilkan semua perintah dalam satu baris. Jika Anda klik ENTER, maka otomatis
akan beralih ke baris di bawahnya, dan R otomatis juga akan memberikan indentasi
(menjorok sedikit ke kanan).
 Line 24 perintah awal ggplot, diikuti dengan parameter selanjutnya dengan simbol +.
Perintah ggplot() adalah mempersiapkan objek visualisasi, yang jika diikuti simbol +
maka semua komponen visualisasi setelah simbol + akan dieksekusi bersamaan.
 Line 25 membuat scatter plot dengan perintah geom_point diikuti dengan aes (singkatan
dari aesthetic) untuk menentukan mana sumbu x dan mana sumbu y. dan warna apa yang
Anda inginkan.
 Line 26 membuat plot line dengan perintah geom_line. Parameternya sama dengan
geom_point.
 Line 27 memberikan judul untuk grafiknya
 Line 28 memberikan label untuk sumbu x
 Line 29 memberikan label untuk sumbu y
Jika dieksekusi, maka akan menampilkan grafik sebagai berikut:

Hasil regresi
 Line 32 sampai line 38 menampilkan grafik untuk test set.
Jika dieksekusi, maka akan menampilkan grafik sebagai berikut:
Hasil regresi
Sampai di sini Anda bisa melihat bagaimana model kita (bahasa python dan R) cukup baik
memprediksi gaji dengan menggunakan pembelajaran dari dataset X_train.
Untuk bisa memastikan seberapa akurat, maka perlu dilakukan uji statistik. Dalam hal ini R
memang didesain sebagai software statistik, maka pengujianya cukup menulis perintah summary
pada line 41.
 Line 41 perintah melihat seberapa baik (fit) model regresi yang kita buat. Cukup menulis
summary(diikuti model regresinya)
Jika dieksekusi maka hasilnya adalah sebagai berikut:

Hasil model regresi
Residuals adalah seberapa banyak data poin yang tidak bisa dijelaskan dengan model kita.
Gambaran umumnya adalah semakin kecil residual, maka semakin kuat model regresi kita
menjelaskan hubungan antara variabel dependen dengan independen. Min menyatakan nilai
minimum, 1Q menyatakan nilai residual kuartal pertama (persentil 25), median adalah nilai
tengah, 3Q adalah persentil 75, dan Max adalah nilai terbesar.
Penjelasan bagian Coefficients:
 Intercept merupakan koefisien yang dimiliki model regresi Anda. Artinya untuk setiap
nilai X nol (karyawan tanpa pengalaman bekerja di perusahaan ini), ia akan mendapatkan
gaji sebesar 25592 euro per tahun. Angka ini Anda bisa lihat di bagian Estimate dari
Intercept.
 Kemudian pada bagian Tahun_bekerja nilai 9365 menyatakan bahwa untuk setiap
penambahan tahun bekerja sebanyak 1 tahun, gajinya akan bertambah sebesar 9365 euro
per tahun.
 Jika Anda tulis persamaan regresinya maka dapat ditulis sebagai berikut:
 Std.Error (standar error) adalah seberapa menyimpang data prediksi dari data
sesungguhnya. Semakin kecil std. error tentu semakin baik model kita.
 t value adalah uji statistik dari distribusi t. Nilai t di atas 2 atau kurang dari -2 secara
umum sudah dianggap signifikan.
 Pr adalah p value. Variabel independen kita (Tahun_bekerja) memiliki nilai p di bawah
0.05, artinya ia signifikan memprediksi variabel dependen (Gaji).
 Untuk melihat seberapa baik, maka lihat bagian Multiple R-squared yang merupakan nilai
, yang nilainya berkisar dari 0 sampai 1. Nilai nol (0), artinya error (jarak antara nilai
prediksi dengan nilai yang sebenarnya) terlalu besar, sehingga modelnya sangat buruk.
Sebaliknya jika nilainya 1 adalah model yang sempurna, artinya prediksinya benar-benar
tanpa error.
Pastilah tidak mungkin model regresi memiliki nilai 1, karena jika demikian maka model kita
terlalu sempurna (ada yang salah, atau tidak beres). Model kita memiliki nilai 0.96 tentunya
modelnya sangatlah baik (karena ini hanya data contoh untuk mempermudah).
Jika Anda melakukan pendekatan regresi, kemudian nilai sangat buruk, misal kurang dari 0.5
atau mendekati nol, maka bisa dipastikan hubungan variabel dependen dan independen tidaklah
linear. Jika demikian, Anda bisa melakukan fitting (melihat hubungan variabel dependen dengan
independen) dengan model regresi non linear, klasifikasi, dan lain sebagainya.
Sampai di sini saya berharap Anda bisa membuat model ML (Machine learning) Anda sendiri.
Multiple Linear Regression
Sebelumnya kita sudah bersama-sama belajar tentang simple linear regression (SLR), kali
ini kita belajar yang sedikit lebih advanced yaitu multiple linearregression (MLR). Apa
perbedaannya? Pada pembahasan SLR, kita memiliki satu variabel dependen (gaji yang diterima
per tahun), dan satu variabel independen (lamanya bekerja). Jika kita ingin mengetahui pengaruh
variabel dependen (output) terhadap lebih dari satu variabel independen (data input, atau
disebut juga dengan prediktor), maka kita harus menggunakan MLR.
Persamaan SLR:
di mana y adalah variabel dependen, a0 adalah konstanta, a1 adalah koefisien untuk x1,
dan x1 adalah variabel independen.
Persamaan MLR:
di mana MLR memiliki fungsi yang mirip dengan SLR namun memiliki variabel independen
sebanyak n
Misal, dalam pembelajaran kali ini ada dataset keuntungan yang dimiliki oleh 50 perusahaan baru
yang berada di US. Kita ingin melihat apakah ada hubungan keuntungan yang didapat (profit)
terhadap pengeluaran-pengeluaran dan wilayah domisili perusahaan-perusahaan ini. Ada 4
variabel independen yang kita miliki yaitu data pengeluaran R & D (riset dan development), data
pengeluaran marketing, data pengeluaran administrasi (seperti gaji, tagihan, dan lain-lain), dan
wilayah di mana 50 perusahaan ini berada. Karena ada lebih dari 1 variabel independen, maka
kita harus menggunakan multiple linear regression. Kita juga penasaran, dari 4 variabel
independen ini mana yang memiliki kontribusi terbesar terhadap profit. Jika kita sudah
mengetahui variabel independen mana yang memiliki kontribusi terbesar terhadap profit, maka
kita juga bisa mengambil keputusan untuk memprioritaskan investasi dan fokus kita di variabel-
variabel independen ini. Tentunya masih banyak lagi keputusan-keputusan yang bisa diambil
dari model regresi kita kali ini.
Perlu diperhatikan, bahwa saat kita menggunakan MLR, kita dari awal sudah mengasumsikan
bahwa hubungan keempat variabel independen terhadap variabel dependen adalah linear. Tentu
saja, kenyataannya hubungan yang kita temukan setelah mengevaluasi model kita nanti bisa saja
tidak linear. Dan jika hal ini terjadi, maka model MLR tidak cocok untuk mencari hubungan
ketiganya. Tenang saja, untuk contoh kali ini, datanya sudah disesuaikan, sehingga ada hubungan
linear antara variabel dependen dan independen.
Hal lain yang perlu diperhatikan adalah dalam membuat model linear regresi (simple atau multi),
maka variabel dependen harus memenuhi beberapa asumsi lainnya. Di mana jika asumsi ini tidak
terpenuhi maka model kita dinyatakan tidak cukup baik. Asumsi-asumsi tersebut antara lain:
 Linearity
 Homoscedasticity
 Multivariate normality
 Independence of errors
 Lack of multicollinearity
Walau demikian, kita tidak akan membahas asumsi-asumsi di atas (akan di bahas di topik
lainnya). Untuk mempermudah, kita asumsikan bahwa semua asumsi tersebut terpenuhi.
Baik, mari kita mulai membangun model machine learning MLR kita. Langkah pertama, Anda
harus mendownload datasetnya di link ini.
Mari kita mulai dengan mendata variabel apa saja yang kita miliki.
 Variabel dependen = Profit (data numerik)

 Variabel independen 1 = Biaya R&D (data numerik)
 Variabel independen 2 = Biaya administrasi (data numerik)
 Variabel independen 3 = Biaya marketing (data numerik)
 Variabel independen 4 = Wilayah perusahaan (data kategori)
Semua satuan untuk variabel independen 1 sampai 4 dan variabel dependen adalah dalam dollar
($) per tahun.
Pada jenis data variabel yang dimiliki, kita melihat bahwa variabel independen 4 tidak memiliki
jenis data numerik. Padahal model regresi (simple atau multi) adalah model di mana semua
datanya haruslah numerik. Lalu apa yang harus dilakukan?
Untuk mensiasati ini, maka kita perlu membuat dummy variable. Dummy variable adalah
konversi data kategori ke bentuk numerik yang terdiri dari dua nilai yaitu 0 dan 1. Ilustrasi dari
dummy variabel ini bisa dilihat pada tabel di bawah ini:
Bisa Anda lihat, bahwa kita merubah data kategori menjadi boolean (True or False). Nilainya
bernilai True (1) jika datanya sama. Misal, baris pertama New York bernilai satu untuk kolom
New York, namun FALSE (0) untuk California dan Florida. Begitu seterusnya sampai baris-baris
lainnya. Namun perlu diingat, jika kita memiliki 3 kategori seperti contoh di atas, maka total
dummy variabel yang dibutuhkan adalah n-1 , dalam hal ini 3-1 = 2 dummy variabel. Hal ini
dilakukan untuk menghindari jebakan dummy variabel (dummy variable trap).
Kira-kira funsgi multiple regresinya akan tampak sebagai berikut:
Tips: Saat membuang salah satu dummy variabel, tidak ada aturan apakah harus dummy variabel
pertama, kedua atau ketiga, sehingga pilihan bebas terserah Anda. Walau demikian, pada contoh
formula di atas, kita membuang dummy variabel ketiga (Wilayah3).
Mari sekarang kita buat modelnya step-by-step dilengkapi penjelasannya.
Bahasa Python
# Mengimpor library yang diperlukan

4
5 # Mengimpor dataset
6 dataset = pd.read_csv('50_Startups.csv')
X = dataset.iloc[:, :-1].values
7 Tampilkan_X = pd.DataFrame(X) #visualisasi X
9
10 # Encode categorical data
11 from sklearn.preprocessing import LabelEncoder, OneHotEncoder
12 labelencoder_X = LabelEncoder()
X[:, 3] = labelencoder_X.fit_transform(X[:, 3])
13 onehotencoder = OneHotEncoder(categorical_features = [3])
14 X = onehotencoder.fit_transform(X).toarray()
15
16 # Menghindari jebakan dummy variabel
17 X = X[:, 1:]
18
19 # Membagi data menjadi the Training set and Test set
from sklearn.model_selection import train_test_split
20 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
21
22 # Membuat model Multiple Linear Regression dari Training set
24 regressor = LinearRegression()
25 regressor.fit(X_train, y_train)
26
# Memprediksi hasil Test set
27 y_pred = regressor.predict(X_test)
28
29 # Memilih model multiple regresi yang paling baik dG metode backwardpropagation
30 import statsmodels.api as sma
31 X = sma.add_constant(X)
32 import statsmodels.api as sm
X_opt = X[:, [0, 1, 2, 3, 4, 5]]
33 regressor_OLS = sm.OLS(endog = y, exog = X_opt).fit()
34 regressor_OLS.summary()
35 X_opt = X[:, [0, 1, 3, 4, 5]]
regressor_OLS = sm.OLS(endog = y, exog = X_opt).fit()
37 X_opt = X[:, [0, 3, 4, 5]]
40 X_opt = X[:, [0, 3, 5]]
regressor_OLS = sm.OLS(endog = y, exog = X_opt).fit()
42 X_opt = X[:, [0, 3]]
Penjelasan:
 Line 2 sampai line 4 mengimpor library yang diperlukan.

 Line 8 mendefinisikan variabel independennya (biaya R&D, marketing, administrasi dan
wilayah). Di sini kita belum mendefinisikan dummy variabel.
 Line 9 menampilkan X sebagai data frame. Jika Anda menggunakan spyder versi lama,
maka ketika Anda double klik X di variable inspector, Anda bisa melihat isi datanya.
Namun di spyder yang baru hal ini tidak dimungkinkan, karena kolom wilayah bukanlah
tipe data numerik. Jika Anda ingin sekilas melihat data X, cukup ketik X di console lalu
tekan ENTER. Namun Anda juga bisa mengeksekusi line 9 untuk melihat isinya sebagai
sebuah data frame.
 Line 10 mendefinisikan variabel dependennya.
 Line 13 mengimpor class LabelEncoder dan OneHotEncoder untuk
membuat dummy variabel.
 Line 14 mempersiapkan objek labelencoder untuk proses dummy variabel berikutnya.
Jika Anda lupa apa saja yang harus dituliskan, cukup copy paste dari data format di
pembahasan preprocessing di link ini.
 Line 15 menentukan kolom ke berapa yang ingin dibuat dummy variabelnya. Karena
indeks python dimulai dari nol, maka kolom terakhir adalah kolom ketiga. Line 15 hanya
mengonversi kategori menjadi 0, 1 atau 2.
 Label 16 melakukan transformasi OneHotEncoder hasil dari line 15 menjadi dummy
variabel yang kita inginkan (nilai 0 atau 1). Perlu diingat karena punya 3 jenis kategori,
maka kita tuliskan categorical_features = [3].
 Line 17 mengeksekusi proses transformasi kolom wilayah objek X menjadi dummy
variabel. Anda sekarang bisa klik 2x pada variable inspector variabel X. Di situ bisa dilihat
3 kolom pertama sudah menjadi dummy variable. Namun perlu diingat kita hanya
memerlukan dummy variable. Oleh karena itu line kita hilangkan salah satu kolom
di line 18.
 Line 18 menghilangkan salah satu kolom dummy variabel agar tidak terjebak dummy
variable trap.
Hasil transformasi dataset menjadi 2 dummy variabel akan tampak sebagai berikut:
 Line 23 mengimpor class dan sublibrary yang diperlukan untuk membagi dataset ke train
set dan test set.
 Line 24 membagi data 20% ke test set dan 80% ke train set.
 Line 27 mengimpor class LinearRegression untuk membuat model regresi.
 Line 28 mempersiapkan objek regressor sebagai model regresi kita nantinya.
 Line 29 membuat model regresi dari dataset X_train dan y_train.
 Line 32 memprediksi hasil test set, di mana kita ingin membandingkan nilai y_pred
dengan y_test nantinya.
Perbandingan antara y_pred dengan y_test akan tampak sebagai berikut:
Bisa dilihat bahwa model kita cukup baik memprediksi nilai profit 50 perusahaan ini. Terlihat
dari selisih yang tidak terlalu besar untuk setiap barisnya antara y_pred dan y_test. Walau
demikian, tentunya tidak cukup jika menilai baik tidaknya hanya membandingkan secara visual
saja. Kita memerlukan cara kuantitatif dengan menggunakan statistik.
Oleh karena itu, untuk menguji apakah model ini sudah baik, dan variabel independen mana saja
yang signifikan atau tidak, kita melakukan metoda backpropagation atau backward propagation.
Metode ini memulai dengan memasukkan semua variabel independen, kemudian melucuti satu
per satu variabel independen yang tidak signifikan sampai ditemukan model yang terbaik
(converged). Bagaimana memilih variabel independen yang dilucuti? Adalah variabel independen
yang p value nya di atas 0.05. Kemudian kita uji lagi, jika ada variabel independen yang p value nya
di atas 0.05 kita buang lagi. Begitu seterusnya sampai converged.
 Line 35 mengimpor library stastmodels.api sebagai sma

 Line 36 memerlukan penjelasan yang sedikit panjang. Berikut penjelasannya:
Seperti kita ketahui, fungsi umum dari multi regresi adalah:
Di situ kita memiliki konstanta di mana ia juga sebenarnya dikalikan dengan variabel dengan
nilai 1. Library statsmodels tidak mempertimbangkan hal ini. Sementara library
LinearRegression di line 27 sudah mempertimbangan variabel . Oleh karena itu line 36 adalah
memberikan tambahan kolom baru di objek X dengan nilai 1.
Jika dilihat objek X yang baru akan tampak sebagai berikut:
Kita lihat di kolom paling kiri merupakan nilai yang semua barisnya adalah 1.
 Line 37 mengimpor library statsmodels.formula.api sebagai sm.

 Line 38 membuat objek X_opt sebagai daftar semua variabel independen yang ingin
dianalisis. Di sini kita memilih semua baris, dan semua kolom. Tentunya kita bisa
menuliskannya dengan X[ : , : ]. Tapi kita menuliskannya dengan X[ : , [0,1,2,3,4,5]] untuk
nantinya mempermudah kita membuang satu per satu variabel independen yang tidak
signifikan.
 Line 39 membuat objek X_OLS sebagai objek untuk melihat performa model kita dengan
menggunakan metode OLS (Ordinary least squares) dari library sm kita tadi. Anda tentu
bisa selalu menginspeksi parameter apa saja yang diperlukan dengan menekan CTRL+i di
OLS(). Jika tidak muncul setelah klik CTRL+i, maka coba ketik sm.OLS? di console.
Parameter yang diperlukan adalah endog sebagai variabel dependen, dan exog sebagai
variabel independennya (dengan sudah menambahkan ). Oleh karena itu endog = y,
dan exog = X_opt. Jangan lupa menambahkan metode .fit() di belakangnya.
Tips: Dalam penulisan metode di python ada dua cara, langsung dan tidak langsung. Berikut
penullisan yang berbeda namun hasilnya sama, tergantung bagaimana gaya dan kenyamanan
Anda.
1
# STYLE 1
4
5 # STYLE 2
6 regressor_OLS = sm.OLS(endog = y, exog = X_opt)
hasil = regressor_OLS.fit()
7
hasil.summary()
8
 Jika Anda eksekusi line 40, hasilnya akan tampak sebagai berikut:
Tampilan summary multiple regression

Lihatlah pada bagian p value nya (P>|t|). Di mana semakin kecil nilai p maka semakin baik variabel
tersebut. Semakin tinggi semakin buruk. Cara mudahnya adalah nilai p di atas 0.05 maka ia tidak
signifikan sebagai sebuah variabel independen untuk memprediksi profit perusahaan.
Kita juga bisa melihat bahwa ada 5 variabel independen, dengan penjelasan sebagai berikut:
 const adalah nilai koefisien untuk

 x1 dan x2 adalah dummy variabel untuk variabel independen Wilayah (p value x1 = 0.95,
dan x2 = 0.99)
 x3 adalah variabel independen R&D (p value x3 < 0.05)
 x4 adalah variabel independen administrasi (p value x4 = 0.6)
 x5 adalah variabel independen marketing (p value x5 = 0.12)
Setelah dilihat maka variabel independen dengan p value terbesar harus dibuang. Maka kita
membuang x2.
Jika Anda eksekusi terus dari line 41 sampai line 52 maka variabel independen yang tersisa
adalah variabel R&D dengan tampilan sebagai berikut:
Dengan demikian kita bisa menuliskan fungsi multiple regresinya sebagai berikut:
Jika dirasa proses backpropagation ini terlalu melelahkan karena harus manual satu persatu
mengeluarkan variabel independen yang tidak signifikan, maka Anda bisa melakukannya secara
otomatis dengan beberapa lines yang sudah saya siapkan di bawah ini:
1
2
import statsmodels.api as sm
3
def backwardElimination(x, sl):
4 numVars = len(x[0])
5 for i in range(0, numVars):
6 regressor_OLS = sm.OLS(y, x).fit()
7 maxVar = max(regressor_OLS.pvalues).astype(float)
if maxVar > sl:
8
for j in range(0, numVars - i):
9 if (regressor_OLS.pvalues[j].astype(float) == maxVar):
10 x = np.delete(x, j, 1)
12 return x
SL = 0.05
13
X_opt = X[:, [0, 1, 2, 3, 4, 5]]
14 X_Modeled = backwardElimination(X_opt, SL)
15
16
Tampilan script backward elimination otomatis di Python
Bahasa R
dataset = read.csv('50_Startups.csv')
2
3
# Encode categorical data
4 dataset$Wilayah = factor(dataset$Wilayah,
5 levels = c('New York', 'California', 'Florida'),
6 labels = c(1, 2, 3))
7
8 # Membagi data ke Training set and Test set
# install.packages('caTools')
9
library(caTools)
10 set.seed(123)
11 split = sample.split(dataset$Profit, SplitRatio = 0.8)
12 training_set = subset(dataset, split == TRUE)
13 test_set = subset(dataset, split == FALSE)
14
# Membangun model Multiple Linear Regression dari Training set
15 regressor = lm(Profit ~ R.D + Administrasi + Marketing + Wilayah, data = training_set)
16 # Alternatif penulisan
17 regressor2 = lm(Profit ~ ., data = training_set)
18
19 # Memprediksi hasil Test set
20 y_pred = predict(regressor, newdata = test_set)
21
# Membandingkan y_pred dengan y_test
22 perbandingan = data.frame(y_pred,test_set$Profit)
23
24 # Membangun model terbaik menggunakan menggunakan metode Backward Elimination
25 regressor = lm(formula = Profit ~ R.D + Administrasi + Marketing + Wilayah, data = dataset)
26 summary(regressor)
27 regressor = lm(formula = Profit ~ R.D + Administrasi + Marketing + factor(Wilayah,
exclude = 2), data = dataset)
29 regressor = lm(formula = Profit ~ R.D + Administrasi + Marketing, data = dataset)
31 regressor = lm(formula = Profit ~ R.D + Administrasi + Marketing, data = dataset)
regressor = lm(formula = Profit ~ R.D, data = dataset)
Penjelasan:
 Line 2 mengimpor dataset yang diperlukan.

 Line 5 meng-encode data kategori Wilayah. Catatan: di R membuat dummy variabel tidak
serumit di Python.
 Line 11 mengimpor library untuk membagi data ke test dan training set.
 Line 12 adalah menentukan angka bilangan random (bebas).
 Line 13 membagi data menjadi dua dengan 80% untuk train set dan 20% test set dengan
mengonversi ke tipe data boolean (TRUE or FALSE)
 Line 14, jika bernilai TRUE, maka ia menjadi train set.
 Line 15, jika bernilai FALSE, maka ia menjadi test set.
 Line 18 membuat model regresi berdasarkan training set.
 Line 19 menampilkan ringkasan statistik model regresi yang kita buat. Tampilannya akan
tampak sebagai berikut:
Dapat dilhat, jika kita menggunakan R, maka R secara otomatis akan mempertimbangkan
masalah jebakan dummy variabel, sehingga kita tidak perlu khawatir. R secara otomatis
membuang 1 dari 3 kategori, maka yang ditampilkan dalam ringkasan statistiknya hanyalah
wilayah2 dan wilayah3.
Pada kolom Pr(>|t|) dapat dilihat nilai p value dari masing-masing variabel. Semakin kecil
(apalagi jika signifikan di bawah 0.05, ditandai dengan simbol asterik *), maka variabel tersebut
secara signifikan berpengaruh terhadap variabel dependen. Sebaliknya, jika semakin besar maka
semakin tidak signifikan (semakin kecil pengaruhnya terhadap variabel dependen).
Karena kita ingin memilih model regresi yang terbaik (paling bisa menjelaskan pengaruh antara
variabel dependen dan independen), maka kita buang variabel dengan nilai p value terbesar yaitu
wilayah2. Metode yang digunakan adalah backpropagation.
Pada summary(regressor) kita sebenarnya bisa menduga bahwa variabel R.D lah yang memiliki
pengaruh paling kuat terhadap Profit perusahaan.
 Line 22 adalah cara lain menuliskan fungsi regresi dalam R. Daripada menuliskan satu
demi satu variabel independen, Anda bisa cukup menuliskan titik (.) setelah tanda ~.
 Line 25 adalah memprediksi hasil y_pred melalui pembelajaran train_set. Nantinya kita
akan bandingkan y_pred dengan y_test.
 Line 28 membuat data frame gabungan antara y_pred dengan kolom profit dari test_set.
Perbandingannya tampaksebagai berikut:
Secara visual, prediksi kita terhadap y_test cukup baik. Walau demikian, kita harus menentukan
model terbaik kita secara statistik (kuantitatif).
 Line 31 sekilas sama dengan line 18, namun berbeda. Kali ini kita menggunakan dataset
awal, karena ingin mencari model terbaik. Kita sudah tidak tertarik lagi membangun
hubungan antara X_train dan y_train.
 Line 32 memberikan ringkasan statistik dari line 31. Hasilnya tampak sebagai berikut:
Karena variabel wilayah2 memiliki p value terbesar, maka wilayah2 kita buang.
 Line 33 kita membuang wilayah2 dari perbandingan model. Perhatikan bagaimana cara
mengeluarkan wilayah2, yaitu dengan perintah factor(Wilayah, exclude = 2)
 Line 35 sampai terakhir didapat bahwa variabel independen yang tersisa adalah R.D,
sehingga hasilnya nampak sebagai berikut:
Jika kita tulis fungsi regresinya maka tampak sebagai berikut:
Fungsinya sama persis antara python dan R, sehingga Anda bisa memilih mana di antara
keduanya yang paling nyaman.
Jika Anda merasa metode backward propagation terlalu melelahkan, karena harus satu demi satu
kita mengeluarkan variabel independen yang tidak signifikan, maka saya siapkan script R di
bawah ini yang secara otomatis menyaring variabel independen yang tidak signifikan tersebut.
Sehingga hidup Anda terasa lebih mudah.
1
2 backwardElimination <- function(x, sl) {
3 numVars = length(x)
4 for (i in c(1:numVars)){
5 regressor = lm(formula = Profit ~ ., data = x)
maxVar = max(coef(summary(regressor))[c(2:numVars), "Pr(>|t|)"])
6 if (maxVar > sl){
7 j = which(coef(summary(regressor))[c(2:numVars), "Pr(>|t|)"] == maxVar)
8 x = x[, -j]
9 }
10 numVars = numVars - 1
}
11 return(summary(regressor))
12 }
13
14 SL = 0.05
15 dataset = dataset[, c(1,2,3,4,5)]
16 backwardElimination(training_set, SL)
17
Tampilan script backward elimination secara otomatis di R
Perlu diingat! Kebetulan model multiple regresi kita hanya menyisakan 1 variabel independen
(yaitu R&D), ini hanyalah kebetulan saja. Bisa jadi untuk kasus lain, semua variabel independen
menjadi signifikan, atau bisa jadi hanya tersisa dua, tiga dan seterusnya.
Kesimpulan apa yang bisa diambil?
Sampai di sini kita bisa mengerti bahwa profit 50 perusahaan sangat ditentukan oleh biaya R&D
nya, sehingga semakin banyak sebuah perusahaan berinvestasi di biaya pengembangan ini, maka
semakin tinggi profitnya. Selian itu kita juga mengetahui bahwa biaya marketing, administrasi
dan jenis wilayah tidak berdampak signifikan terhadap profit perusahaan.
Apakah hasil ini valid (sesuai) bagi semua perusahaan (perusahaan lain di luar 50 perusahaan
ini)? Tentu saja tidak, karena model ini dibangun berdasarkan data 50 perusahaan yang kita
miliki. Tapi setidaknya hasil dari model regresi ini bisa menjadi senjata untuk membuat strategi
tentang bagaimana cara meningkatkan profit ke depannya.
Saya harap Anda bisa membuat model multiple regresi machine learning Anda sendiri. Anda bisa
mengaplikasikannya untuk berbagai persoalan real. Misal, apakah ada hubungan antara nilai
ujian dengan usia pelajar, jenis kelamin, lama belajar, uang bulanan dari orang tua, uang spp yang
dibayarkan, dan faktor-faktor lainnya.
Multiple regresi juga bisa diaplikasikan untuk data biologis seperti data pertumbuhan tanaman,
data DNA, data medis, data eskerimen dan masih banyak lagi. Anda bisa memasukkan banyak
variabel independen yang Anda duga berpengaruh terhadap variabel dependen Anda.
Machine Learning: Polynomial
Regression
Pada pembelajaran sebelumnya kita telah membahas tentang regresi sederhana,
dan regresi multilinear. Kali ini kita akan membahas tentang regresi polinomial. Apa itu regresi
polinomial?
Regresi polinomial merupakan regresi di mana fungsinya adalah kuadratik. Perbedaan
persamaannya bisa kita lihat sebagai berikut:
Simple linear –>
Multilinear –>
Polinomial –>
Pada ketiga fungsi di atas, tampak bahwa fungsi polinomial adalah fungsi kuadratik, di mana nilai
variabel independen ada yang bernilai pangkat 1, pangkat 2, pangkat n dan seterusnya.
Secara visual, maka perbedaanya sebagai berikut:
Visualisasi simple linear dan polinomial

Pertanyaannya, kapan kita memakai simple, multi, dan poli? Semua fungsi ini tergantung dari
pertanyaan yang ingin dijawab. Jika kita ingin mencari hubungan antara 1 variabel dependen
dengan 1 variabel independen, maka bisa menggunakan simple atau poli. Jika kita ingin mencari
hubungan antara 1 variabel dependen dengan banyak variabel independen, maka yang kita
gunakan adalah multilinear.
Lalu, jika kita hanya ingin mencari hubungan terhadap 1 variabel independen, kapan
menggunakan simple dan kapan menggunakan polinomial? Jawabannya adalah dilihat
seberapa fit model kita dengan data aslinya. Jika menggunakan simple linear sudah fit, maka
cukup menggunakan model ini saja, namun jika tidak dan fungsinya tampak seperti fungsi
polinomial (fungsi kuadratik) maka kita coba dekati dengan metode polinomial. Jika
menggunakan simple dan polinomial tidak juga fit, maka hubungan antara keduanya bukanlah
linear, sehingga harus menggunakan algoritma regresi non linear seperti SVR (support vector
regression) misalnya.
Mungkin Anda juga bertanya, apakah polinomial itu adalah termasuk family dari regresi linear?
Jawabannya adalah Ya. Polinomial dalam beberapa literatur lain disebut dengan polynomial linear
regression, jadi ia termasuk ke dalam fungsi Linear, dan bukan non Linear.
Definisi linear adalah hubungan kombinasi linear (berantai) antara variabel dependen dengan
koefisien variabel independen dan seterusnya yang konsisten. Sementara non linear adalah
fungsi di mana koefisiennya tidak bisa berdiri sendiri, misal a1 memerlukan a2, dan seterusnya.
Lebih mudahnya, perbedaan fungsi linear dan non linear adalah sebagai berikut:
Fungsi linear –>
Fungsi non linear –>
Perlu dicatat bahwa secara visualisasi 2D (2 dimensi), regresi polinomial nampak tidak seperti
fungsi linear (simple linear) karena bentuknya melengkung dan tidak lurus seperti linear
sederhana, namun ia tetaplah bagian dari fungsi linear. Jika hanya dilihat secara visual, maka
ketika di plot ke dalam 3 dimensi (3D), ia akan nampak sebagai fungsi yang linear.
Tidak sedikit pula yang mengatakan regresi polinomial sebagai fungsi non linear. Hal ini boleh-
boleh saja jika dalam konteks visualisasi 2D. Namun dalam konteks fungsi linear, kita tahu bahwa
ia sebenarnya merupakan bagian dari kelompok fungsi linear.
Semoga sampai di sini, konsep regresi polinomial dapat dipahami.
STUDI KASUS
Dalam pembelajaran kali ini, kita ingin mencari solusi dari proses perekrutan sebuah perusahaan.
Perusahaan ini sedang merekrut seorang calon pegawai baru. Namun, bagian HRD perusahaan
ini kebingungan, berapa gaji yang harus ia berikan, sesuai dengan level di mana calon pegawai
baru ini masuk. Tentunya akan ada proses negosiasi antara HRD dengan calon pegawai baru ini
tentang jumlah gaji yang pantas diterima pegawai tersebut.
Calon pegawai ini mengaku bahwa sebelumnya ia telah berada di posisi Region Manager dengan
pengalaman bekerja 20 tahun lebih dengan gaji hampir 160K dollar per tahun. Ia meminta
perusahaan baru ini untuk memberikan ia gaji lebih dari 160K dollar per tahun.
Untuk menyelidiki apakah calon pegawai ini benar-benar digaji sebanyak 160K dollar/tahun,
maka bagian HRD membandingkan data gaji perusahaan tempat calon pegawai ini bekerja
sebelumnya (kebetulan perusahaan memiliki daftar gajinya) dengan pengakuannya.
Data yang dimiliki adalah daftar antara gaji dan level di perusahaan tersebut. Bagian HRD ingin
mencari hubungan antara gaji yang didapat dengan level (tingkatan jabatan) di perusahaan calon
pekerja tadi bekerja sebelumnya.
Hasil penelitian awal, calon pegawai ini layak masuk di level 6.5 (antara region
manager dan partner).
Berikut variabel yang kita miliki:
 Variabel dependen : Gaji (dalam dollar per tahun)
 Variabel independen : level (tingkatan jabatan)
Tabel variabel dependen (gaji) dengan variabel independen (level) yang dijelaskan dengan
definisi tiap level di kolom sebelah kiri
Setelah melihat tabelnya, bisa dilihat bahwa kita memiliki 1 variabel dependen, dan 1 variabel
independen. Dari sini kita bisa tahu bahwa kita bisa menggunakan pendekatan model regresi
sederhana. Walau demikian, datanya sudah diatur sedemikian rupa sehingga fungsi yang dimiliki
antara variabel dependen dengan independen adalah kuadratik. Kita tetap akan mencoba
membuat 2 model (simple dan polinomial) untuk membandingkan performanya
(seberapa fit antara 2 model regresi ini dengan data).
Untuk memulai pembelajaran, silakan download dulu datasetnya .
Bahasa Python
1 # Mengimpor library
import numpy as np
2
import matplotlib.pyplot as plt
4
6 dataset = pd.read_csv('Posisi_gaji.csv')
7 X = dataset.iloc[:, 1:2].values
y = dataset.iloc[:, 2].values
8
9
# Fitting Linear Regression ke dataset
11 lin_reg = LinearRegression()
12 lin_reg.fit(X, y)
13
14 # Fitting Polynomial Regression ke dataset
from sklearn.preprocessing import PolynomialFeatures
15
poly_reg = PolynomialFeatures(degree = 2) ## nantinya degree diganti menjadi 4
16 X_poly = poly_reg.fit_transform(X)
17 lin_reg_2 = LinearRegression()
18 lin_reg_2.fit(X_poly, y)
19
20 # Visualisasi hasil regresi sederhana
plt.scatter(X, y, color = 'red')
21 plt.plot(X, lin_reg.predict(X), color = 'blue')
22 plt.title('Sesuai atau tidak (Linear Regression)')
23 plt.xlabel('Level posisi')
25 plt.show()
26
# Visualisasi hasil regresi polynomial
27 plt.scatter(X, y, color = 'red')
28 plt.plot(X, lin_reg_2.predict(X_poly), color = 'blue')
29 plt.title('Sesuai atau tidak (Polynomial Regression)')
30 plt.xlabel('Level posisi')
plt.show()
32
33 # Memprediksi hasil dengan regresi sederhana
34 lin_reg.predict(6.5)
35
36 # Memprediksi hasil dengan regresi polynomial
37 lin_reg_2.predict(poly_reg.fit_transform(6.5))
Penjelasan:
 Line 2 sampai line 4 mengimpor library yang diperlukan

 Line 7 mengimpor datasetnya
 Line 8 menentukan variabel independen X. Penting, bahwa usahakan variabel
independen adalah matrix, dan bukan vector. Kita bisa saja menuliskan X = dataset.iloc[:,
1].values, namun perintah ini akan menghasilkan vector. Biasakan membuatnya sebagai
sebuah matrix, dengan cara melakukan slicing X = dataset.iloc[:, 1:2].values. Bagaimana
kita tahu X sudah menjadi matrix? Bisa dilihat kolom size di spyder variabel X adalah
(10,1). Artinya X adalah matrix 10×1 (10 baris dan 1 kolom).
 Line 9 menentukan variabel dependen y. Penting, usahakan variabel dependen
adalah vector. Vektor (vector) adalah matriks yang hanya terdiri dari 1 kolom, atau
matriks 1 baris. Cara membuatnya menjadi vektor adalah jangan lakukan slicing pada
bagian kolomnya. Pada bagian size variabel y di spyder adalah (10,) yang artinya ia adalah
matrix 1 baris.
 Line 12 mengimpor class LinearRegression (untuk membuat model regresi sederhana)
 Line 13 mempersiapkan objek lin_reg sebagai model regresi sederhana
 Line 14 membuat model regresi sederhana (Kali ini tanpa membagi dataset ke dalam test
dan train set, karena datasetnya terlalu kecil (biasanya train set minimal butuh 10 baris,
dan kali ini tidak cukup data untuk dimasukkan ke test set). Walau demikian, model yang
jadi nanti akan merupakan bagian dari train set, dan dataset baru yang diterima
(pengujian train set) akan menjadi test set-nya).
Untuk membuat model polinomial, kita perlu memahami konsep teknisnya. Model regresi
polinomial yang akan kita buat sebenarnya hanyalah modifikasi dari model regresi biasa (baik
simple atau multi), di mana modifikasinya adalah dengan menambahkan fitur polinomial. Oleh
karena itu, prosedurnya sebenarnya adalah prosedur regresi biasa, namun sebelumnya membuat
model regresi ada penambahan langkah-langkah preprocessing polinomial.
 Line 17 mengimpor PolynomialFeatures dari library sklearn.preprocessing untuk
membuat model polinomial. Untuk mengetahui parameter apa saja yang diperlukan,
cukup arahkan kursor pada PolynomialFeatures, lalu klik CTRL+i.
 Line 18 mempersiapkan objek poly_reg sebagai transformasi matriks X menjadi matriks
X pangkat 2, pangkat 3 hingga pangkat n. Jadi nantinya kita memiliki beberapa tambahan
variabel independen sebanyak n. Parameter default untuk PolynomialFeatures adalah
degrees=2.
 Line 19 menyiapkan objek X_poly sebagai hasil fit_transform (proses fit dan transform
dilakukan sekaligus) dari variabel X. Mari kita bandingkan antara X dengan X_poly.
Bisa dilihat, X_poly memiliki 3 kolom. Kolom paling kiri adalah hasil transformasi X pangkat nol.
Kolom ini otomatis ditambahkan oleh class PolynomialFeatures untuk mempersiapkan konstanta
untuk (di mana = 1, di bahas di multiple regression sebelumnya).
Kolom kedua adalah nilai X dengan pangkat 1 (nilai X sesungguhnya), dan kolom paling kanan
adalah nilai X pangkat 2 (degree=2).
Jika kita menuliskan degree=4 misalnya, maka nanti X_poly akan menampilkan kolom untuk nilai
X hingga pangkat 4.
 Line 20 menyiapkan objek lin_reg_2 sebagai model regresi polinomial.

 Line 21 membuat model regresi polinomial dengan parameter variabel independen
adalah X_poly, dan variabel dependennya adalah y.
 Line 24 sampai line 29 adalah perintah untuk visualisasi hasil model regresi sederhana
kita. Ingat untuk visualisasi, perintah dari line 24-29 harus dieksekusi bersamaan.
Visualisasinya akan nampak sebagai berikut:
Bisa dilihat bahwa model regresi sederhana kita sangatlah tidak baik (tidak fit), di mana jarak
antara model (garis biru) dengan data sesungguhnya (titik merah) sangat jauh. Dengan melihat
titik merahnya saja sebenarnya sudah bisa diduga bahwa fungsi yang cocom adalah fungsi
kuadratik (polinomial), di mana semakin tinggi levelnya (sumbu x) maka semakin tinggi pula
gajinya (data sumbu y yang melengkung ke atas).
 Line 32 sampai line 37 adalah perintah untuk visualisasi hasil model regresi polinomial.
Pelru diingat sumbu y nya adalah lin_reg_2.predict(X_poly). Hasilnya akan tampak
sebagai berikut:
Bisa dilihat dengan menggunakan fungsi polinomial hasilnya cukup baik. Namun tetap saja masih
kurang cukup fit, di mana masih ada jarak antara model dengan data. Solusinya adalah pada line
18 kita ubah degree nya dari 2 menjadi 4. Eksekusi line 18 sampai line 21. Kemudian eksekusi
line 32 sampai line 37. Maka visualisasi yang baru akan tampak sebagai berikut:
Ternyata sekarang hasilnya cukup baik.
Tentunya Anda pun juga bisa bereksperimen dengan merubah-ubah degree-nya. Anda bisa
mencoba degree=3, degree=6 dan seterusnya. Namun perlu diingat jangan sampai modelnya
terlalu baik (overfitting), karena semakin besar nilai degree yang Anda tentukan, maka cenderung
semakin fit dan semakin overfitting pula hasilnya.
Mengapa kita menghindari overfitting? Bukankah modelnya bisa menjadi sangat fit? Kita
menghindari overfitting karena model seperti ini sangatlah tidak realistis. Modelnya akan
menjadi terlalu baik, artinya terlalu mengesampingkan faktor-faktor lainnya (baik itu fixed
effect ataupun random effect).
 Line 40 adalah perintah untuk melihat dengan model regresi sederhana yang sudah
dibuat, berapa gaji yang layak untuk tingkat level 6.5? Maka cukup ganti parameter X
di lin_reg.predict(X) dengan angka 6.5. Jika dieksekusi, hasilnya adalah 330378.78
dollar/tahun. Tentunya prediksi dari regresi sederhana terlalu tinggi (terlihat juga di plot
visualisasinya). Kita tidak menginginkan gaji yang terlalu tinggi yang merupakan hasil
dari model regresi sederhana yang buruk kali ini.
 Line 43 adalah perintah untuk melihat prediksi gaji dengan model regresi polinomial.
Perlu diperhatikan bahwa parameter X diganti dengan poly_reg.fit_transform(6.5) dan
bukan X_poly. Karena kita ingin mengisi angka 6.5 sebagai parameter X. Sementara
X_poky adalah hasil dari definisi fungsi poly_reg.fit_transform(X). Ketika dieksekusi maka
hasilnya adalah 158862.45 dollar/tahun. Prediksi yang cukup baik, dengan model
yang fit.
Kesimpulan apa yang bisa diambil dari model polinomial?

Ternyata apa yang dikatakan calon pegawai tersebut adalah benar, di mana di perusahaan
sebelumnya dengan level 6.5 ia mengaku digaji hampir 160K dollar/tahun, dan ternyata
prediksinya adalah 158K dollar/tahun. Selisih 2K yang tidak terlalu jauh. Bisa dikatakan bahwa
calon pegawai adalah orang yang jujur dan tidak membesar-besarkan gaji sebelumnya.
Perusahaan cukup beruntung memiliki claon pegawai yang jujur.
Bahasa R
1
2
3
dataset = read.csv('Posisi_gaji.csv')
5
dataset = dataset[2:3]
6
7 # Membuat model regresi sederhana
8 lin_reg = lm(Gaji ~ ., data = dataset)
9
10 # Membuat model regresi polinomial
11 dataset$Level2 = dataset$Level^2
dataset$Level3 = dataset$Level^3
12
dataset$Level4 = dataset$Level^4
13 poly_reg = lm(Gaji ~ ., data = dataset)
14 summary(poly_reg)
15
16 # Visualisasi hasil regresi sederhana
17 # install.packages('ggplot2')
library(ggplot2)
18
ggplot() +
19 geom_point(aes(x = dataset$Level, y = dataset$Gaji), colour = 'red') +
20 geom_line(aes(x = dataset$Level, y = predict(lin_reg, newdata = dataset)), colour = 'blue') +
21 ggtitle('Sesuai atau tidak(Linear Regression)') +
22 xlab('Level') +
ylab('Gaji')
23
24
# Visualisasi hasil regresi polinomial
26 ggplot() +
27 geom_point(aes(x = dataset$Level, y = dataset$Gaji), colour = 'red') +
28 geom_line(aes(x = dataset$Level, y = predict(poly_reg, newdata = dataset)), colour = 'blue') +
ggtitle('Sesuai atau tidak (Polynomial Regression)') +
29
xlab('Level') +
30 ylab('Gaji')
31
32 # Prediksi tingkat 6.5 dengan model regresi sederhana
33 predict(lin_reg, data.frame(Level = 6.5))
34
35 # Prediksi tingkat 6.5 dengan model regresi polinomial
predict(poly_reg, data.frame(Level = 6.5,
36
Level2 = 6.5^2,
37 Level3 = 6.5^3,
38 Level4 = 6.5^4))
39
40
41
Penjelasan:
 Line 2 mengimpor dataset.

 Line 3 melakukan slicing kolom ke 2 dan 3 saja yang diperlukan.
 Line 6 membuat model regresi sederhana
 Line 9 sampai line 11 adalah menambahkan fitur polinomial untuk model regresi kita.
Pada dasarnya ini hanyalah menambahkan kolom baru (variabel-variabel independen
baru) di dataset kita yang berisi data pangkat untuk setiap nilai X. Jika dilihat datasetnya
maka tampak sebagai berikut:
Kolom Level2 adalah hasil pangkat 2 dari semua baris di kolom level. Level3 adalah hasil pangkat
3, dan Level4 adalah hasil pangkat 4.
 Line 12 membuat model regresi polinomial. Sebagai catatan, dengan menambahkan tanda
titik (.) setelah tanda tilde (~) maka R akan mencari fungsi regresi terbaik dari semua
variabel independen yang ada (Level, Level2, Level3, Level4).
 Line 13 melihat hasil statistik sekaligus mengetahui koefisien dan konstanta apa saja yang
signifikan. Tampilannya adalah sebagai berikut:
Kita lihat bahwa semua variabel independen signifikan. Jika ditulis persamaannya, maka menjadi:
 Line 16 menginstal package ggplot2 (jika sudah terinstall abaikan saja)

 Line 17 mengimpor library ggplot2
 Line 18 sampai line 23 adalah perintah untuk visualisasi model regresi sederhana. Jika
dieksekusi bersamaan, maka tampak sebagai berikut:
 Line 27 sampai line 32 adalah perintah untuk visualisasi model regresi polinomial. Hasil
eksekusinya tampak sebagai berikut:
Tampak bahwa visualisasi model regresi polinomial dengan derajat 4 lebih baik (lebih fit antara
model dengan data) dibandingkan dengan model regresi sederhana. Oleh karena itu kita
menggunakan model regresi polinomial untuk memprediksi berapa gaji dia ketika dulu bekerja
di perusahaan sebelumnya.
 Line 35 memprediksi gaji level 6.5 dengan model regresi sederhana. Hasilnya
adalah 330378.8 (sama dengan hasil python). Angkanya terlalu tinggi, sehingga model
regresi sederhana sangat buruk untuk memprediksi gaji.
 Line 38 sampai line 41 memprediksi gaji level 6.5 dengan model regresi polinomial
(derajat=4). Hasilnya adalah 158862.5 (sama dengan hasil python). Angka yang cukup
baik dengan model yang fit.
Sesuai dengan kesimpulan yang diambil sebelumnya (di pembahasan bahasa python), maka calon
pegawai tersebut adalah pegawai yang jujur. Oleh karena itu, perusahaan cukup beruntung
mendapatkan calon pegawai berkualitas dengan pengalaman mumpuni dan moral yang baik.
Dengan demikian calon pegawai ini wajar jika mendapat gaji di atas 160K sesuai dengan
permintaannya.
Persamaan model regresi poinomialnya adalah:
Demikianlah contoh aplikasi dari model machine learning regresi polinomial. Model yang sudah
jadi ini tentunya bisa diuji ke dataset (diuji ke test set) untuk dibandingkan performanya dengan
train set (model itu sendiri).
Semoga Anda bisa membuat model regresi polinomial Anda sendiri. Anda pun bisa
menggunakan template di atas (bahasa R maupun python) untuk menyelesaikan persoalan Anda
dengan pendekatan regresi.
Machine Learning: Support Vector

Regression
Kali ini kita akan belajar tentang model regresi lain yang disebut dengan SVR (Support
Vector Regression). Model regresi ini merupakan penggunaan dari metode machine learning yang
lain yaitu klasifikasi menggunakan SVM (Support vector machines). Model ini walaupun memiliki
nama regression di belakangnya, namun kita tidak melakukan regresi yang umum (di bahas di
materi-materi sebelumnya).
Informasi lengkap tentang pembahasan ini bisa melalui tautan ini, namun tentunya pembahasan
di link tersebut sangatlah akademis. Maka akan saya buat cara yang sangat sederhana sehingga
para pembaca bisa memahaminya dengan mudah.
Untuk lebih mudahnya mari kita melihat gambar di bawah ini:
Ilustrasi SVM
Melalui gambar di atas kita dapat melihat ada 3 garis sejajar diagonal dari kiri bawah menuju
kanan atas. Saya akan membaginya menjadi 3 garis:
 Garis paling atas (garis putus-putus) adalah garis batas +, artinya garis ini merupakan
garis yang melewati/melalui poin (satu data poin) yang menjadi bagian dari kluster +.
Titik-titik (data points) ini sering disebut juga dengan istilah support vectors. Titik yang
dilewati garis ini adalah titik terluar dari kluster + sekaligus menjadi batas bagi kluster +.
Jarak antara garis ini dengan garis tengah haruslah tegak lurus (perpendicular).
 Garis tengah adalah garis pembatas antara kedua zona (+ dan -), yang dalam SVM disebut
dengan istilah hyperplane atau separating plane/line. Garis ini memisahkan dua kluster,
yaitu klaster + dan -. Atau bisa saja kita sebut dengan kluster A dan B, 1 dan 2, dan
seterusnya (penamaan bebas, namun konvensi umum menggunakan + dan -).
 Garis paling bawah (garis putus-putus) adalah garis batas -, artinya garis ini merupakan
garis yang memiliki melewati satu data poin yang menjadi bagian dari kluster -.
Penjelasannya sama dengan garis batas +.
Perlu diingat bahwa jarak antara garis paling atas dengan garis tengah, adalah sama dengan jarak
antara garis paling bawah dengan garis tengah. Jarak ini kita sebut dengan epsilon dengan
simbol ε.
Inti dari gambar di atas (kita bahas konsep SVM dulu secara umum agar mudah memahami SVR
nantinya), adalah bagaimana agar bisa membagi dua zona (dua kluster) dengan sebisa mungkin
memaksimalkan jarak epsilon (ε) nya, sehingga didapat sebuah pembagian yang paling optimal.
Pembagian optimal itu seperti apa? Adalah didapat dua zona yang semua data poin masuk ke
dalam salah satu dari dua zona ini, dengan tingkat kepastian yang presisi (jarak epsilon paling
besar).
Jadi bisa dipahami ya apa itu SVM.
Sebagai ringkasan, SVM adalah sebuah cara membagi sebuah dataset ke dalam 2 jenis dataset
dengan menggunakan sebuah hyperplane.
Lalu apa bedanya dengan SVR? Jika SVM itu tujuannya membagi dataset (klasifikasi) ke dalam 2
zona, maka SVR sebaliknya, yaitu bagaimana caranya agar semua dataset masuk ke dalam satu
zona, dengan tetap meminimasi nilai epsilon (ε).
SVM membagi menjadi dua, SVR memasukkan semuanya menjadi satu. Mudah dimengerti
ya sampai di sini.
Sebagai ilustrasi SVR, dapat dilihat melalui gambar di bawah ini:
Ilustrasi SVR
Gambar di atas menunjukkan sebuah hyperplane (garis diagonal di tengah) yang diapit oleh dua
garis batas + dan garis batas – (dijelaskan di atas). Kita juga melihat ada ε sebagai jarak
antara hyperplane dengan 2 garis batas tadi. Bisa dilihat ada beberapa datapoin yang dilingkari
yang menjadi potential support vectors. Artinya titik-titik (data points) ini merupakan data poin
yang bisa menjadi calon pembatas, sehingga semua data poin bisa masuk ke dalam satu kluster,
dengan tetap sebisa mungkin meminimasi nilai ε nya. Sehingga jika divisualisasikan,
garis hyperplane nya sebisa mungkin melewati semua titik-titik data (data points) tadi.
Gambarnya akan tampak seperti grafik regresi pada umunya.
Sekarang mari kita bahas langkah-langkah menggunakan SVR:
1. Menyiapkan training set

2. Memilih kernel dan parameternya serta regularisasinya (regularization)
3. Membuat korelasi matriks
4. Melatih modelnya untuk mendapatkan koefisien
5. Gunakan koefisien di atas, kemudian buat estimatornya
Barangkali ada sebagian yang melihat langkah-langkah di atas terlalu rumit, karena ada proses
kalkulasi yang melibatkan vektor. Selain itu ada juga istilah kernel, yang merupakan sebuah istilah
yang menjelaskan tentang cara merubah data dari dua dimensi menjadi multi dimensi. Ada
beberapa kernel yang populer dipakai di ML yaitu kernel linear, polinomial, radial basis
function atau gaussian, dan sigmoid. Tenang saja, tidak perlu mengerti semuanya saat ini. Semua
ini akan menjadi sangat mudah ketika mencobanya memecahkan sebuah contoh nyata.
STUDI KASUS
Kali ini kita akan melakukan sebuah prediksi regresi menggunakan SVR. Kasusnya sama persis
dengan kasus gaji di pembahasan regresi polinomial. Secara ringkas, perusahaan ingin mencari
tahu apakah calon pegawai jujur atau tidak tentang gaji yang ia sampaikan di perusahaan
sebelumnya tempat ia bekerja.
Perlu dicatat melalui pembahasan sebelumnya di regresi polinomial bahwa data kita bukanlah
linear!
Bahasa Python
5
# Mengimpor dataset
8 y = dataset.iloc[:, 2:3].values
9
10 # Feature Scaling
11 from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
12 sc_y = StandardScaler()
13 X = sc_X.fit_transform(X)
14 y = sc_y.fit_transform(y)
15
16 # Fitting SVR ke dataset
17 from sklearn.svm import SVR
regressor = SVR(kernel = 'rbf')
18 regressor.fit(X, y)
19
20 # Visualisasi hasil SVR
22 plt.plot(X, regressor.predict(X), color = 'blue')
23 plt.title('Jujur atau tidak (SVR)')
plt.xlabel('Tingkat posisi')
25 plt.show()
26
27 # Memprediksi hasil
28 # y_pred = regressor.predict(6.5)
29 # y_pred = regressor.predict(sc_X.transform(6.5))
# y_pred = regressor.predict(sc_X.transform(np.array([[6.5]])))
30 y_pred = sc_y.inverse_transform(regressor.predict(sc_X.transform(np.array([[6.5]]))))
31
32 # Visualisasi hasi SVR (resolusi tinggi dan kurva yang lebih halus)
33 X_grid = np.arange(min(X), max(X), 0.01) # Pilih 0.01 dan bukan 0.1,
34 karena datanya sudah melalui feature scaling
35 X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(X, y, color = 'red')
36 plt.plot(X_grid, regressor.predict(X_grid), color = 'blue')
37 plt.title('Jujur atau tidak (SVR)')
38 plt.xlabel('Tingkat posisi')
4 plt.show()
Penjelasan:
 Line 2 sampai 4 mengimpor library apa saja yang diperlukan

 Line 7 sampai 9 mengimpor datasetnya
 Line 12 mengimpor library untuk feature scaling. Mengapa kita melakukan feature
scaling? Karena perbedaan antara gaji (satuannya jutaan) dengan level bekerja sangatlah
jauh, sehingga jika dibuat grafiknya nantinya hanya akan terlihat garis lurus saja. Oleh
karena itu feature scaling (FS) menyamakan satuannya sehingga mudah untuk
divisualisasikan dan diinterpretasikan.
Perlu juga diingat alasan mengapa kita membutuhkan FS. Library ML lainya seperti regresi linear
dan regresi polinomial sudah memiliki fitur FS di dalamnya, sehingga tidka perlu melakukan FS
lagi. Namun library SVM tidak memiliki fitur FS, sehingga kali ini kita perlu melakukan FS.
 Line 13 adalah mempersiapkan feature scaling untuk variabel X

 Line 14 adalah mempersiapkan feature scaling untuk variabel y
 Line 15 adalah proses melakukan FS kepada variabel X
 Line 16 adalah proses melakukan FS kepada variabel y
 Line 19 mengimpor sub library SVR dari library SVM
 Line 20 mempersiapkan model SVR dengan menggunakan kernel gaussian alias RBF
(radial basis function). Mengapa memilih kernel ini? Pertama, kernel ini adalah
kernel default dan paling umum dipakai. Kedua, kernel ini juga cocok untuk data non
linear.
 Line 21 membuat model SVR kita dari dataset kita (training set)
 Line 24 sampai 29 adalah untuk melihat visualisasi dari model SVR kita.
Grafiknya tampak sebagai berikut
Model SVR
Sekilas grafik di atas tampak seperti grafik regresi polinomial, namun sebenarnya itu merupakan
hasil dari model SVR. Garis biru yang tampak merupakan hyperplane dari model kita, yang sbeisa
mungkin memasukkan semua datapoints ke dalam zona euclideannya.
Perlu dicermati bahwa sumbu x dan y-nya bukanlah nilai awal, karena sudah melalui hasil feature
scalingsebelumnya. Oleh karena itu, bisa dilihat bahwa FS sangat membantu visualisasi hasil
pemodelan SVR. Karena jika tidak maka sumbu y dan sumbu x tidak akan tampak hubungan yang
jelas yang disebabkan satuan x dan y terpaut jauh.
Selain itu, di gambar tersebut dapat dilihat titik merah paling kanan (posisi CEO) tidak terhubung
dengan hyperplane. Hal ini disebabkan karena hyperplane dari SVR menganggap titik tersebut
sebagai outlier karena jaraknya terhadap titik-titik (datapoints) yang lain terlalu jauh. Sehingga
tidak menjadi bagian dari kluster SVR.
 Line 32 sampai 34 adalah alur berpikir menentukan prediksi y nya

 Line 32 adalah perintah umum untuk melakukan prediksi regresi. Namun karena nilai 6.5
(level ke 6.5) yang ingin kita prediksi perlu dilakukan FS (feature scaling), maka perintah
FS dilakukan di line 33.
 Line 33 adalah perintah melakukan FS untuk nilai 6.5 dengan cara menuliskan
sc_X.transform. Artinya kita menggunakan sc_X yang merupakan variabel yang sudah
disiapkan untuk melakukan FS terhadap nilai variabel X. Kemudian kita cukup
melakukan transform saja dan tidak perlu fit, karena kita hanya ingin melakukan FS saja
untuk kemudian memprediksi nilai y-nya, dan bukan membuat model SVR (lagi). Kalau
ingin membuat model SVR lagi, maka diperlukan transform dan fit dengan penulisan
transform_fit seperti pada line 15.
 Line 34 adalah merubah 6.5 menjadi sebuah array dengan perintah np.array[[6.5]].
Mengapa perlu menjadi array? Karena jika di inspeksi (CTRL+i) perintah transform ia
memerlukan sebuah nilai array di dalamnya. Dan agar merubah angka 6.5 ke dalam
sebuah array melalui library numpy maka perlu menuliskannya dengan ditutup dengan
2 brackets (kurung kotak).
 Line 35 adalah perintah yang kita pakai. Perlu diingat, jika kita mengeksekusi line 34,
maka yang didapat adalah nilai prediksi y dengan satuan yang sudah melalui proses FS.
Bukan itu yang kita inginkan. Kita menginginkan nilai prediksi y dalam satuan juta dolar.
Oleh karena itu prosesnya perlu dibalik, dengan cara melakukan inverse. Jika dieksekusi
maka akan menghasilkan nilai prediksi y adalah 170K dolar per tahun. Nilai yang tidak
jauh dari regresi polinomial. Walau demikian modelnya masih cukup baik dan berhasil
memprediksi nilai gaji berdasarkan level pekerjanya.
Bahasa R
2
3
4 # Membuat model SVR
5 install.packages('e1071')
6 library(e1071)
7 regressor = svm(formula = Gaji ~ .,
data = dataset,
8
type = 'eps-regression',
9 kernel = 'radial')
10
11 # Memprediksi level ke 6.5
12 y_pred = predict(regressor, data.frame(Level = 6.5))
13
14 # Visualisasi SVR
# install.packages('ggplot2')
15 library(ggplot2)
16 ggplot() +
17 geom_point(aes(x = dataset$Level, y = dataset$Gaji),
18 colour = 'red') +
19 geom_line(aes(x = dataset$Level, y = predict(regressor, newdata = dataset)),
colour = 'blue') +
20 ggtitle('Jujur atau tidak (SVR)') +
21 xlab('Tingkat') +
22 ylab('Gaji')

 Line 3 melakukan slicing (kita hanya butuh gaji sebagai sumbu y, dan level pekerjaan
sebagai sumbu x)
 Line 6 menginstall package e1071. Jika sudah punya package ini di Rstudio, maka tidak
perlu menginstallnya
 Line 7 menyalakan package e1071 yang sudah diinstall melalui perintah sebelumnya
 Line 8 membuat model SVR nya dengan membuat nama modelnya adalah regressor.
Kemudian diikuti dengan perintah svm. Untuk mengetahui parameter apa saja yang
diperlukan, cukup arahkan kursor ke svm lalu klik kiri. Setelah itu tekan F1 maka akan
tampak sebagai berikut:
Parameter SVR di Rstudio

 Line 10 menjelaskan bahwa kita memilih tipe ‘eps-regression’ karena kita ingin
melakukan regresi dengan support vectors. Jika ingin melakukan SVM pada umumnya
pilihlah TIPE ‘C-classification’
 Line 11 menjelaskan bahwa kita memilih kernel ‘radial’, karena datanya tidak linear.
Radial sama saja dengan gaussian. Bisa saja kita memilih polynomial, tapi kali ini kita
memilih yang sering dipakai secara umum yaitu ‘radial’.
 Line 14 memprediksi nilai y untuk level 6.5. Jika dieksekusi maka hasilnya 177K dolar per
tahun.
 Line 18 menyalakan/menjalankan library ggplot2 untuk visualisasi modelnya
 Line 19 sampai 26 adalah perintah visualisasi modelnya. Jika dieksekusi maka akan
tampak grafik sebagai berikut:
Model SVR di Rstudio

Tampak bahwa modelnya cukup baik memprediksi nilai gaji pegawai berdasarkan tingkatan
pekerjaannya.
Sampai sini tampak bahwa menggunakan R untuk beberapa kasus ML lebih mudah daripada
python, baik dari sisi coding dan logika berpikirnya. Namun kedua bahasa ini memiliki plus dan
minusnya. R memang spesifik untuk statistik dan ML, namun python lebih umum (general) dan
banyak diintegrasikan ke dalam hardware iseperti robot misalnya.
Baik sampai sini saya harap pembaca bisa mendapatkan gambaran tentang apa itu SVR dan
bagaimana cara memodelkannya melalui studi kasus di dunia nyata.
Machine Learning: Decision Tree
Regression
Masih tentang Machine Learning, kali ini saya akan berbagi sebuah teknik regresi,
yaitu Decision Tree (DT). Pada dasarnya DT bisa dilakukan untuk 2 hal, yaitu regresi dan
klasifikasi. Namun kali ini kita bahas teknik regresinya.
Apa itu DT? Sesuai dengan penamaannya, maka ia adalah teknik pengambilan keputusan dengan
analogi sebuah pohon memiliki banyak cabang/ akar. Di mana satu cabang akan bercabang lagi,
kemudian bercabang lagi, dan seterusnya.
Dalam konteks regresi, maka decision tree adalah regresi yang bersifat non-linear dan non-
kontinu (diskret).
Lebih mudahnya, dilihat melalui ilustrasi berikut:
Ilustrasi dataset decision tree

Anggap kita memiliki dataset seperti gambar di atas. Kita memiliki 2 variabel independen (X1,
X2) dan variabel dependen Y. Di dalam grafik ini kita lihat ada beberapa data yang diplot terhadap
sumbu X1 dan X2.
Yang dilakukan DT adalah membagi data-data ke dalam beberapa kelompok secara bertahap.
Pembagiannya dimulai dari keputusan pertama. Hasil dari keputusan pertama digunakan untuk
mengambil keputusan kedua. Hasil dari keputusan pertama dan kedua, digunakan untuk
mengambil keputusan ketiga. Begitu seterusnya.
Ilustrasinya sebagai berikut:
Keputusan pertama adalah memilih data yang nilai X1 lebih kecil dari 20.
Setelah itu langkah kedua, membagi data lagi sebagai berikut:
Keputusan kedua adalah memilih data yang nilai X2 lebih kecil dari 170.
Langkah selanjutnya kita bagi lagi:
Keputusan ketiga adalah membagi data yang masuk ke dalam kriteria keputusan pertama dengan
kriteria nilai X2 lebih kecil dari 200.
Pembagian keempat adalah sebagai berikut:
Keputusan keempat adalah membagi data yang masuk ke dalam kriteria keputusan kedua dengan
kriteria nilai X1 lebih kecil dari 40.
Setelah membagi-bagi data ke dalam beberapa kelompok, kita sekarang sudah mendapatkan 5
grup (kelompok). Data points (titik-titik) dalam masing-masing kelompok memiliki nilai Y nya
sendiri-sendiri. Sekarang anggap saja data Y dari masing-masing kelompok kita cari nilai
rataannya, sehingga ilustrasinya seperti ini:
Hasil akhir decision tree.

Sekarang kita memiliki model decision tree kita.
Dengan demikian, jika kita ingin memprediksi nilai Y (regresi nilai Y), maka cukup dilihat titik
variabel independen (X1 dan X2) masuk di kelompok mana. Mudah bukan.
Sekarang mari kita coba memecahkan permasalahan real.
Sama dengan permasalahan regresi sebelumnya di bagian pembahasan regresi polinomial . Kali
ini ingin menilai apakah calon pegawai kita jujur atau tidak saat memberikan informasi gajinya
di perusahaan sebelumnya tempat ia bekerja.
Langsung saja kita bahas menggunakan bahasa Python dan R.
Untuk mengimpor datasetnya.
Bahasa Python
1
2
import numpy as np
4
6
y = dataset.iloc[:, 2].values
10
11
# Membuat model regresi decision tree
12 from sklearn.tree import DecisionTreeRegressor
13 regressor = DecisionTreeRegressor(random_state = 0)
15
16 # Memprediksi hasil model
y_pred = regressor.predict([[6.5]])
17
18
# Visualisasi hasil regresi decision tree
19 X_grid = np.arange(min(X), max(X), 0.01)
plt.title('Sesuai atau tidak (Decision Tree Regression)')
23
plt.xlabel('Level Posisi')
25 plt.show()
26
27
Penjelasan:
 Line 2-4 mengimpor library apa saja yang diperlukan.

 Line 7 mengimpor dataset.
 Line 8 mendefinisikan variabel independen X dengan melakukan slicing hanya pada
kolom kedua (indeks python dimulai dari nol, dan indeks terakhir tidak dimasukkan).
Kebetulan dalam contoh kasus unu variabel independennya hanya 1. Untuk variabel
independen lebih dari 1 juga tidak masalah. Cukup definisikan X1, X2, dan seterusnya.
 Line 9 mendefinisikan variabel dependen Y.
 Line 12 mengimpor DecisionTreeRegressor dari library sklearn.tree.
 Line 13 mendefinisikan objek regressor untuk model regresinya dengan random number
generator adalah nol (sehingga nanti bisa diduplikasi dengan selalu mensetting
random_state=0).
 Line 14 membuat model regresi decision tree-nya.
 Line 17 mendefinisikan objek y_pred untuk memprediksi hasil model regresinya. Kali ini
kita coba memprediksinya untuk level pekerjaan 6.5. Setelah di run, kita bisa melihat
y_pred nya dan hasilnya adalah 150.000 dollar/tahun. Prediksinya cukup baik (tidak
meleset jauh jika bandingkan dengan dataset-nya). Bisa dibilang ia adalah calon pegawai
yang jujur.
 Line 20-27 adalah perintah untuk visualisasi hasil regresi decision tree. Hasilnya adalah
sebagai berikut:
Grafik hasil regresi decision tree.

Bisa diperhatikan bahwa regresi decision tree adalah regresi yang bersifat non linear dan jelas
grafiknya memang bukan garis lurus, melainkan seperti tangga yang berundak-undak.
Selain itu, regresi decision tree juga bersifat non-kontinu atau diskret, yang artinya satu titik di
sumbu X bukan mewakili satu titik di sumbu Y. Melainkan, satu titik di sumbu Y diwakili oleh
rentang interval di sumbu X. Mengapa demikian? Karena nilai di titik Y merupakaan hasil rataan
antara beberapa titik sumbu X untuk masing-masing intervalnya.
Sehingga nilai X untuk rentang X>5 sampai X<7 adalah 15.000. Bisa dipahami ya.
Bahasa R
2
3
4 # Membuat model regresi decision tree
5 install.packages('rpart')
6 library(rpart)
7 regressor = rpart(formula = Gaji ~ .,
data = dataset,
8
control = rpart.control(minsplit = 1))
9
10 # Memprediksi hasil model decision tree
12
13 # Visualisasi hasil model decision tree
library(ggplot2)
15
x_grid = seq(min(dataset$Level), max(dataset$Level), 0.01)
16 ggplot() +
19 geom_line(aes(x = x_grid, y = predict(regressor, newdata = data.frame(Level = x_grid))),
colour = 'blue') +
20 ggtitle('Sesuai atau Tidak (Decision Tree Regression)') +
21 xlab('Level') +
22 ylab('Gaji')
23
Penjelasan:

 Line 3 melakukan slicing datasetnya. Kita hanya memerlukan kolom level (kolom ke-2)
dan gaji saja (kolom ke-3).
 Line 6 menginstall package rpart. Package ini adalah library untuk membuat model
decision tree di R.
 Line 7 mengimpor library rpart. Setelah diinstall di line 6, maka kita impor (dipakai) di
sini.
 Line 8 membuat model regresinya dengan mendefinisikan objek regressor. Untuk bisa
mengerti parameter apa saja yang diperlukan, cukup arahkan kursor pada rpart
kemudian ketik di keyboard F1, maka akan muncul tampilan sebagai berikut:
Parameter yang diperlukan untuk membuat model regression tree di R.

Pada line 8 kita tambahkan parameter control = rpart.control(minsplit = 1).
 Line 13 adalah memprediksi model regresi decision tree nya untuk level 6.5. Jika kita run,
maka hasilnya adalah 250.000 dollar/tahun. Mengapa berbeda dengan python? Dalam hal
ini, sepertinya library decision tree antara R dan Python memiliki parameter yang
berbeda, sehingga hasilnya juga berbeda. Bisa dibilang, regresi decision tree pada python
sedikit lebih akurat.
 ine 16 menginstall library ggplot2 dengan menghilangkan tanda pagarnya.
 Line 17 mengimpor library ggplot2.
 Line 18-26 adalah perintah visualisasi model regresi decision tree nya. Jika dieksekusi
maka hasilnya tampak sebagai berikut:
Hasil model regresi decision tree.

Kali ini hasil visualisasinya berbeda antara R dan Python. Mengapa hal ini terjadi? Ada beberapa
penjelasan logisnya:
1. Parameter library decision tree antara python dan R berbeda.

2. Parameter estetika grafis antara python dan R berbeda.
Secara visual bisa dikatakan bahwa untuk penggunaan decision tree regression saya lebih
menyukai python. Namun bukan berarti R kurang akurat dalam memprediksi variabel dependen
dengan menggunakan decision tree. Bisa jadi untuk dataset (kasus lain) bisa saja R lebih akurat.
Demikian pembahasan regresi non linear dan non kontinu dengan menggunakan decision tree.
Semoga bermanfaat.
Machine Learning: Random Forest
Regression
Kali ini kita akan belajar tentang teknik regresi lagi,
yaitu Random Forest Regression (RFR). Jika diartikan ke dalam bahasa Indonesia artinya adalah
teknik regresi ala hutan acak, cukup unik namanya memang. Dari sini, mungkin pembaca bisa
menebak, bahwa teknik ini masih bersaudara dengan teknik Decision Tree, karena ada nama
hutan-nya (di mana hutan terdiri dari beberapa pohon). Walau agak aneh namanya jika
diterjemahkan ke bahasa Indonesia, tingkat prediksi teknik ini jangan diragukan.
Teknik RFR ini bisa diaplikasikan untuk dua hal: regresi dan klasifikasi. Namun untuk
pembahasan kali ini, kita bahas regresinya dulu.
Berikut langkah-langkah RFR:
1. Pilih beberapa data di training set sebanyak K buah (Jika datanya terlalu sedikit, misal
kurang dari 30, tidak perlu dibagi ke dalam training dan test set).
2. Buat Decision Tree-nya dari K data yang sudah dipilih sebelumnya.
3. Pilih jumlah N-tree (kumpulan pohon-pohon) yang ingin dibuat. Selanjutnya ulangi
langkah 1 dan 2. Intinya terus membuat decision tree regressionsebanyak-banyaknya
(umumnya sebanyak 200 kali, 300, 500, dst).
4. Untuk dataset yang baru, buat setiap N-tree memprediksi nilai Y untuk dataset yang baru
ini. Jika sudah, cari nilai rataan Y dari hasil prediksi N-treetadi. Misal, kita menghitung 500
prediksi nilai Y untuk dataset baru. Langkah selanjutnya, kita ambil nilai rataan Y dari 500
prediksi tadi.
Jadi alasan mengapa disebut random forest adalah karena kita melakukan penghitungan decision
tree beberapa kali (200, 300, 400, 500, dst) sehingga membentuk sebuah forest (hutan kecil).
Teknik ini memiliki tingkat akurasi cukup tinggi karena dia mengambil rataan (average) dari
sekian banyak prediksi. Dengan demikian, teknik ini bisa meminimumkan bias (error) nya.
Satu atau dua hasil prediksi yang salah memang buruk, namun jika hanya ada 2 prediksi salah
dari 500 prediksi, maka ia tidak akan menganggu nilai rataannya. Semakin banyak prediksi,
semakin baik hasil akurasi dan stabilitasnya. Namun ia akan banyak memakan waktu (waktu
komputasi bertambah).
Jika pembaca masih bingung tentang kosep random forest regression, saya coba pakai analogi lain.
Anggap kita memiliki toples yang berisi permen seperti berikut:
Toples permen
Pertanyaannya adalah, berapa banyak permen yang ada di dalam toples ini?
Logika random forest untuk menyelesaikan masalah di atas bukanlah dengan melihat toplesnya lalu
langsung menebak isinya. Jika kita melihat dan langsung menebak maka kemungkinannya 50:50 (50%
salah, 50% benar). Namun caranya adalah suruh orang lain menebaknya. Bisa dengan cara ia mencoba
melihat isinya, meraba isi toples dan lain-lain. Setiap tebakan yang ia ucapkan, maka kita tulis di
kertas.
Selanjutnya suruh orang lain menebak lagi. Setiap mereka mengucapkan tebakannya,tulis di kertas
lagi. Terus lakukan ini sampai kurang lebih 200 kali misalnya. Selanjutnya, langkah terakhir adalah
cukup menghitung rataan dari 200 tebakan yang sudah Anda catat. Secara statistik, maka semakin
banyak tebakan, semakin dekat Anda untuk memprediksi jumlah permen yang sesungguhnya. Mudah
bukan?
Selanjutnya kita akan mencoba mengaplikasikan konsep random forest regression untuk kasus nyata.
Kali ini kita coba memprediksi apakah dan melihat apakah calon pegawai kita jujur atau tidak saat
memberikan informasi gajinya di perusahaan sebelumnya tempat ia bekerja. Untuk membaca secara
detail permasalahannya silakan buka di bagian pembahasan regresi polinomial
Bahasa Python
1 # Mengimpor library yang diperlukan

4
9
# Membuat model random forest regression
10 from sklearn.ensemble import RandomForestRegressor
11 regressor = RandomForestRegressor(n_estimators = 10, random_state = 0)
13
14 # Memprediksi nilai Y dari modelnya
15 y_pred = regressor.predict([[6.5]])
16
# Visualisasi hasil random forest regression
17 X_grid = np.arange(min(X), max(X), 0.01)
21 plt.title('Jujur atau tidak (Random Forest Regression)')
plt.xlabel('Tingkat posisi')
23 plt.show()
24
25
26
27
Penjelasan:
 Line 2-5 mengimpor library apa saja yang diperlukan.

 Line 8 mendefinisikan variabel independen X dengan melakukan slicing. Kita hanya butuh
kolom kedua (kolom level).
 Line 9 mendefinisikan variabel dependen Y dengan melakukan slicing Kita butuh kolom
ketiga (kolom gaji).
 Line 12 mengimpor library untuk membuat model random forest regression dari sklearn.
 Line 13 mendefinisikan variabel regressor. Parameter yang kita tentukan adalah
n_estimator yaitu sebanyak 10 buah. Artinya kita membuat 10 prediksi yang nantinya
akan dihitung nilai rataannya. Tips: Untuk bisa melihat parameter apa saja yang
diperlukan, cukup arahkan kurson pada RandomForestRegressor kemudian ketik CTRL+i
pada keyboard. Maka akan tampak tampilan sebagai berikut di bagian help spyder:
Parameter random forest di Python
 Line 14 adalah mengaplikasikan model kita ke datasetnya.

 Line 17 adalah memprediksi variabel dependen Y dengan nilai X=6.5. Jika dieksekusi
maka nilai y_pred nya adalah 167.000 dollar/tahun. Cukup baik prediksinya, sangat dekat
dengan datasetnya.
 Line 20-27 adalah perintah untuk visualisasi hasil model dan prediksinya. Jika dieksekusi
maka akan tampak sebagai berikut:
Hasil random forest regression

Bisa dilihat bahwa jumlah anak tangga pada random forest regression lebih banyak jika
dibandingkan dengan satu grafik dari 1 decision tree di contoh sebelumnya. Saya tampilkan lagi
grafik dari 1 decision tree sebagai berikut:
Hasil 1 decision tree dari contoh sebelumnya

Mengapa random forest lebih baik dibandingkan 1 decision tree seperti pada penjelasan
sebelumnya? Karena model random forest kita aalah hasil dari 10 decision tree. Selain itu,
ditunjukkan dengan semakin banyaknya anak tangga, yang menggambarkan semakin banyak
interval pembagiannhya (interval pembagian adalah pembagian cabang keputusan dalam
analogi decision tree).
Selain itu prediksi y_pred di model random_forest juga sangat dekat dengan datasetnya yaitu
167rb dollar/tahun. Jika dibandingkan dengan 1 decision treeyaitu 150rb dollar/tahun, maka
prediksi random forest lebih presisi, karena lebih dekat ke 175rb dollar/tahun (di dataset level 6
adalah 150rb dan level 7 adalah 200rb, maka nilai median nya adalah 175rb).
Tentu saja pembaca bisa mencoba-coba dengan parameter lain. Misal dengan meningkatkan
jumlah N-tree nya di parameter n_estimators.
Bahasa R
1
2
4 dataset = read.csv('Posisi_gaji.csv')
5
6 # Membuat model random forest regression
7 install.packages('randomForest')
8 library(randomForest)
9 set.seed(1234)
10 regressor = randomForest(x = dataset[1],
y = dataset$Gaji,
11 ntree = 500)
12
13 # Memprediksi hasil model regresi random forest
15
16 # Visualisasi hasil random forest regression
library(ggplot2)
18 x_grid = seq(min(dataset$Level), max(dataset$Level), 0.01)
19 ggplot() +
22 geom_line(aes(x = x_grid, y = predict(regressor, newdata = data.frame(Level = x_grid))),
colour = 'blue') +
23 ggtitle('Sesuai atau tidak (Random Forest Regression)') +
24 xlab('Level') +
25 ylab('Gaji')
26
27
Penjelasan:

 Line 3 melakukan slicing untuk variabel X dan y. Kita hanya butuh kolom Level dan Gaji.
 Line 6 menginstall package randomForest. Cukup dieksekusi maka ia akan
menginstall package ini secara otomatis.
 Line 7 menjalankan package randomForest yang baru saja diinstall di line 6.
 Line 8 menentukan random number generator yaitu 1234. Angka ini bebas. Tujuannya
adalah jika ingin mereplikasi hasilnya, cukup samakan angka seednya.
 Line 9 membuat model regressor sebagai wadah dari random forest regression. Tips:
Untuk bisa melihat parameter apa saja yang diperlukan, cukup arahkan kurson pada
randomForest kemudian ketik F1 pada keyboard. Maka akan tampak tampilan sebagai
berikut di R:
Parameter random forest di R
 Line 14 memprediksi variabel dependen y dengan nilai X=6.5 melalui model yang sudah
dibuat di line 9. Hasil y_pred adalah 160.908 dollar per tahun. Masih baik, jika
dibandingkan decision tree sebelumnya yaitu 250.000 dollar per tahun.
 Line 17 menginstall package ggplot2. Jika ingin menginstallnya cukup hilangkan tanda
pagar (#). Jika sudah terinstall, tidak perlu melakukan apa-apa.
 Line 18 menjalankan package ggplot2.
 Line 19-27 adalah perintah untuk visualisasi hasil modelnya. Jika dieksekusi maka
tampilannya tampak sebagai berikut:
Hasil random forest regression di R
Bisa dilihat bahwa anak tangga random forest regression lebih banyak jika dibandingkan dengan
hasil dari 1 decision tree pada pembahasan sebelumnya. Untuk ilustrasi perbandingan, berikut
grafik dari model 1 decision tree sebelumnya:
Hasil model regresi decision tree pada contoh sebelumnya.

Jelas bahwa random forest regression lebih baik daripada decision tree regression karena
memang random forest adalah hasil dari beberapa decision tree. Selain itu hasil prediksinya juga
jauh lebih akurat, yaitu 160.908 dollar/tahun, dibandingkan dengan 1 decision tree yaitu 250.000
dollar/tahun.
Mengapa prediksi angkanya lebih akurat? Karena di dataset nilai gaji untuk level 6 adalah 150rb
dan level 7 adalah 200rb, maka nilai median nya (untuk posisi 6.5) adalah 175rb.
Perlu diperhatikan bahwa di R bisa saja y_pred yang Anda dapatkan tidak sama dengan yang ada
di pembahasan ini, walaupun menggunakan angka seedyang sama. Hal ini dikarenakan R selalu
mengenerate bilangan random setiap sebuah script dieksekusi. Walau demikian, hasilnya tidak
akan jauh dari yang ada di pembahasan ini.
Barangkali pembaca ada yang membandingkan, mengapa hasil antara Python dan R berbeda?
Bisa saja berbeda, dikarenakan dua program ini memiliki parameter berbeda, dan kita juga
menggunakan random number generator yang berbeda untuk dua bahasa ini. Di pembahasan R
kita menggunakan jumlah pohon sebanyak 500, sementara di Python hanya 10 saja. Walau
demikian, setidaknya kesimpulan yang didapat dari dua bahasa ini sama, yaitu hasil
prediksi random forest lebih baik daripada decision tree.
Dengan demikian, bisa kita simpulkan bahwa untuk bisa mendapatkan hasil prediksi yang baik,
kita bisa menggunakan random forest regression.
Semoga pembaca mendapatkan manfaat dari pembahasan teknik random forest regression kali
ini, dan yang tidak kalah penting, semoga bisa mengaplikasikannya untuk permasalahan nyata
yang dihadapi.

Regression

Diunggah oleh

Informasi Dokumen

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

Regression

Diunggah oleh

Hak Cipta:

Format Tersedia

Regression

 Simple linear regression

# Impor library yang dibutuhkan

 Line 2 sampai 4 adalah mengimpor library yang diperlukan.

 Line 21 membuat prediksi dengan menggunakan metode .predict. Untuk menegtahui

Jika sudah, maka hasilnya akan nampak sebagai berikut:

# Membagi dataset menjadi Training set and Test set

# Fitting Simple Linear Regression ke the Training set

# Memprediksi hasil test set

# Visualising the Training set results

# Visualising the Test set results

# Analisis statistik model regresi

 Line 2 mengimpor datasetnya.

Jika dieksekusi, maka akan menampilkan grafik sebagai berikut:

 Line 32 sampai line 38 menampilkan grafik untuk test set.

Jika dieksekusi, maka akan menampilkan grafik sebagai berikut:

Jika dieksekusi maka hasilnya adalah sebagai berikut:

 Variabel dependen = Profit (data numerik)

# Mengimpor library yang diperlukan

 Line 2 sampai line 4 mengimpor library yang diperlukan.

Perbandingan antara y_pred dengan y_test akan tampak sebagai berikut:

 Line 35 mengimpor library stastmodels.api sebagai sma

Seperti kita ketahui, fungsi umum dari multi regresi adalah:

 Line 37 mengimpor library statsmodels.formula.api sebagai sm.

Tampilan summary multiple regression

 const adalah nilai koefisien untuk

Tampilan script backward elimination otomatis di Python

 Line 2 mengimpor dataset yang diperlukan.

Visualisasi simple linear dan polinomial

Fungsi non linear –>

 Line 2 sampai line 4 mengimpor library yang diperlukan

 Line 20 menyiapkan objek lin_reg_2 sebagai model regresi polinomial.

Kesimpulan apa yang bisa diambil dari model polinomial?

 Line 2 mengimpor dataset.

 Line 16 menginstal package ggplot2 (jika sudah terinstall abaikan saja)

Machine Learning: Support Vector

1. Menyiapkan training set

5. Gunakan koefisien di atas, kemudian buat estimatornya

 Line 2 sampai 4 mengimpor library apa saja yang diperlukan

 Line 13 adalah mempersiapkan feature scaling untuk variabel X

Grafiknya tampak sebagai berikut

 Line 32 sampai 34 adalah alur berpikir menentukan prediksi y nya

 Line 2 mengimpor datasetnya

Parameter SVR di Rstudio

Model SVR di Rstudio

Ilustrasi dataset decision tree

Hasil akhir decision tree.

 Line 2-4 mengimpor library apa saja yang diperlukan.

Grafik hasil regresi decision tree.

 Line 2 mengimpor datasetnya.

Parameter yang diperlukan untuk membuat model regression tree di R.

Hasil model regresi decision tree.

1. Parameter library decision tree antara python dan R berbeda.

1 # Mengimpor library yang diperlukan

 Line 2-5 mengimpor library apa saja yang diperlukan.

Parameter random forest di Python

 Line 14 adalah mengaplikasikan model kita ke datasetnya.

Hasil random forest regression

Hasil 1 decision tree dari contoh sebelumnya

 Line 2 mengimpor datasetnya

Parameter random forest di R

Hasil model regresi decision tree pada contoh sebelumnya.

Anda mungkin juga menyukai