Yohanes Danu Widyatmaka - 51421535

Instruksi Tugas untuk fakultas FIKTI dan FTI (kecuali jurusan yang
dituliskan diatas)
Buatlah laporan akhir yang menjelaskan langkah-langkah serta penjelasan tahapan yang
Anda lakukan pada praktikum ini, yang didalamnya menjawab beberapa pertanyaan
sebagai berikut
1. Rubahlah fitur cement menjadi fitur target class yang ingin Anda prediksi, dengan
nilai fitur > 281 merupakan kelas 1 dan < 281 menjadi nilai 0. Berapa akurasi model
dan nilai k untuk skenario ini?
2. Pada hasil diagram heatmap, terlihat banyak konfigurasi warna dan nilai yang
ditampilkan. Jelaskan arti kolom berwarna merah pada hasil diagram heatmap yang
dihasilkan! Pasangan variabel apa saja yang bernilai merah?
3. Apa yang terjadi jika, nilai test set diganti menjadi 0.3 kemudian 0.2 dan 0,1 ?
4. Buatlah tabel yang berisi hasil pengujian Anda dan sertakan berapa nilai k dan nilai
akurasi untuk masing-masing skenario uji.
5. Apakah terjadi perbedaan nilai akurasi model? Jika Ya, jelaskan pendapat Anda
mengapa hal tersebut bisa terjadi.
6. Berapa nilai presisi dan recall dari masing-masing model yang Anda coba serta
jelaskan arti dari nilai tersebut.

1. Memprediksi Fitur Cement

Import Dataset
# Import library
import pandas as pd
import numpy as np

#### import dataset

data = pd.read_csv('https://gitlab.com/andreass.bayu/file-
directory/-/raw/main/new_concreate.csv')

# Lihat 5 data awal

data.head(5)

cement slag ash water superplastic coarseagg fineagg age

\
0 141.3 212.0 NaN 203.5 NaN 971.8 748.5 28

1 168.9 42.2 124.3 158.3 10.8 1080.8 796.2 14

2 250.0 NaN 95.7 187.4 5.5 956.9 861.2 28

3 266.0 114.0 NaN 228.0 NaN 932.0 670.0 28

4 154.8 183.4 NaN 193.3 9.1 1047.4 696.7 28

strength
0 29.89
1 23.51
2 29.22
3 45.85
4 18.29

Review Dataset
# Lihat deskripsi dari tiap kolom
data.describe()

cement slag ash water superplastic

\
count 1030.000000 559.000000 464.000000 1030.000000 651.000000

mean 281.167864 136.158676 120.288793 181.567282 9.816897

std 104.506364 72.351823 33.675470 21.354219 4.580328

min 102.000000 11.000000 24.500000 121.800000 1.700000

25% 192.375000 95.000000 97.850000 164.900000 6.950000

50% 272.900000 135.700000 121.400000 185.000000 9.400000

75% 350.000000 189.000000 141.000000 192.000000 11.600000

max 540.000000 359.400000 200.100000 247.000000 32.200000

coarseagg fineagg age strength

count 1030.000000 1030.000000 1030.000000 1030.000000
mean 972.918932 773.580485 45.662136 35.817961
std 77.753954 80.175980 63.169912 16.705742
min 801.000000 594.000000 1.000000 2.330000
25% 932.000000 730.950000 7.000000 23.710000
50% 968.000000 779.500000 28.000000 34.445000
75% 1029.400000 824.000000 56.000000 46.135000
max 1145.000000 992.600000 365.000000 82.600000

# Lihat tipe data dari tiap kolom

data.dtypes
cement float64
slag float64
ash float64
water float64
superplastic float64
coarseagg float64
fineagg float64
age int64
strength float64
dtype: object

# mlihat jumlah atribut dan data / dimensi data

data.shape

(1030, 9)

# hitung dan melihat jumlah data per label kelas

for col in data.columns:
print('Attribute name:',col)
print('-------------------')
print(data[col].value_counts())
print('-------------------')

Attribute name: cement

-------------------
362.6 20
425.0 20
251.4 15
310.0 14
446.0 14
..
288.4 1
317.9 1
264.5 1
485.0 1
276.4 1
Name: cement, Length: 278, dtype: int64
-------------------
Attribute name: slag
-------------------
189.0 30
106.3 20
24.0 14
20.0 12
145.0 11
..
161.6 1
133.7 1
139.0 1
162.0 1
115.0 1
Name: slag, Length: 184, dtype: int64
-------------------
Attribute name: ash
-------------------
118.3 20
141.0 16
24.5 15
79.0 14
94.0 13
..
99.6 1
109.0 1
132.6 1
60.0 1
90.3 1
Name: ash, Length: 155, dtype: int64
-------------------
Attribute name: water
-------------------
192.0 118
228.0 54
185.7 46
203.5 36
186.0 28
...
190.5 1
201.3 1
167.9 1
167.8 1
179.6 1
Name: water, Length: 195, dtype: int64
-------------------
Attribute name: superplastic
-------------------
11.6 37
8.0 27
7.0 19
6.0 17
9.9 16
..
6.3 1
2.2 1
18.3 1
4.0 1
7.2 1
Name: superplastic, Length: 110, dtype: int64
-------------------
Attribute name: coarseagg
-------------------
932.0 57
852.1 45
944.7 30
968.0 29
1125.0 24
..
990.0 1
924.1 1
892.0 1
924.0 1
979.5 1
Name: coarseagg, Length: 284, dtype: int64
-------------------
Attribute name: fineagg
-------------------
755.8 30
594.0 30
670.0 23
613.0 22
801.0 16
..
760.1 1
764.0 1
794.0 1
805.3 1
768.3 1
Name: fineagg, Length: 302, dtype: int64
-------------------
Attribute name: age
-------------------
28 425
3 134
7 126
56 91
14 62
90 54
100 52
180 26
91 22
365 14
270 13
360 6
120 3
1 2
Name: age, dtype: int64
-------------------
Attribute name: strength
-------------------
33.40 6
35.30 4
71.30 4
23.52 4
79.30 4
..
17.34 1
48.70 1
31.64 1
35.85 1
52.61 1
Name: strength, Length: 845, dtype: int64
-------------------

#import library seaborn untuk visualisasi

import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

# Plot figure untuk menentukan distribusi kelas

plt.figure(figsize=(8,5))

# menghitung baris setiap kelas

sns.countplot(x="cement", data=data)

<Axes: xlabel='cement', ylabel='count'>

Dataset memiliki distribusi nilai untuk kelas cement yang beragam.

Dataset preparation
# Buat salinan dataframe
df = data.copy(deep = True)
# mengubah/convert nilai "?" nilai ke bentuk Na / NaN untuk diproses
lebih lanjut
for col in data.columns:
df[[col]] = data[[col]].replace('?',np.NaN)

# seleksi kolom fitur/feature columns dari dataset

null_data = df.iloc[:,:-1]

# temukan nilai null untuk semua atribut dan jumlahkan total nilai
null
null_data.isnull().sum()

cement 0
slag 471
ash 566
water 0
superplastic 379
coarseagg 0
fineagg 0
age 0
dtype: int64

# jatuhkan/drop semua baris yang memiliki nilai null

df = df.dropna()

# pilih kolom fitur/feature columns dari dataset

null_data = df.iloc[:,:-1]

# cek ulang nilai null

null_data.isnull().sum()

cement 0
slag 0
ash 0
water 0
superplastic 0
coarseagg 0
fineagg 0
age 0
dtype: int64

StandardScaler adalah class dari sklearn untuk melakukan normalisasi data agar data yang
digunakan tidak memiliki penyimpangan yang besar.
# Import library standard scaler

from sklearn.preprocessing import StandardScaler

# Buat dataframe dengan tipe data int64
colname= []
for col in df.columns:
if df[col].dtype == "int64":
colname.append(col)

# Buat salinan dataset untuk keperluan persiapan data / data

preparation
df_copy = df.copy(deep = True)
df_fe = df.copy()

# Buat kerangka data untuk fitur kategoris / categorical features

df_fe.drop('cement',axis='columns', inplace=True)
df_fe.drop(colname,axis='columns', inplace=True)

# buat dataframe untuk kelas target / target class

df_cl = df.copy()
df_cl.drop(df_cl.columns[1:], axis='columns', inplace=True)

# membuat objek scaler / scaler object

std_scaler = StandardScaler()
std_scaler

# Normalisasikan atribut numerik dan tetapkan ke dalam dataframe baru

df_norm = pd.DataFrame(std_scaler.fit_transform(df_copy[colname]),
columns=colname)

Mengapa Menskalakan data untuk KNN? Ketika Anda menggunakan algoritma berbasis
jarak seperti KNN, proses penyesuaian skala data sangatlah penting karena akan
mempengaruhi nilai dari proses perhitungan jarak dilakukan dengan skala yang sama.
Sebagai ilustrasi perhitungan jarak menggunakan dua fitur yang besaran/rentangnya
sangat bervariasi dengan menggunakan perhitungan jarak eucledian. Jarak Euclidean =
[(100000–80000)^2 + (30–25)^2]^(1/2)
fitur dengan jangkauan yang lebih besar akan mendominasi atau mengecilkan fitur yang
lebih kecil sepenuhnya dan ini akan berdampak pada kinerja semua model berbasis jarak
karena akan memberikan bobot yang lebih tinggi pada variabel yang memiliki nilai yang
lebih tinggi.¶
# import library Ordinal Encoder dari package library
sklearn.preprocessing
from sklearn.preprocessing import OrdinalEncoder
ord_enc = OrdinalEncoder()
# enconde fitur kategoris/categorical features menjadi fitur
numerik/numerical features
for col in df_fe.columns[:]:
if df_fe[col].dtype == "object":
df_fe[col] = ord_enc.fit_transform(df_fe[[col]])

tentukan kolom cement sebagai kolom 'target' yang ingin di prediksi dengan threshold(batas
ambang) dari sebuah campuran semen yang di nilai kuat adalah yang memiliki nilai cement >
281.
Sehingga, selanjutnya kita akan melakukan proses encoding untuk kolom fitru cement,
dimana nilai yang > 281 akan diubah menjadi nilai 1 (yang berarti kuat) dan nilai <281
diubah menjadi nilai 0 (yang berarti kategori kurang kuat)
# Melakukan proses encoding untuk mengubah fitur cement menjadi nilai
biner.
df_cl["cement"] = np.where(df_cl["cement"]<281, 0, 1)

df_cl.head(10)

cement
1 0
9 0
10 0
14 0
15 0
23 0
29 0
35 0
37 0
39 0

# Masukkan kolom id ke datasets yang berbeda

df_norm.insert(0, 'id', range(0, 0 + len(df_norm)))
df_fe.insert(0, 'id', range(0, 0 + len(df_fe)))
df_cl.insert(0, 'id', range(0, 0 + len(df_cl)))

# Lihat shapes datasets yang telah di proses

print(df_norm.shape)
print(df_fe.shape)
print(df_cl.shape)

(225, 2)
(225, 8)
(225, 2)

# Gabungkan semua datasets

df_feature = pd.merge(df_norm,df_fe, on=["id"])
df_final = pd.merge(df_feature,df_cl, on=["id"])
# Drop kolom id dari gabungan dataset
df_final.drop('id',axis='columns', inplace=True)

# Lihat 5 data awal dari gabungan dataset

df_final.head(5)

age slag ash water superplastic coarseagg fineagg

strength \
0 -0.720253 42.2 124.3 158.3 10.8 1080.8 796.2
23.51
1 -0.129574 184.0 143.0 194.0 9.0 880.0 699.0
28.99
2 -0.129574 178.1 138.7 167.5 18.3 944.0 694.6
36.35
3 -0.129574 187.0 195.0 185.0 7.0 898.0 636.0
23.89
4 2.908201 98.1 24.5 181.7 6.7 1066.0 785.5
49.97

cement
0 0
1 0
2 0
3 0
4 0

Visualization
p = df_final.hist(figsize = (20,20))
Scatter matrix plot adalah plot yang digunakan untuk membuat sekumpulan scatter plot
dari beberapa pasang variabel. Hal ini sangat bermanfaat terutama ketika ingin
menganalisis bagaimana bentuk hubungan antar variabel. Plot ini sangat bermanfaat untuk
digunakan untuk data yang ukurannya tidak terlalu besar. Untuk menggunakan scatter
matrix kita harus memanggil fungsi scatter_matrix dari pandas.plotting
from pandas.plotting import scatter_matrix

p=scatter_matrix(df_final,figsize=(25, 25))
2. Penjelasan Diagram Heatmap
# Buat visualisasi korelasi data dengan heatmap
import seaborn as sns
import matplotlib.pyplot as plt

# plot heatmap
plt.figure(figsize=(12,10))
p=sns.heatmap(df_final.corr(), annot=True,cmap ='RdYlGn')
Koefisien Korelasi Pearson:
Koefisien pearson mambantu kita mengetahui keterhubungan antara dua fitur atau
variable. Nilai Koefisien Korelasi Pearson dapat berkisar antara -1 sampai +1. 1 berarti
sangat berkorelasi dan 0 berarti tidak ada korelasi.
Heatmap diatas merupakan hasil visualisasi representasi informasi dua dimensi dengan
bantuan gradasi warna untuk mempermudah interpretasi hasil.
Penjelasan:
• Warna merah pada diagram heatmap di atas adalah penunjuk untuk Nilai Koefisien
Korelasi Pearson yang paling kecil, atau nilai negatif terbesar mendekati -1. Hal ini
menunjukkan adanya hubungan linier negatif yang kuat antara dua variabel.
Artinya, jika satu variabel meningkat, maka variabel lainnya cenderung menurun
secara konsisten.

• Adapun pasangan variabel yang bernilai merah adalah:

a. slag dengan cement

 b. water dengan coarseagg
c. water dengan fineagg
yang berarti bahwa ketika salah satu elemen dari pasangan-pasangan tersebut
meningkat, maka pasangannya cenderung menurun secara konsisten, begitu pula
sebaliknya.

3. Perubahan Nilai Test Set Menjadi 0.3, 0.2, dan 0.1

## memisahkan data fitur dengan label yang akan di pelajari
train_data = df_final.drop("cement",axis = 1)
train_data.head()

age slag ash water superplastic coarseagg fineagg

strength
0 -0.720253 42.2 124.3 158.3 10.8 1080.8 796.2
23.51
1 -0.129574 184.0 143.0 194.0 9.0 880.0 699.0
28.99
2 -0.129574 178.1 138.7 167.5 18.3 944.0 694.6
36.35
3 -0.129574 187.0 195.0 185.0 7.0 898.0 636.0
23.89
4 2.908201 98.1 24.5 181.7 6.7 1066.0 785.5
49.97

## memisahkan data label dengan label yang akan di pelajari

df_final.cement = df_final.cement.astype(np.int64)
label_data = df_final.cement
label_data.head()

0 0
1 0
2 0
3 0
4 0
Name: cement, dtype: int64

from sklearn.model_selection import train_test_split

# Test set 0.3

X_train_03, X_test_03, y_train_03, y_test_03 =
train_test_split(train_data, label_data, test_size=0.3,
random_state=42)

# Test set 0.2

X_train_02, X_test_02, y_train_02, y_test_02 =
train_test_split(train_data, label_data, test_size=0.2,
random_state=42)

# Test set 0.1

X_train_01, X_test_01, y_train_01, y_test_01 =
train_test_split(train_data, label_data, test_size=0.1,
random_state=42)

from sklearn.neighbors import KNeighborsClassifier

import sklearn.metrics as metrics

# Test set 0.3

scores = []
lrange = list(range(1, 25))

for k in lrange:
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train_03, y_train_03.ravel())
y_pred = knn.predict(X_test_03)
scores.append(metrics.accuracy_score(y_test_03, y_pred))

plt.figure(2, figsize=(15, 5))

optimal_k_03 = lrange[scores.index(max(scores))]
print("Nilai k KNN yang optimal adalah %d" % optimal_k_03)
print("Skor optimalnya adalah %.2f" % max(scores))

plt.plot(lrange, scores, ls='dashed')

plt.xlabel('Nilai dari k untuk KNN')
plt.ylabel('Accuracy Score')
plt.title('Accuracy Scores untuk nilai k dari k-Nearest-Neighbors')
plt.show()

knn = KNeighborsClassifier(13)
knn.fit(X_train_03, y_train_03)
accuracy_03 = knn.score(X_test_03, y_test_03)
print("Skor akurasi KNN pada test set 0.3 adalah: %.2f" % accuracy_03)

Nilai k KNN yang optimal adalah 1

Skor optimalnya adalah 1.00

Skor akurasi KNN pada test set 0.3 adalah: 0.91

# Test set 0.2
scores = []
lrange = list(range(1, 25))

for k in lrange:
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train_02, y_train_02.ravel())
y_pred = knn.predict(X_test_02)
scores.append(metrics.accuracy_score(y_test_02, y_pred))

plt.figure(2, figsize=(15, 5))

optimal_k_02 = lrange[scores.index(max(scores))]
print("Nilai k KNN yang optimal adalah %d" % optimal_k_02)
print("Skor optimalnya adalah %.2f" % max(scores))

plt.plot(lrange, scores, ls='dashed')

plt.xlabel('Nilai dari k untuk KNN')
plt.ylabel('Accuracy Score')
plt.title('Accuracy Scores untuk nilai k dari k-Nearest-Neighbors')
plt.show()

knn = KNeighborsClassifier(13)
knn.fit(X_train_02, y_train_02)
accuracy_02 = knn.score(X_test_02, y_test_02)
print("Skor akurasi KNN pada test set 0.2 adalah: %.2f" % accuracy_02)

Nilai k KNN yang optimal adalah 1

Skor optimalnya adalah 1.00

Skor akurasi KNN pada test set 0.2 adalah: 0.89

# Test set 0.1

scores = []
lrange = list(range(1, 25))

for k in lrange:
knn = KNeighborsClassifier(n_neighbors=k)
 knn.fit(X_train_01, y_train_01.ravel())
y_pred = knn.predict(X_test_01)
scores.append(metrics.accuracy_score(y_test_01, y_pred))

plt.figure(2, figsize=(15, 5))

optimal_k_01 = lrange[scores.index(max(scores))]
print("Nilai k KNN yang optimal adalah %d" % optimal_k_01)
print("Skor optimalnya adalah %.2f" % max(scores))

plt.plot(lrange, scores, ls='dashed')

plt.xlabel('Nilai dari k untuk KNN')
plt.ylabel('Accuracy Score')
plt.title('Accuracy Scores untuk nilai k dari k-Nearest-Neighbors')
plt.show()

knn = KNeighborsClassifier(13)
knn.fit(X_train_01, y_train_01)
accuracy_01 = knn.score(X_test_01, y_test_01)
print("Skor akurasi KNN pada test set 0.1 adalah: %.2f" % accuracy_01)

Nilai k KNN yang optimal adalah 1

Skor optimalnya adalah 1.00

Skor akurasi KNN pada test set 0.1 adalah: 0.87

4. Tabel Hasil Pengujian

import pandas as pd
from tabulate import tabulate

hasil_uji = {
'Test Set': ['0.3', '0.2', '0.1'],
'Nilai k KNN Optimal': [optimal_k_03, optimal_k_02, optimal_k_01],
'Skor Akurasi KNN': [accuracy_03, accuracy_02, accuracy_01]
}

tabel_hasil_uji = tabulate(pd.DataFrame(hasil_uji), headers='keys',

tablefmt='psql')
print(tabel_hasil_uji)

+----+------------+-----------------------+--------------------+
| | Test Set | Nilai k KNN Optimal | Skor Akurasi KNN |
|----+------------+-----------------------+--------------------|
| 0 | 0.3 | 1 | 0.911765 |
| 1 | 0.2 | 1 | 0.888889 |
| 2 | 0.1 | 1 | 0.869565 |
+----+------------+-----------------------+--------------------+

Penjelasan:
• Dalam semua skenario pengujian, nilai k yang optimal adalah 1.
• Skor akurasi yang diperoleh untuk masing-masing skenario adalah 0.911765 untuk
test set 0.3, 0.888889 untuk test set 0.2, dan 0.869565 untuk test set 0.1.
Kesimpulan:
• Hasil pengujian tersebut menunjukkan bahwa model KNN dengan nilai k=1
memberikan hasil yang cukup baik dalam melakukan prediksi pada dataset yang
diuji, dengan skor akurasi yang relatif tinggi pada semua skenario pengujian.
• Semakin besar test set, semakin besar pula skor akurasi yang didapat.

5. Pendapat Mengenai Tabel Hasil Uji

Pertanyaan: Apakah terjadi perbedaan nilai akurasi model? Jika Ya, jelaskan pendapat
Anda mengapa hal tersebut bisa terjadi.
Jawab: Ya, terjadi perbedaan nilai akurasi model di mana akurasi model pada test set
dengan proporsi 0.1 lebih kecil dari akurasi model pada test set dengan proporsi 0.2, dan
akurasi test set 0.2 lebih kecil daripada akurasi test set 0.3.
Hal ini dapat terjadi karena jumlah data yang digunakan untuk evaluasi model pada test set
yang lebih kecil adalah lebih sedikit. Dalam kasus ini, model hanya diuji dengan sejumlah
sampel terbatas, sehingga hasil akurasi dapat dipengaruhi oleh variasi dalam sampel yang
lebih kecil.
Selain itu, test set yang lebih kecil memberikan model lebih sedikit data untuk melakukan
training dan membuat prediksi. Ini dapat membuat model menjadi kurang akurat karena
kurangnya representasi yang memadai dari data untuk membangun pola yang kuat.
Oleh karena itu, penting untuk memahami bahwa hasil akurasi pada test set yang berbeda
dapat bervariasi, terutama jika jumlah sampel pada test set berbeda-beda. Evaluasi model
pada test set yang lebih besar atau mewakili populasi secara statistik cenderung
memberikan hasil yang lebih dapat diandalkan dan dapat digeneralisasi dengan lebih baik.

6. Nilai Presisi dan Recall dari Tiap Test Set

# Test set 0.3
from sklearn import metrics
y_pred = knn.predict(X_test_03)
cnf_matrix = metrics.confusion_matrix(y_test_03, y_pred)
p = sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu",
fmt='g')
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')

from sklearn.metrics import classification_report

print(classification_report(y_test_03, y_pred))

precision recall f1-score support

0 0.94 0.96 0.95 49

1 0.89 0.84 0.86 19

accuracy 0.93 68
macro avg 0.91 0.90 0.91 68
weighted avg 0.93 0.93 0.93 68
Penjelasan:
• Model memiliki akurasi sebesar 93% pada test set 0.3.
• Model memiliki presisi yang tinggi untuk kedua kelas, yaitu 94% untuk kelas 0 dan
89% untuk kelas 1. Ini berarti sebagian besar prediksi positif adalah benar.
• Recall untuk kelas 0 adalah 96%, yang menunjukkan kemampuan model dalam
mengidentifikasi dengan benar sebagian besar data dengan label 0. Namun, recall
untuk kelas 1 adalah 84%, yang menunjukkan bahwa model sedikit lebih rendah
dalam mengidentifikasi dengan benar data dengan label 1. Keduanya masih
termasuk dalam kategori recall yang baik.
• Skor F1 untuk kedua kelas juga cukup baik, yaitu 0.95 untuk kelas 0 dan 0.86 untuk
kelas 1.
Secara keseluruhan, model menunjukkan kinerja yang baik dalam mengklasifikasikan data
# Test set 0.2
y_pred = knn.predict(X_test_02)
cnf_matrix = metrics.confusion_matrix(y_test_02, y_pred)
p = sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu",
fmt='g')
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')

print(classification_report(y_test_02, y_pred))

precision recall f1-score support

0 0.91 0.94 0.92 32

1 0.83 0.77 0.80 13

accuracy 0.89 45
macro avg 0.87 0.85 0.86 45
weighted avg 0.89 0.89 0.89 45
Penjelasan:
• Model memiliki akurasi sebesar 89% pada test set 0.2.
• Presisi untuk kedua kelas adalah 91% untuk kelas 0 dan 83% untuk kelas 1. Ini
menunjukkan bahwa sebagian besar prediksi positif adalah benar.
• Recall untuk kelas 0 adalah 94%, yang menunjukkan kemampuan model dalam
mengidentifikasi dengan benar sebagian besar data dengan label 0. Namun, recall
untuk kelas 1 adalah 77%, yang menunjukkan bahwa model sedikit lebih rendah
dalam mengidentifikasi dengan benar data dengan label 1. Keduanya masih
termasuk dalam kategori recall yang baik.
• Skor F1 untuk kedua kelas juga cukup baik, yaitu 0.92 untuk kelas 0 dan 0.80 untuk
kelas 1.
Secara keseluruhan, model masih memiliki kinerja yang baik, meskipun sedikit lebih
rendah dibandingkan dengan test set sebelumnya.
# Test set 0.1
from sklearn import metrics
import seaborn as sns
import matplotlib.pyplot as plt
y_pred = knn.predict(X_test_01)
cnf_matrix = metrics.confusion_matrix(y_test_01, y_pred)
p = sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap="YlGnBu",
fmt='g')
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')

print(classification_report(y_test_01, y_pred))

precision recall f1-score support

0 0.89 0.94 0.91 17

1 0.80 0.67 0.73 6

accuracy 0.87 23
macro avg 0.84 0.80 0.82 23
weighted avg 0.87 0.87 0.87 23

Penjelasan:
 • Model memiliki akurasi sebesar 87% pada test set 0.1.
• Presisi untuk kedua kelas adalah 89% untuk kelas 0 dan 80% untuk kelas 1. Ini
menunjukkan bahwa sebagian besar prediksi positif adalah benar.
• Recall untuk kelas 0 adalah 94%, yang menunjukkan kemampuan model dalam
mengidentifikasi dengan benar sebagian besar data dengan label 0. Namun, recall
untuk kelas 1 adalah 67%, yang menunjukkan bahwa model memiliki sedikit
kesulitan dalam mengidentifikasi dengan benar data dengan label 1. Keduanya
masih termasuk dalam kategori recall yang baik.
• Skor F1 untuk kedua kelas juga cukup baik, yaitu 0.91 untuk kelas 0 dan 0.73 untuk
kelas 1.
Meskipun kinerja model sedikit menurun dibandingkan dengan test set sebelumnya, model
masih mampu melakukan klasifikasi dengan baik.