LAPORAN

PRAKTIKUM
COMPUTER VISION

Oleh:

MUHAMMAD RIZKI
NIM 2022573010105
Kelas : TI / 3C
Program Studi : Teknik Informatika
Dosen Pengampu : Dr. Rahmad Hidayat, [Link]., [Link]

PROGRAM STUDI TEKNIK INFORMATIKA

JURUSAN TEKNOLOGI INFORMASI DAN KOMPUTER
POLITEKNIK NEGERI LHOKSEUMAWE

2025
1. Percobaan 1 Fitur Warna Support Vector Machines (SVM)

a. Program
1. Library yang Diimpor

import pandas as pd
import seaborn as sns
import [Link] as plt
from [Link] import SVC
from [Link] import accuracy_score, classification_report,
confusion_matrix
from sklearn.model_selection import train_test_split

● Explanation:
○ pandas as pd: Untuk membaca, memproses, dan memanipulasi data
tabular (DataFrame).
○ seaborn as sns & [Link] as plt: Untuk visualisasi data,
misalnya plotting distribusi kelas atau hasil confusion matrix.
○ [Link]: Kelas dari scikit-learn untuk membuat model
Support Vector Classifier (SVM).
○ [Link]: Untuk mengevaluasi performa model seperti:
■ Akurasi (accuracy_score)
■ Laporan klasifikasi (classification_report)
■ Confusion matrix (confusion_matrix)
○ train_test_split: Untuk membagi dataset ke dalam data latih dan uji.

2. Fungsi load_data()

CSV_PATH = r"[Link]"

def load_data():
df = pd.read_csv(CSV_PATH)

● Explanation:
○ Membaca file CSV menjadi DataFrame df.

3. Membaca file CSV menjadi DataFrame df.

X = df[["r_Mean", "g_Mean", "b_Mean", "r_HistMean",

"g_HistMean", "b_HistMean"]]
y = df["Actual"].astype(str)
return train_test_split(X, y, test_size=0.2, random_state=42),
X, y

1
● Explanation:
○ Menentukan fitur (fitur warna) untuk model.
○ Kolom X berisi nilai rata-rata RGB dan histogram RGB, jadi ini
adalah fitur representasi warna.
○ y adalah label kelas untuk klasifikasi.
○ Label dikonversi ke string (mungkin karena ada angka yang
sebenarnya adalah nama kelas).
○ Data dibagi menjadi 80% training dan 20% testing.
○ Fungsi mengembalikan hasil split, serta X dan y asli.

4. Menampilkan info dataset

def tampilkan_info_dataset():
df = pd.read_csv(CSV_PATH)
print("\n=== Informasi Dataset ===")
print([Link]())
print("\nContoh Data:")
print([Link]())

● Explanation:
○ Membaca file [Link] ke dalam DataFrame df.

5. Melatih model klasifikasi SVM

def train_svm(X_tr, X_te, y_tr, y_te):

model = SVC(kernel='linear', random_state=42).fit(X_tr, y_tr)
y_pred = [Link](X_te)
print(f"\n Akurasi: {accuracy_score(y_te, y_pred):.2%}")
print(classification_report(y_te, y_pred, zero_division=0))
return model, y_pred

● Explanation:
train_svm() digunakan untuk melatih model klasifikasi SVM dengan
data latih, lalu memprediksi data uji. Setelah itu, fungsi ini menampilkan
akurasi dan laporan performa model, lalu mengembalikan model dan hasil
prediksinya.

6. Melatih model klasifikasi SVM

def show_confusion_matrix(y_true, y_pred):

cm = confusion_matrix(y_true, y_pred)
labels = sorted(set(y_true) |
set(y_pred))
[Link](cm, annot=True, fmt='d', cmap='Blues',
xticklabels=labels, yticklabels=labels)
[Link]("Confusion Matrix"); [Link]("Predicted");
[Link]("Actual"); [Link]()
● Explanation:
show_confusion_matrix() digunakan untuk menampilkan confusion
matrix dalam bentuk visual menggunakan heatmap. Fungsi ini menerima label
asli dan prediksi, lalu menghitung confusion matrix-nya, mengurutkan label

2
 yang digunakan sebagai sumbu, dan menampilkannya dengan pewarnaan agar
lebih mudah dibaca.

7. Menampilkan visualisasi hubungan antar fitur

def show_pairplot(X, y):

df = [Link](); df["Actual"] = y
[Link](df, hue="Actual",
palette="Set2")
[Link]("Pairplot Fitur", y=1.02); [Link]()
● Explanation:
show_pairplot() digunakan untuk menampilkan visualisasi hubungan
antar fitur dalam bentuk pairplot. Data fitur X digabung dengan label y, lalu
divisualisasikan dengan warna berbeda untuk setiap kelas. Tujuannya biar
kelihatan pola atau pemisahan antar kelas berdasarkan fitur-fiturnya.

8. Menampilkan heatmap korelasi antar kolom

def show_heatmap(csv_path):
df = pd.read_csv(csv_path)
df_num = df.select_dtypes(include='number')
[Link](figsize=(14, 10))
[Link](df_num.corr(), annot=True, cmap='coolwarm')
[Link]("Heatmap Korelasi Semua Kolom Numerik")
[Link]()

● Explanation:
show_heatmap() digunakan untuk menampilkan heatmap korelasi
antar kolom numerik dalam dataset. Data dibaca dari file CSV, lalu hanya
kolom angka yang dipilih. Korelasinya dihitung dan divisualisasikan pakai
heatmap biar kelihatan hubungan antar fitur.

9. Menampilkan heatmap korelasi antar kolom

def menu():
(X_tr, X_te, y_tr, y_te), X, y_all = load_data()
model = y_pred = None

while True:
print("\n=== MENU SVM ===")
print("1. Tampilkan Informasi Dataset")
print("2. Latih Model")
print("3. Confusion Matrix")
print("4. Pairplot")
print("5. Heatmap")
print("6. Keluar")

p = input("Pilih (1-6): ")

if p == "1":
tampilkan_info_dataset()
elif p == "2":
model, y_pred = train_svm(X_tr, X_te, y_tr, y_te)
elif p == "3":

3
 show_confusion_matrix(y_te, y_pred) if y_pred is not
None else print(" Jalankan model dulu.")
elif p == "4":
show_pairplot(X, y_all)
elif p == "5":
show_heatmap(CSV_PATH)
elif p == "6":
print("Keluar."); break
else:
print(" Pilihan tidak valid.")

if name == " main ":

menu()

● Explanation:
Fungsi menu() berfungsi sebagai antarmuka utama program yang
memungkinkan pengguna memilih berbagai fitur yang tersedia. Di awal
fungsi, data dibagi menjadi data latih dan data uji melalui load_data(), lalu
disiapkan variabel model dan y_pred sebagai penampung hasil pelatihan dan
prediksi. Selanjutnya, program masuk ke dalam perulangan while yang
menampilkan daftar menu mulai dari menampilkan informasi dataset, melatih
model SVM, menampilkan confusion matrix, visualisasi pairplot, hingga
heatmap korelasi antar fitur numerik. Setiap pilihan dijalankan sesuai dengan
input pengguna, dan program akan terus berjalan sampai pengguna memilih
keluar dengan memilih opsi nomor enam. Jika input yang dimasukkan tidak
sesuai, maka akan ditampilkan pesan bahwa pilihan tidak valid.

b. Output

1. Informasi Dataset

4
● Explanation:

Output tersebut adalah rangkuman dari sebuah tabel data (DataFrame)

yang berisi 39 baris dan 18 kolom, dengan kondisi data yang sangat baik
karena tidak ada nilai yang hilang sama sekali. Tabel ini bertujuan untuk
mengevaluasi performa sebuah model dengan membandingkan nilai Actual
(kategori asli) dengan nilai Predicted (tebakan model) berdasarkan 15 fitur
input, yang kemungkinan merupakan statistik warna dari gambar. Namun,
analisis kritis pada data contoh menunjukkan adanya kesalahan fatal: sebuah
prediksi yang salah (di mana Actual adalah 0 dan Predicted adalah 1) secara
keliru ditandai pada kolom Correct sebagai True, yang mengindikasikan
adanya kesalahan logika pada kode evaluasi dan dapat membuat perhitungan
akurasi keseluruhan menjadi tidak akurat.

2. Latih Model

● Explanation:

Performa model klasifikasi SVM ini menunjukkan akurasi keseluruhan

sebesar 87.50%. Artinya, model berhasil menebak 8 dari 8 data uji dengan
benar. Rincian performanya menunjukkan bahwa model memiliki
karakteristik yang berbeda untuk setiap kelas. Untuk kelas 1, model memiliki

5
 presisi (precision) sempurna (1.00), yang berarti setiap kali model menebak
"kelas 1", tebakannya itu pasti benar. Namun, daya ingatnya (recall) hanya
0.80, artinya model gagal menemukan 20% dari total data yang seharusnya
masuk ke kelas 1. Sebaliknya, untuk kelas 0, model memiliki recall
sempurna (1.00), berhasil mengidentifikasi semua data yang memang kelas
0. Akan tetapi, presisinya lebih rendah (0.75), menunjukkan bahwa
terkadang model salah menebak data lain sebagai kelas 0. Kolom support
menunjukkan jumlah data asli untuk setiap kelas (3 untuk kelas 0, dan 5
untuk kelas 1). Karena jumlah data tidak seimbang, weighted avg (rata-rata
terbobot) menjadi acuan yang baik, dengan F1-score 0.88, yang menandakan
performa model secara keseluruhan sangat solid. Singkatnya, model ini
sangat andal saat memprediksi kelas 1, namun cenderung sedikit "terlalu
bersemangat" dalam mengidentifikasi kelas 0 sehingga terkadang
melewatkan beberapa data dari kelas 1.

3. Confusion Matrix

● Explanation:

Sumbu Y (Actual): Menunjukkan kelas yang sebenarnya.

Sumbu X (Predicted): Menunjukkan kelas yang ditebak oleh model.

Setiap kotak dalam matriks menunjukkan jumlah data untuk kombinasi

prediksi dan aktual tertentu:

● Kiri Atas (True Negative = 3): Model dengan benar memprediksi 3

data sebagai kelas 0.
● Kanan Bawah (True Positive = 4): Model dengan benar memprediksi 4
data sebagai kelas 1.
● Kanan Atas (False Positive = 0): Model tidak pernah salah menebak
kelas 0 sebagai kelas 1. Ini adalah hasil yang sangat baik.
● Kiri Bawah (False Negative = 1): Model membuat 1 kesalahan dengan
menebak data yang seharusnya kelas 1 sebagai kelas 0.

6
 Secara keseluruhan, model ini memiliki performa yang baik. Dari total 8
data (3+0+1+4), model hanya membuat satu kesalahan, yaitu gagal
mengidentifikasi satu data dari kelas 1. Model ini sangat akurat dalam
memprediksi kelas 0 dan tidak pernah membuat kesalahan "False positif".

4. Pairplot

● Explanation:

Grafik ini membandingkan beberapa fitur dari dataset Anda (seperti

r_Mean, g_Mean, dll.) dan membedakan datanya berdasarkan kelas Actual
(kelas 0 berwarna oranye dan kelas 1 berwarna hijau toska).

Grafik ini terdiri dari dua jenis plot:

1. Plot di Garis Diagonal (Plot Kepadatan) Plot yang membentang dari
kiri atas ke kanan bawah adalah plot kepadatan (density plot). Grafik
ini menunjukkan distribusi atau sebaran data untuk satu variabel saja.

● Contoh: Lihat plot di pojok kiri atas untuk variabel r_Mean.

Terlihat jelas bahwa distribusi untuk kelas 0 (oranye) dan kelas
1 (hijau tosca) memiliki puncak di lokasi yang berbeda. Ini
adalah pertanda yang sangat baik, artinya fitur r_Mean ini
kemungkinan besar berguna untuk membedakan kedua kelas.
Hal yang sama berlaku untuk g_Mean dan b_Mean.

2. Plot di Luar Diagonal (Plot Tebar) Semua plot lainnya adalah plot
tebar (scatter plot). Grafik ini menunjukkan hubungan antara dua
variabel yang berbeda.

● Contoh: Lihat plot pada baris pertama, kolom kedua. Ini

membandingkan g_Mean (sumbu x) dengan r_Mean (sumbu
y). Terlihat bahwa titik-titik data untuk kelas 0 dan kelas
1

7
 membentuk dua kelompok yang cukup terpisah. Ini memperkuat
bahwa kombinasi fitur-fitur ini efektif untuk klasifikasi.

5. Heatmap

● Explanation:

Interpretasi visual didasarkan pada skala warna, dimana warna merah

intens (mendekati +1.0) merepresentasikan korelasi positif yang kuat, warna
biru intens (mendekati -1.0) merepresentasikan korelasi negatif yang kuat, dan
warna netral (mendekati 0) menandakan korelasi yang lemah atau tidak ada.

Dari analisis heatmap, diperoleh beberapa temuan kunci sebagai berikut:

1. Indikasi Multikolinearitas: Teridentifikasi adanya korelasi positif yang

sangat tinggi (r > 0.9) di antara beberapa kelompok fitur. Kelompok
fitur Color Coherence Vector (r_CCV, g_CCV, b_CCV) dan Mean
(r_Mean, g_Mean, b_Mean) menunjukkan dependensi yang kuat satu
sama lain. Fenomena serupa juga teramati pada kelompok fitur
Skewness (r_Skew, g_Skew, b_Skew). Tingginya korelasi ini
mengindikasikan adanya redundansi informasi, yang menjadi
pertimbangan penting dalam tahap seleksi fitur untuk menghindari
multikolinearitas pada model.
2. Korelasi dengan Variabel Target: Analisis terhadap variabel Actual
menunjukkan bahwa beberapa fitur memiliki nilai prediktif yang
signifikan. Fitur r_Skew dan g_Skew memiliki korelasi positif terkuat
(r ≈ 0.7), sementara fitur-fitur seperti r_CCV dan b_Mean
menunjukkan korelasi negatif terkuat (r ≈ -0.74). Fitur-fitur dengan
nilai absolut koefisien korelasi yang tinggi ini merupakan kandidat
utama untuk digunakan dalam pemodelan karena memiliki pengaruh
paling signifikan terhadap kelas target.

8
 3. Anomali Data: Perlu dicatat bahwa nilai korelasi untuk fitur
r_HistMean, g_HistMean, dan b_HistMean tidak dapat dihitung dan
tidak ditampilkan pada heatmap. Hal ini mengindikasikan adanya
kemungkinan masalah pada data tersebut, seperti tipe data
non-numerik atau terdapat nilai yang hilang (missing values).

Secara keseluruhan, analisis korelasi ini memberikan landasan kuantitatif untuk

proses seleksi fitur, memungkinkan identifikasi variabel yang paling relevan
dan pengelolaan variabel yang redundan untuk optimasi model.

2. Percobaan 2 Fitur Warna menjadi Decision Tree

a. Program

1. Import Library

import pandas as pd
import seaborn as sns
import [Link] as plt
from [Link] import DecisionTreeClassifier, plot_tree
from [Link] import accuracy_score,
classification_report, confusion_matrix
from sklearn.model_selection import train_test_split,
cross_val_score

● Explanation:
Baris kode tersebut berisi import library yang dibutuhkan untuk
program klasifikasi menggunakan Decision Tree. pandas digunakan untuk
membaca dan mengolah data, seaborn dan matplotlib digunakan untuk
visualisasi, sedangkan sklearn menyediakan tools untuk membangun, melatih,
mengevaluasi model Decision Tree, serta melakukan split data dan
cross-validation.

2. Mendefinisikan variabel global

CSV_PATH = r"[Link]"

model_default = model_opt = None

X_train = X_test = y_train = y_test = None
y_pred_default = y_pred_opt = None

● Explanation:
Mendefinisikan variabel global yang akan digunakan dalam program.
CSV_PATH menyimpan lokasi file dataset. Variabel model_default dan
model_opt disiapkan untuk menyimpan model decision tree versi default dan
versi yang sudah dioptimasi. Sementara itu, X_train, X_test, y_train, dan
y_test adalah variabel untuk menyimpan data latih dan uji. Terakhir,
y_pred_default dan y_pred_opt akan menyimpan hasil prediksi dari
masing-masing model.

9
3. Fungsi load_data()
def load_data():
df = pd.read_csv(CSV_PATH)
X = [Link](columns=["Actual", "Predicted", "Correct"],
errors='ignore')
y = df["Actual"]
return train_test_split(X, y, test_size=0.2,
random_state=42), X

● Explanation:
Fungsi load_data() digunakan untuk membaca dataset dari file CSV,
memisahkan fitur (X) dan label target (y), lalu membagi data menjadi data
latih dan data uji. Kolom seperti "Actual", "Predicted", dan "Correct" akan
di-drop dari fitur jika ada, untuk memastikan hanya fitur yang relevan yang
digunakan. Fungsi ini mengembalikan hasil pembagian data (train_test_split)
serta seluruh data fitur (X) untuk keperluan visualisasi atau analisis tambahan.

4. Fungsi train_decision_tree()
def train_decision_tree(X_train, X_test, y_train, y_test,
max_depth=None):
model = DecisionTreeClassifier(max_depth=max_depth,
random_state=42)
[Link](X_train, y_train)
y_pred = [Link](X_test)
acc = accuracy_score(y_test, y_pred)
report = classification_report(y_test, y_pred,
target_names=["dino", "kuda"])
print(f"\n Akurasi Model Decision Tree{' (Optimal)' if
max_depth else ''}: {acc:.2%}")
print(report)
return model,
y_pred
● Explanation:
Fungsi train_decision_tree() digunakan untuk melatih model Decision
Tree menggunakan data latih dan menguji akurasinya pada data uji. Parameter
max_depth bisa diisi untuk mengatur kedalaman maksimal pohon; jika tidak
diisi, maka model menggunakan pengaturan default (tidak terbatas). Model
dilatih dengan fit(), lalu digunakan untuk memprediksi label data uji. Akurasi
dihitung, dan laporan klasifikasi ditampilkan dengan label target yang di-set
sebagai “dino” dan “kuda”. Fungsi ini mengembalikan model yang sudah
dilatih dan hasil prediksinya.

5. Fungsi visualisasi_confusion_matrix()
def visualisasi_confusion_matrix(y_test, y_pred):
cm = confusion_matrix(y_test, y_pred)
[Link](cm, annot=True, fmt='d', cmap='Blues',
xticklabels=["dino", "kuda"],
yticklabels=["dino", "kuda"])
[Link]("Confusion Matrix - Decision Tree")
[Link]("Predicted")
[Link]("Actual")
[Link]()

10
● Explanation:
Fungsi visualisasi_confusion_matrix() digunakan untuk menampilkan
confusion matrix dari hasil prediksi model Decision Tree dalam bentuk visual
heatmap. Confusion matrix dihitung dari label asli (y_test) dan hasil prediksi
(y_pred), lalu divisualisasikan menggunakan seaborn dengan pewarnaan biru.
Sumbu X menunjukkan label prediksi, sedangkan sumbu Y menunjukkan
label asli. Fungsi ini membantu melihat sejauh mana model benar atau salah
dalam mengklasifikasi masing-masing kelas, yaitu "dino" dan "kuda".

6. Fungsi visualisasi_pohon()
def visualisasi_pohon(model, X, title):
[Link](figsize=(12,6))
plot_tree(model, feature_names=[Link],
class_names=["dino", "kuda"],
filled=True) [Link](title)
[Link]()

● Explanation:
Fungsi visualisasi_pohon() digunakan untuk menampilkan struktur
pohon keputusan (Decision Tree) yang telah dilatih. Model pohon
divisualisasikan menggunakan plot_tree() dari sklearn, dengan nama fitur
diambil dari kolom X dan label kelas ditampilkan sebagai “dino” dan “kuda”.
Judul plot disesuaikan dengan parameter title. Visualisasi ini membantu
memahami bagaimana model membuat keputusan berdasarkan fitur yang
diberikan.

7. Fungsi find_optimal_depth()
def find_optimal_depth(X_train, y_train):
print("\n Mencari kedalaman terbaik untuk
pohon
keputusan...")
depths = range(3, 15)
scores = []
for depth in depths:
tree =
DecisionTreeClassifier(max_depth=depth,
random_state=42)
cv_scores = cross_val_score(tree, X_train, y_train,
cv=5)
[Link](cv_scores.mean())
optimal_depth = depths[[Link](max(scores))]
print(f"Kedalaman optimal ditemukan: {optimal_depth} dengan
akurasi rata-rata: {max(scores):.2%}")
● Explanation:
Fungsi find_optimal_depth() digunakan untuk mencari kedalaman
(depth) terbaik dari model Decision Tree dengan cara menguji berbagai nilai
depth menggunakan cross-validation. Fungsi ini mencoba kedalaman dari 3
hingga 14, lalu menghitung rata-rata akurasi dari 5-fold cross-validation untuk
setiap kedalaman. Nilai depth dengan akurasi tertinggi dianggap sebagai yang
optimal. Hasilnya ditampilkan di terminal dan dikembalikan untuk digunakan
saat melatih model yang dioptimasi.

11
8. Fungsi find_optimal_depth()
def menu():
global model_default, model_opt, y_pred_default, y_pred_opt
global X_train, X_test, y_train, y_test

(X_train, X_test, y_train, y_test), X_all = load_data()

while True:
print("\n=== MENU UTAMA ===")
print("1. Latih Model Decision Tree")
print("2. Visualisasi Confusion Matrix")
print("3. Visualisasi decision awal")
print("4. Visualisasi decision optimasi")
print("5. Keluar")
pilihan = input("Pilih menu (1-5): ")

if pilihan == "1":
model_default, y_pred_default =
train_decision_tree(X_train, X_test, y_train, y_test)
elif pilihan == "2":
if y_pred_default is not None:
visualisasi_confusion_matrix(y_test,
y_pred_default)
else:
print(" Jalankan pelatihan model dulu.")
elif pilihan == "3":
if model_default:
visualisasi_pohon(model_default, X_all,
"Pohon
Keputusan (Default)")
else:
print(" Jalankan pelatihan model dulu.")
elif pilihan == "4":
optimal_depth = find_optimal_depth(X_train,
y_train)
model_opt, y_pred_opt =
train_decision_tree(X_train, X_test, y_train, y_test,

max_depth=optimal_depth)
visualisasi_pohon(model_opt, X_all,
f"Pohon Keputusan (Optimal -
max_depth={optimal_depth})")
elif pilihan == "5":
print("Keluar dari program.")
break
else:
print(" Pilihan tidak valid.")

if name == " main ":

menu()

● Explanation:
Fungsi menu() ini bertindak sebagai “dashboard” interaktif untuk
seluruh pipeline Decision Tree‐mu. Begitu fungsi dipanggil, ia memuat
dataset lewat load_data()—hasilnya langsung dipecah menjadi data latih dan
data uji, lalu disimpan di variabel global agar bisa diakses di sepanjang
program. Di dalam loop tak terbatas, program menampilkan lima opsi. Opsi
pertama menjalankan pelatihan Decision Tree standar; model yang
dihasilkan
12
 beserta prediksinya disimpan di model_default dan y_pred_default. Opsi
kedua menampilkan confusion matrix, tetapi hanya akan dieksekusi bila
model default sudah ada—kalau belum, pengguna diingatkan untuk melatih
model lebih dulu. Opsi ketiga menggambar struktur pohon dari model default,
lagi-lagi dengan pengecekan yang sama supaya tidak memanggil objek
kosong. Opsi keempat melakukan tuning sederhana: ia mencari kedalaman
pohon terbaik memakai cross-validation lima lipatan lewat
find_optimal_depth(), melatih ulang pohon dengan kedalaman tersebut, lalu
memvisualisasikannya. Opsi kelima keluar dari aplikasi dan memecah loop.

b. Output

1. Latih Model Decision Tree

● Explanation:

Tabel Akurasi Model Decision Tree menyajikan ringkasan matrik evaluasi

kinerja untuk model klasifikasi Decision Tree. Metrik ini dihitung berdasarkan
hasil prediksi model pada data uji untuk mengukur efektivitasnya dalam
membedakan antara kelas dino dan kuda. Secara keseluruhan, model ini
mencapai tingkat akurasi (accuracy) sebesar 87.50%.

Analisis terperinci untuk setiap kelas menunjukkan performa sebagai berikut:

1. Kinerja pada Kelas kuda: Model menunjukkan presisi (precision)

sempurna (1.00), yang mengindikasikan bahwa setiap sampel yang
diprediksi sebagai 'kuda' adalah prediksi yang benar. Namun, nilai
daya ingat (recall) sebesar 0.80 menunjukkan bahwa model hanya
berhasil mengidentifikasi 80% dari total sampel 'kuda' yang
sebenarnya, dan melewatkan 20% sisanya.
2. Kinerja pada Kelas dino: Untuk kelas ini, model mencapai recall
sempurna (1.00), artinya seluruh sampel 'dino' yang ada pada data
uji berhasil ditemukan oleh model. Akan tetapi, nilai presisi yang
lebih rendah (0.75) menandakan bahwa dari semua sampel yang
diprediksi

13
 sebagai 'dino', hanya 75% yang benar, sementara sisanya merupakan
kesalahan klasifikasi dari kelas lain.

Kolom support menunjukkan distribusi data aktual pada set pengujian, yaitu
sebanyak 3 sampel untuk kelas dino dan 5 sampel untuk kelas kuda.
Mengingat adanya ketidakseimbangan jumlah sampel ini, metrik rata-rata
terbobot (weighted average) F1-Score sebesar 0.88 menjadi indikator
performa gabungan yang paling representatif.

2. Visualisasi Confusion Matrix

● Explanation:

Sumbu Y (Actual): Menunjukkan kelas yang sebenarnya.

Sumbu X (Predicted): Menunjukkan kelas yang ditebak oleh model.

Setiap kotak dalam matriks menunjukkan jumlah data untuk kombinasi prediksi
dan aktual tertentu:

● Kiri Atas (True Negative = 3): Model dengan benar memprediksi 3

data sebagai kelas 0.
● Kanan Bawah (True Positive = 4): Model dengan benar memprediksi 4
data sebagai kelas 1.
● Kanan Atas (False Positive = 0): Model tidak pernah salah menebak
kelas 0 sebagai kelas 1. Ini adalah hasil yang sangat baik.
● Kiri Bawah (False Negative = 1): Model membuat 1 kesalahan dengan
menebak data yang seharusnya kelas 1 sebagai kelas 0.

Secara keseluruhan, model ini memiliki performa yang baik. Dari total 8 data
(3+0+1+4), model hanya membuat satu kesalahan, yaitu gagal

14
 mengidentifikasi satu data dari kelas 1. Model ini sangat akurat dalam
memprediksi kelas 0 dan tidak pernah membuat kesalahan "False positif".

3. Visualisasi decision awal

● Explanation:
Model ini bekerja dengan cara membuat serangkaian pertanyaan "ya/tidak"
(True/False) secara bertahap untuk mengklasifikasikan data ke dalam kategori
tertentu, dalam kasus ini antara kelas dino dan kuda.

Setiap kotak pada diagram disebut node. Ada dua jenis node utama:

● Node Keputusan: Kotak yang memiliki "pertanyaan" atau aturan dan

bercabang menjadi dua.
● Node Daun (Leaf Node): Kotak di ujung cabang yang memberikan
hasil klasifikasi akhir.

Setiap node berisi informasi berikut:

1. Aturan Keputusan: Pertanyaan yang diajukan tentang sebuah fitur

(contoh: g_Skew <= -0.875).
2. Gini: Metrik "ketidakmurnian" (impurity). Nilai Gini = 0.0 berarti
node tersebut murni, artinya semua data di dalamnya hanya milik satu
kelas. Semakin mendekati 0.5, semakin tercampur datanya.
3. Samples: Jumlah sampel data yang sampai pada node tersebut.
4. Value: Distribusi sampel di setiap kelas. Contoh value = [17, 14]
berarti ada 17 sampel kelas dino dan 14 sampel kelas kuda.
5. Class: Kelas mayoritas pada node tersebut, yang menjadi prediksi di
titik itu.

Model ini bekerja dari atas ke bawah. Mari kita ikuti satu contoh alur ke kiri:
1. Node Akar (Paling Atas): Sebuah data baru masuk. Model bertanya:
"Apakah nilai g_Skew data ini lebih kecil atau sama dengan -0.875?"

15
 2. Jalur "True": Jika jawabannya Ya (True), data akan dikirim ke node di
sebelah kiri.
3. Node Kedua: Di sini, model bertanya lagi: "Apakah nilai r_CCV lebih
kecil atau sama dengan 92219.5?"
4. Jalur "True": Jika jawabannya Ya (True), data akan dikirim ke node
daun di paling kiri.
5. Node Daun (Hasil Akhir): Node ini berisi 15 sampel, yang semuanya
adalah kelas dino (value = [15, 0]). Karena node ini sudah murni (Gini
= 0.0), maka model dengan yakin memutuskan bahwa data tersebut
termasuk dalam kelas dino.

4. Visualisasi decision optimasi

● Explanation:

1. Penentuan Kedalaman Optimal (Hyperparameter Tuning)

Langkah pertama dalam proses ini adalah mencari kedalaman maksimum

(max_depth) yang paling efektif untuk pohon keputusan. Teks pada gambar
pertama, "Mencari kedalaman terbaik...", mengindikasikan bahwa
sebuah

16
 proses pencarian, kemungkinan menggunakan validasi silang
(cross-validation), telah dilakukan. Hasil dari proses ini adalah:

● Kedalaman Optimal Ditemukan: max_depth = 3.

● Akurasi Rata-rata Validasi: 60.95%.

Nilai ini menunjukkan bahwa dari berbagai kedalaman yang diuji, kedalaman
3 memberikan performa rata-rata terbaik selama fase validasi. Proses ini
bertujuan untuk menemukan keseimbangan antara model yang terlalu
sederhana (underfitting) dan terlalu kompleks (overfitting).

2. Kinerja dan Visualisasi Model Optimal

Setelah kedalaman optimal ditemukan, sebuah model Decision Tree final

dibangun dengan menggunakan max_depth=3.

● Visualisasi Model: Gambar kedua menampilkan struktur "Pohon

Keputusan (Optimal - max_depth=3)". Visualisasi ini secara eksplisit
menunjukkan bahwa pohon tersebut tidak memiliki cabang yang
melebihi tiga tingkat kedalaman, sesuai dengan hasil optimisasi. Ini
menciptakan model yang lebih sederhana dan lebih mudah
diinterpretasikan.
● Evaluasi Kinerja Akhir: Model optimal ini kemudian diuji pada set
data pengujian (test set) yang terpisah, dan hasilnya dirangkum dalam
laporan klasifikasi. Model ini mencapai akurasi akhir sebesar 87.50%,
yang secara signifikan lebih tinggi dari akurasi rata-rata pada fase
validasi. Laporan klasifikasi menunjukkan bahwa model ini memiliki
performa yang kuat, dengan F1-score rata-rata terbobot (weighted avg)
sebesar 0.88.

Secara keseluruhan, output ini mendemonstrasikan alur kerja standar dalam

machine learning: melakukan tuning untuk menemukan hyperparameter
terbaik (max_depth=3), kemudian melatih model final dengan parameter
tersebut untuk menghasilkan model yang tidak hanya berkinerja tinggi
(akurasi 87.50%) tetapi juga terkontrol kompleksitasnya.

c. Perbandingan Percobaan 1 dan Percobaan 2

Percobaan 1 mengklasifikasikan data berdasarkan atribut warna dengan

menggunakan metode Support Vector Machine (SVM). Hasilnya menunjukkan
akurasi sebesar 87,5%. Model ini mampu mengklasifikasikan semua data kelas 0
dengan benar, kecuali satu data kelas 1 yang salah diklasifikasikan menjadi kelas 0,
dan akurasi kelas 1 mencapai 100% dan recall 80%, yang menunjukkan bahwa semua
prediksi positif sangat akurat, meskipun ada satu sampel yang tidak ditemukan.
Percobaan 2 juga menggunakan metode Decision Tree dengan data yang sama.
Selain

17
 itu, model ini menunjukkan kinerja yang baik dengan hanya satu kesalahan klasifikasi
untuk data kelas "dino" dan semua data kelas "kuda" diklasifikasikan dengan
[Link] terdapat kesalahan Tipe I (false positive), hanya satu kesalahan Tipe II
(false negative). Secara keseluruhan, meskipun kedua model bekerja dengan baik,
SVM lebih unggul dalam precision, sedangkan Decision Tree menunjukkan kekuatan
dalam menghindari prediksi salah untuk kelas negatif.

3. Percobaan 3 Tekstur menjadi SVM

a. Program

1. Import Library
import os
import pandas as pd
import seaborn as sns
import [Link] as plt
from sklearn.model_selection import train_test_split
from [Link] import LabelEncoder,StandardScaler
from [Link] import SVC
from [Link] import
accuracy_score,classification_report, confusion_matrix

● Explanation:
Import menyiapkan semua pustaka yang dibutuhkan untuk proyek
klasifikasi SVM. os dipakai untuk urusan sistem file, pandas untuk membaca
dan mengolah data tabular, sedangkan seaborn dan [Link]
membantu membuat visualisasi grafik. train_test_split membagi data menjadi
latih dan uji, LabelEncoder mengubah label kategorikal menjadi angka, dan
StandardScaler menstandarkan skala fitur numerik. SVC adalah algoritma
Support Vector Machine yang akan dilatih, lalu kinerja model diukur
memakai accuracy_score, classification_report, dan confusion_matrix.

2. Mendefinisikan variabel global

CSV_PATH = r"[Link]"

data = None
numeric_cols = None
X = y = None
X_tr = X_te = y_tr = y_te = None
svm_clf = None

● Explanation:
Mendefinisikan variabel-variabel global yang akan dipakai dalam
program klasifikasi. CSV_PATH menyimpan lokasi file dataset bernama
[Link]. Variabel data akan menampung isi dataset, numeric_cols untuk
menyimpan kolom-kolom numerik yang dipilih. X dan y masing-masing
mewakili fitur dan label target. X_tr, X_te, y_tr, dan y_te akan digunakan

18
 untuk menyimpan data hasil pembagian train-test. Terakhir, svm_clf disiapkan
sebagai penampung model Support Vector Machine setelah dilatih.
3. Fungsi show_info()
def show_info():
print("\n=== Informasi Dataset ===")
print([Link]())
print("\nContoh Data:")
print([Link]())

● Explanation:
Fungsi show_info() digunakan untuk menampilkan informasi umum
tentang dataset. Fungsi ini mencetak struktur data seperti jumlah kolom, tipe
data, dan apakah ada data kosong melalui [Link](), lalu menampilkan 5
baris pertama dari dataset dengan [Link]() agar pengguna bisa melihat
contoh isi datanya.

4. Fungsi train_svm()
def train_svm():
global numeric_cols, X, y, X_tr, X_te, y_tr, y_te,
svm_clf if 'label' not in [Link]:
print("[ERROR] Kolom 'label' tidak ada."); return

numeric_cols = [c for c in
data.select_dtypes(include=['int64', 'float64']).columns if c
!= 'label']
if not numeric_cols:
print("[ERROR] Tidak ada kolom numerik untuk fitur.");
return

X = data[numeric_cols].values
y = LabelEncoder().fit_transform(data['label'])

X_tr, X_te, y_tr, y_te = train_test_split(X, y,

test_size=0.25, random_state=42, stratify=y)
scaler = StandardScaler(); X_tr =
scaler.fit_transform(X_tr); X_te = [Link](X_te)

svm_clf = SVC(kernel='linear', random_state=42)

svm_clf.fit(X_tr, y_tr)

preds = svm_clf.predict(X_te)
print("\n=== Evaluasi SVM ===")
print("Accuracy :", accuracy_score(y_te, preds))
print(classification_report(y_te, preds, zero_division=0))
cm = confusion_matrix(y_te, preds)
[Link](cm, annot=True, cmap='Blues', fmt='d')
[Link]('Confusion Matrix'); [Link]('Predicted');
[Link]('Actual'); [Link]()

● Explanation:
Fungsi train_svm() digunakan untuk melatih model klasifikasi SVM
menggunakan data dari dataset yang sudah dimuat sebelumnya. Pertama,
fungsi ini memastikan bahwa kolom 'label' ada dalam data karena itu yang

19
 digunakan sebagai target. Lalu, fungsi mencari kolom-kolom numerik yang
akan dipakai sebagai fitur, dan mengecek apakah ada. Jika semuanya aman,
data fitur (X) dan label (y) diambil, label dikodekan ke angka menggunakan
LabelEncoder.

Setelah itu, data dibagi menjadi data latih dan uji dengan train_test_split, lalu
fitur dinormalisasi menggunakan StandardScaler agar model bekerja lebih
optimal. Model SVM dengan kernel linear dibuat dan dilatih menggunakan
data latih. Setelah pelatihan, model digunakan untuk memprediksi data uji.
Terakhir, fungsi ini menampilkan akurasi, laporan klasifikasi lengkap, dan
confusion matrix dalam bentuk heatmap untuk memudahkan interpretasi hasil.

5. Fungsi pairplot()
def pairplot():
try:
subset = numeric_cols[:3] + ['label']
[Link](data[subset], hue='label',palette='husl')
[Link]("Pairplot GLCM", y=1.02)
[Link]()
except Exception as e:
print("[WARN] Gagal pairplot:", e)

● Explanation:
Fungsi pairplot() digunakan untuk menampilkan visualisasi hubungan
antar beberapa fitur numerik pertama dari dataset menggunakan diagram sebar
(scatter plot) berpasangan. Fungsi ini mengambil 3 fitur numerik pertama dari
numeric_cols, lalu menambahkan kolom 'label' untuk digunakan sebagai
pewarna (hue) berdasarkan kelas.

Visualisasi dibuat menggunakan [Link]() dari seaborn, dengan

palet warna 'husl' agar tiap label punya warna berbeda. Judul grafik juga
ditambahkan di atas plot. Jika terjadi kesalahan—misalnya kolom tidak
ditemukan atau data belum dimuat—fungsi akan menangkap error dan
menampilkannya sebagai peringatan, bukan membuat program berhenti.

6. Fungsi heatmap()
def heatmap():
try:
corr = data[numeric_cols].corr()
[Link](figsize=(14, 12))
[Link](corr, cmap='coolwarm',
annot=True) [Link]('Heatmap Korelasi
GLCM')
[Link]()
except Exception as e:
print("[WARN] Gagal heatmap:", e)
actions = {
'1': show_info,
'2': train_svm,
'3': pairplot,
'4': heatmap
}

20
● Explanation:
Fungsi heatmap() digunakan untuk menampilkan visualisasi korelasi
antar fitur numerik dalam dataset menggunakan heatmap. Korelasi dihitung
dari kolom-kolom yang tersimpan di numeric_cols, lalu divisualisasikan
menggunakan [Link]() dengan palet warna 'coolwarm' dan anotasi nilai
korelasi di dalam tiap sel. Jika ada kesalahan saat proses (misalnya data belum
dimuat atau numeric_cols kosong), maka error akan ditangkap dan
ditampilkan dalam bentuk pesan peringatan.

Variabel actions berisi dictionary yang memetakan input string

(misalnya '1', '2', dst.) ke fungsi yang sesuai. Ini biasanya dipakai untuk
menjalankan fungsi secara dinamis dalam menu interaktif.

7. Fungsi heatmap()
def main():
global data
if not [Link](CSV_PATH):
print("[ERROR] File CSV tidak ditemukan di
path:", CSV_PATH)
return

data = pd.read_csv(CSV_PATH)

while True:
print("\n=== MENU SVM TEKSTUR ===")
print("1. Informasi Dataset")
print("2. Model SVM (Latih & Evaluasi)")
print("3. Visualisasi Pairplot")
print("4. Visualisasi Heatmap Korelasi")
print("5. Keluar")
choice = input("Pilih [1-5]: ").strip()
if choice == '5':
print("[INFO] Program selesai."); break
act = [Link](choice)
act() if act else print('[WARN] Pilihan tidak
valid')

if name == ' main ':

main()

● Explanation:
Fungsi main() adalah fungsi utama yang menjalankan program
klasifikasi tekstur menggunakan SVM. Di awal, fungsi ini mengecek apakah
file CSV ([Link]) tersedia. Kalau tidak ada, program langsung berhenti
dan memberi pesan error. Jika file ditemukan, data dibaca ke dalam variabel
data.

Selanjutnya, program masuk ke dalam loop menu interaktif yang terus

berjalan sampai pengguna memilih keluar. Menu menyediakan lima pilihan:
menampilkan informasi dataset, melatih dan mengevaluasi model SVM,
menampilkan pairplot antar fitur, menampilkan heatmap korelasi antar fitur
numerik, dan keluar dari program. Input user diproses, lalu fungsi yang
sesuai

21
 dijalankan melalui dictionary actions. Jika input tidak valid, akan muncul
peringatan.

Program akan terus meminta input sampai user memilih opsi 5 untuk keluar.

b. Output
1. Informasi Dataset

22
● Explanation:

Deskripsi dan Karakteristik Dataset

Dataset yang digunakan dalam penelitian ini terdiri dari 200 sampel data
dengan total 25 kolom, yang disajikan dalam format DataFrame dari pustaka
pandas. Dataset ini dirancang untuk tugas klasifikasi, di mana 24 kolom
berfungsi sebagai fitur prediktif dan satu kolom sebagai label target.

1. Struktur dan Kualitas Data

Berdasarkan analisis informasi dataset, dapat disimpulkan beberapa hal

berikut:

● Dimensi: Dataset memiliki 200 baris (entri) dan 25 kolom.

● Kualitas Data: Seluruh kolom menunjukkan 200 non-null, yang
mengindikasikan bahwa tidak terdapat data yang hilang (missing
values) sama sekali. Hal ini menunjukkan kualitas data yang sangat
baik dan siap digunakan tanpa memerlukan proses imputasi.
● Tipe Data: Terdapat 24 kolom fitur dengan tipe data numerik desimal
(float64) dan satu kolom target (label) dengan tipe data numerik bulat
(int64).

2. Rincian Fitur dan Variabel Target

● Fitur (Atribut): Ke-24 kolom fitur merupakan hasil ekstraksi ciri

tekstur dari Gray-Level Co-occurrence Matrix (GLCM). Fitur-fitur ini
terdiri dari 6 properti tekstur utama, yaitu:
○ dissimilarity
○ correlation
○ homogeneity
○ contrast
○ ASM (Angular Second Moment)
○ energy
● Setiap properti dihitung pada empat arah sudut yang berbeda (0°, 45°,
90°, dan 135°) untuk menangkap karakteristik tekstur dari berbagai
orientasi.
● Variabel Target (label): Kolom terakhir bernama label berfungsi
sebagai variabel dependen atau kelas yang akan diprediksi oleh model.

Secara keseluruhan, dataset ini lengkap dan terstruktur dengan baik,

menyediakan fitur-fitur tekstur yang kaya dari berbagai arah untuk
mendukung proses pelatihan dan evaluasi model klasifikasi.

23
2. Model SVM (Latih & Evaluasi)

● Explanation:

Evaluasi dilakukan terhadap model Support Vector Machine (SVM)

untuk mengukur kinerjanya dalam tugas klasifikasi pada 50 sampel data uji.
Hasil evaluasi, yang disajikan dalam Laporan Klasifikasi dan Matriks Konfusi
(Confusion Matrix), menunjukkan bahwa model memiliki performa yang
sangat tinggi dengan tingkat akurasi keseluruhan sebesar 98%.

1. Analisis Laporan Klasifikasi

Laporan klasifikasi memberikan rincian performa model untuk setiap kelas,
yang dalam kasus ini jumlah sampelnya seimbang (25 sampel untuk kelas 0
dan 25 untuk kelas 1).

● Untuk Kelas 0, model mencapai presisi (precision) sempurna (1.00),

artinya setiap prediksi untuk kelas 0 dijamin benar. Namun, daya ingat
(recall) sebesar 0.96, yang berarti ada sebagian kecil data kelas 0 yang
tidak teridentifikasi.
● Untuk Kelas 1, model mencapai recall sempurna (1.00), yang berarti
model berhasil menemukan semua sampel yang sebenarnya termasuk
dalam kelas 1. Presisinya sedikit lebih rendah (0.96).

24
 Nilai F1-Score yang tinggi dan seimbang untuk kedua kelas (0.98)
mengonfirmasi bahwa model memiliki keseimbangan yang sangat baik antara
presisi dan recall.

2. Analisis Matriks Konfusi

Matriks Konfusi (Gambar 2) memberikan visualisasi detail dari hasil prediksi.

● Prediksi Benar: Diagonal utama menunjukkan bahwa model berhasil

mengklasifikasikan 24 sampel sebagai kelas 0 (True Negative) dan 25
sampel sebagai kelas 1 (True Positive).
● Prediksi Salah: Hanya terdapat satu kesalahan di seluruh data uji.
Model salah mengklasifikasikan satu sampel yang seharusnya kelas 0
sebagai kelas 1 (False Positive). Tidak ada kesalahan di mana kelas 1
diprediksi sebagai kelas 0 (False Negative = 0).

Secara keseluruhan, model SVM menunjukkan kinerja yang luar biasa

dan sangat andal. Dengan hanya satu kesalahan dari 50 prediksi, model ini
terbukti sangat efektif untuk tugas klasifikasi yang diberikan.

3. Pairplot

● Explanation:

1. Distribusi Fitur Individual (Plot Diagonal)

Plot kepadatan (density plot) yang terletak pada garis diagonal

menunjukkan distribusi nilai untuk setiap fitur, yang dibedakan berdasarkan
kelas (label 0 berwarna merah muda, label 1 berwarna hijau toska). Dari plot
tersebut, terlihat bahwa distribusi untuk kedua kelas memiliki tumpang tindih
(overlap) yang sangat signifikan. Meskipun terdapat sedikit pergeseran pada
nilai puncak antara kedua kelas, tidak ada pemisahan yang jelas. Hal ini

25
 mengindikasikan bahwa setiap fitur dissimilarity secara individual memiliki
kemampuan yang terbatas untuk membedakan antara kelas 0 dan 1.

2. Hubungan Antar Fitur (Plot Tebar)

Plot tebar (scatter plot) di luar diagonal menggambarkan hubungan antara

setiap pasang fitur dissimilarity. Hasilnya menunjukkan beberapa poin:

● Terdapat korelasi positif moderat antara fitur-fitur dissimilarity

(titik-titik cenderung membentuk pola menanjak).
● Yang lebih krusial, titik-titik data dari kelas 0 dan 1 terlihat sangat
tercampur (intermingled) dan tidak membentuk kelompok (cluster)
yang terpisah pada ruang dua dimensi.

Secara keseluruhan, analisis pairplot ini menyimpulkan bahwa

fitur-fitur dissimilarity memiliki daya pisah yang rendah. Ketergantungan
sebuah model klasifikasi hanya pada fitur-fitur ini kemungkinan besar akan
menghasilkan performa yang kurang optimal karena tumpang tindih data yang
substansial antara kedua kelas.

4. Visualisasi Heatmap Korelasi GLCM

● Explanation:

Korelasi Antar Fitur Tekstur GLCM

Visualisasi heatmap yang menggambarkan matriks korelasi antar

fitur-fitur tekstur yang diekstraksi menggunakan metode Gray-Level
Co-occurrence Matrix (GLCM). Analisis ini bertujuan untuk mengidentifikasi
tingkat ketergantungan linear dan potensi redundansi informasi antar fitur.

26
 Interpretasi visual didasarkan pada skala warna, di mana warna merah intens
(mendekati +1.0) merepresentasikan korelasi positif kuat, warna biru
(mendekati -1.0) merepresentasikan korelasi negatif kuat, dan warna netral
atau pucat (mendekati 0) menandakan korelasi yang lemah.

Dari analisis heatmap, diperoleh beberapa temuan signifikan sebagai berikut:

1. Multikolinearitas Tinggi: Teridentifikasi adanya korelasi positif yang

sangat kuat (r > 0.9) antara kelompok fitur homogeneity, ASM, dan
energy. Blok berwarna merah intens yang dominan pada area ini
mengonfirmasi bahwa ketiga jenis fitur ini membawa informasi yang
sangat mirip dan redundan.
2. Korelasi Negatif Signifikan: Terdapat korelasi negatif yang cukup kuat
antara kelompok fitur contrast dengan kelompok fitur homogeneity,
ASM, dan energy. Hal ini mengindikasikan hubungan yang
berbanding terbalik; peningkatan nilai kontras pada tekstur cenderung
disertai dengan penurunan nilai homogenitas dan energi.
3. Korelasi Moderat dan Lemah: Fitur dissimilarity dan correlation
menunjukkan hubungan yang lebih bervariasi dan tidak sekonsisten
kelompok lainnya, menandakan bahwa mereka mungkin membawa
informasi yang lebih unik.

Implikasi untuk Seleksi Fitur: Adanya multikolinearitas yang tinggi,

terutama pada kelompok homogeneity, ASM, dan energy, memberikan
implikasi penting untuk tahap seleksi fitur. Untuk membangun model yang
efisien dan stabil, sangat disarankan untuk hanya memilih salah satu fitur
perwakilan dari kelompok yang sangat berkorelasi ini guna menghindari
redundansi data dan meningkatkan interpretasi model.

4. Percobaan 4 Tekstur menjadi Decision Tree

a. Program

1. Import Library
import os
import pandas as pd
import [Link] as plt
from sklearn.model_selection import train_test_split
from [Link] import LabelEncoder
from [Link] import DecisionTreeClassifier,
plot_tree
from [Link] import classification_report,
accuracy_score, confusion_matrix

● Explanation:
Bagian ini berfungsi untuk memanggil semua library yang dibutuhkan
dalam program. os dipakai untuk ngecek apakah file dataset tersedia. pandas
berguna buat baca dan ngolah data dalam bentuk tabel. [Link]
dipakai buat bikin visualisasi, terutama pas gambar pohon keputusan nanti.

27
 Dari sklearn, ada beberapa modul penting: train_test_split untuk bagi data jadi
latih dan uji, LabelEncoder buat ubah label kategori jadi angka,
DecisionTreeClassifier dan plot_tree buat bangun dan visualisasi model pohon
keputusan, serta classification_report, accuracy_score, dan confusion_matrix
buat evaluasi performa model.

2. Global Variabel
CSV_PATH = r"[Link]"

X_train, X_test, y_train, y_test = None, None, None,

None
model_awal, model_opt = None, None

● Explanation:
Variabel CSV_PATH digunakan untuk menyimpan path atau lokasi
file dataset yang akan digunakan, dalam hal ini bernama [Link].
Selanjutnya, variabel X_train, X_test, y_train, dan y_test dideklarasikan
sebagai penampung untuk data latih dan data uji yang akan dihasilkan dari
proses pembagian dataset. Sedangkan model_awal dan model_opt masing-
masing digunakan untuk menyimpan model Decision Tree sebelum dan
sesudah dilakukan proses optimasi terhadap parameter tertentu (seperti
kedalaman pohon). Pendefinisian awal ini diperlukan agar variabel-variabel
tersebut dapat diakses secara global dalam program.

3. Fungsi train_evaluate_decision_tree()
def train_evaluate_decision_tree():
global X_train, X_test, y_train, y_test, model_awal
df = pd.read_csv(CSV_PATH)
if 'label' not in [Link]:
print("[ERROR] Kolom 'label' tidak ditemukan.");
return

X = [Link]('label', axis=1)
y = LabelEncoder().fit_transform(df['label'])

X_train, X_test, y_train, y_test =

train_test_split( X, y, test_size=0.2,
random_state=42, stratify=y
)

model_awal = DecisionTreeClassifier(random_state=42)
model_awal.fit(X_train, y_train)
y_pred = model_awal.predict(X_test)

print("\n=== Hasil Evaluasi Decision Tree

===") print(classification_report(y_test,
y_pred)) print(f"Akurasi:
{accuracy_score(y_test,
y_pred):.2%}")
cm = confusion_matrix(y_test, y_pred)
[Link]()
[Link]("Confusion Matrix - Decision Tree")
[Link]("Predicted")

28
 [Link](cm, cmap='Greens',
interpolation='nearest')
[Link]()
[Link]()

● Explanation:
Fungsi train_evaluate_decision_tree() digunakan untuk melakukan
pelatihan dan evaluasi awal terhadap model Decision Tree menggunakan
dataset yang telah ditentukan. Pertama, dataset dibaca dari file yang telah
didefinisikan pada variabel CSV_PATH. Fungsi ini kemudian memeriksa
keberadaan kolom 'label' sebagai target klasifikasi. Jika kolom tersebut tidak
ditemukan, proses akan dihentikan.

Fitur (X) diambil dari seluruh kolom selain 'label', sedangkan label (y)
dikonversi ke bentuk numerik menggunakan LabelEncoder. Dataset kemudian
dibagi menjadi data latih dan data uji dengan proporsi 80:20 secara stratifikasi
untuk menjaga distribusi kelas tetap seimbang.

Model Decision Tree dibuat menggunakan parameter default dan

dilatih dengan data latih. Setelah proses pelatihan selesai, model digunakan
untuk memprediksi label data uji. Evaluasi dilakukan dengan mencetak
classification report, akurasi model, dan visualisasi confusion matrix.
Confusion matrix ditampilkan menggunakan matplotlib dalam bentuk gambar
berwarna hijau untuk memudahkan interpretasi terhadap performa klasifikasi.

4. Fungsi visualisasi_decision_awal()
def visualisasi_decision_awal():
if model_awal is None:
print("[INFO] Model belum dilatih. Silakan
latih model dulu.")
return
[Link](figsize=(20, 10))
plot_tree(model_awal, filled=True,
feature_names=X_train.columns,
class_names=[str(i) for i in set(y_train)],
fontsize=8)
[Link]("Visualisasi Decision Tree - Default")
[Link]()

● Explanation:
Fungsi visualisasi_decision_awal() digunakan untuk menampilkan
struktur pohon keputusan dari model Decision Tree yang telah dilatih
menggunakan parameter default. Sebelum visualisasi dilakukan, fungsi akan
terlebih dahulu memeriksa apakah model telah tersedia. Jika belum, maka
pengguna akan diberikan informasi bahwa pelatihan model perlu dilakukan
terlebih dahulu.

Jika model tersedia, fungsi akan menampilkan struktur pohon

keputusan menggunakan plot_tree() dari library [Link]. Visualisasi
tersebut mencakup nama fitur dari data latih, label kelas yang telah dikonversi

29
 menjadi string, serta pewarnaan otomatis pada setiap node untuk membedakan
kategori. Tampilan pohon ditata dalam ukuran besar (20x10) agar seluruh
struktur dapat terlihat dengan jelas. Fungsi ini ditutup dengan perintah
[Link]() untuk menampilkan hasil visualisasi secara interaktif.

5. Fungsi visualisasi_decision_optimasi()
def visualisasi_decision_optimasi():
global model_opt
if X_train is None or y_train is None:
print("[INFO] Model belum dilatih. Silakan
latih
model dulu.")
return
model_opt = DecisionTreeClassifier(
max_depth=3, min_samples_split=5, random_state=42
)
model_opt.fit(X_train, y_train)
[Link](figsize=(20, 10))
plot_tree(model_opt, filled=True,
feature_names=X_train.columns,
class_names=[str(i) for i in set(y_train)],
fontsize=8)
[Link]("Visualisasi Decision Tree - Optimasi")
[Link]()
● Explanation:
Fungsi visualisasi_decision_optimasi() digunakan untuk menampilkan
struktur pohon keputusan hasil dari model Decision Tree yang telah
dioptimasi. Sebelum proses visualisasi dilakukan, fungsi terlebih dahulu
memeriksa apakah data latih (X_train dan y_train) sudah tersedia. Jika belum,
maka akan ditampilkan pesan bahwa model belum dilatih dan visualisasi tidak
akan dijalankan.

Model optimasi dibuat menggunakan DecisionTreeClassifier dengan

parameter yang telah disesuaikan, yaitu max_depth=3 dan
min_samples_split=5. Parameter ini bertujuan untuk mengurangi kompleksitas
pohon dan menghindari overfitting. Setelah model dilatih menggunakan data
latih, struktur pohon divisualisasikan menggunakan plot_tree() dari pustaka
[Link]. Visualisasi mencakup nama fitur, label kelas dalam bentuk string,
serta pewarnaan node untuk membedakan kategori.

Ukuran gambar diperbesar agar seluruh struktur pohon dapat terbaca

dengan jelas, dan hasil visualisasi ditampilkan melalui [Link](). Fungsi ini
membantu dalam memahami bagaimana model mengambil keputusan
berdasarkan fitur-fitur yang digunakan.

30
6. Fungsi Menu()
def menu():
while True:
print("\n=== MENU DECISION TREE TEKSTUR ===")
print("1. Model Decision Tree (Latih &
Evaluasi)")
print("2. Visualisasi Pohon Default")
print("3. Visualisasi Pohon Optimasi")
print("4. Keluar")

pilihan = input("Pilih menu (1-4): ").strip()

if pilihan == "1":
train_evaluate_decision_tree()
elif pilihan == "2":
visualisasi_decision_awal()
elif pilihan == "3":
visualisasi_decision_optimasi()
elif pilihan == "4":
print("Keluar dari program.")
break
else:
print("Pilihan tidak valid.")

if name == " main ":

menu()

● Explanation:
Fungsi menu() merupakan antarmuka utama dari program yang
menyediakan pilihan interaktif bagi pengguna untuk menjalankan proses
klasifikasi menggunakan algoritma Decision Tree. Fungsi ini akan terus
berjalan dalam sebuah perulangan while hingga pengguna memilih opsi untuk
keluar dari program.

Di dalam menu, terdapat empat opsi utama:

(1) Melatih dan mengevaluasi model Decision Tree menggunakan dataset yang
tersedia,
(2) Menampilkan visualisasi pohon keputusan dari model default,
(3)Menampilkan visualisasi pohon keputusan dari model yang
telah dioptimasi, dan
(4)Keluar dari program.

Setiap input dari pengguna akan diproses dan diarahkan ke fungsi yang sesuai.
Jika pengguna memasukkan pilihan yang tidak valid, maka program akan
memberikan pesan peringatan. Struktur ini dibuat untuk memudahkan
navigasi dan pengujian fungsi-fungsi utama secara terpisah serta menjaga agar
program tetap berjalan hingga diperintahkan untuk berhenti.

31
b. Output

1. Model Decision Tree (Latih & Evaluasi)

● Explanation:
Evaluasi Model Decision Tree

Evaluasi terhadap model Decision Tree menunjukkan kinerja yang

sangat baik dalam tugas klasifikasi. Berdasarkan pengujian pada 40 sampel
data, model ini berhasil mencapai tingkat akurasi keseluruhan sebesar 92.50%.
Rincian performa model disajikan dalam Laporan Klasifikasi dan
divisualisasikan melalui Matriks Konfusi (Confusion Matrix).

1. Analisis Laporan Klasifikasi

Laporan klasifikasi menunjukkan hasil yang kuat dan seimbang pada kedua
kelas, di mana masing-masing kelas memiliki 20 sampel data uji.

● Untuk Kelas 1, model mencapai presisi (precision) 0.95 dan daya ingat
(recall) 0.90. Ini berarti saat model memprediksi kelas 1, 95% di
antaranya benar, dan model berhasil menemukan 90% dari semua
sampel kelas 1 yang ada.

32
 ● Untuk Kelas 0, terjadi pertukaran peran di mana recall lebih tinggi
(0.95) sementara presisi sedikit lebih rendah (0.90). Model ini sangat
efektif dalam menemukan hampir semua sampel kelas 0, namun
dengan sedikit risiko salah mengklasifikasikan.

Nilai F1-Score yang tinggi (0.93 dan 0.92) untuk kedua kelas
mengonfirmasi bahwa model memiliki keseimbangan yang sangat baik antara
presisi dan recall.

2. Analisis Matriks Konfusi

Meskipun tidak menampilkan angka secara eksplisit, matriks konfusi

(Gambar 1) secara visual mengonfirmasi kinerja model. Berdasarkan data dari
laporan klasifikasi, matriks tersebut dapat diinterpretasikan sebagai berikut:

● Prediksi Benar: Warna hijau tua pada diagonal utama

merepresentasikan jumlah prediksi yang benar, yaitu 19 sampel untuk
kelas 0 (True Negative) dan 18 sampel untuk kelas 1 (True Positive).
● Prediksi Salah: Warna terang di luar diagonal utama menunjukkan
jumlah kesalahan yang minimal. Terdapat 2 sampel kelas 1 yang keliru
diprediksi sebagai kelas 0 (False Negative) dan 1 sampel kelas 0 yang
keliru diprediksi sebagai kelas 1 (False Positive).

Secara keseluruhan, dengan 37 dari 40 prediksi yang tepat, model

Decision Tree ini terbukti sangat efektif dan reliabel untuk tugas klasifikasi
yang diberikan.

2. Visualisasi Decision Tree Default

● Explanation:
Visualisasi Struktur Model Decision Tree (Default)

Visualisasi struktur dari model Decision Tree yang dilatih

menggunakan parameter default. Visualisasi ini memberikan gambaran

33
transparan mengenai bagaimana model membuat keputusan klasifikasi secara
hierarkis, dari akar hingga ke daun keputusan.

1. Komponen Pohon Keputusan

Setiap kotak pada diagram disebut node, yang berisi informasi krusial sebagai
berikut:

● Aturan Keputusan: Kondisi berbasis fitur yang digunakan untuk

membagi data (contoh: ASM_0 <= 0.001).
● Indeks Gini: Ukuran "ketidakmurnian" kelas dalam sebuah node. Nilai
Gini = 0.0 menandakan node tersebut murni sempurna (semua sampel
di dalamnya milik satu kelas).
● Samples: Jumlah total sampel data yang berada pada node tersebut.
● Value: Distribusi sampel untuk setiap kelas. Misalnya, value = [80, 80]
pada node akar menunjukkan ada 80 sampel kelas 0 dan 80 sampel
kelas 1.
● Class: Kelas mayoritas dalam node tersebut, yang merupakan hasil
prediksi pada titik itu.

2. Alur Proses Klasifikasi

Proses pengambilan keputusan dimulai dari node akar (paling atas) dan
bergerak ke bawah mengikuti cabang True atau False berdasarkan hasil
evaluasi aturan di setiap node.

Sebagai contoh, sebuah sampel data akan melalui alur berikut:

1. Dimulai dari akar, model menguji aturan ASM_0 <= 0.001.

2. Jika kondisi terpenuhi (True), sampel akan diarahkan ke cabang kiri
menuju node berikutnya yang menguji correlation_90 <= 0.404.
3. Proses ini berlanjut secara rekursif hingga sampel mencapai node daun
(leaf node)—yaitu node di ujung cabang tanpa percabangan lebih
lanjut.
4. Kelas yang tertera pada node daun tersebut (misalnya class = 1 atau
class = 0) menjadi hasil prediksi akhir untuk sampel tersebut.

3. Analisis Struktur Model

Visualisasi ini menunjukkan bahwa fitur ASM_0 merupakan prediktor

paling penting karena dipilih sebagai kriteria pemisah pertama di node akar.
Fitur-fitur lain seperti correlation_90 dan homogeneity_135 juga memainkan
peran signifikan di level-level berikutnya. Karena ini adalah model "default",
pohon keputusan dibiarkan tumbuh hingga mencapai kriteria penghentian
internalnya. Hal ini bisa menghasilkan model yang sangat dalam dan berisiko
mengalami overfitting, di mana model terlalu menghafal data latih.

34
3. Visualisasi Decision Tree Optimasi

● Explanation:
Visualisasi Struktur Model Decision Tree Hasil Optimisasi

Visualisasi dari struktur model Decision Tree yang telah melalui

proses optimisasi. Proses optimisasi, seperti penyesuaian hyperparameter
(contohnya, pembatasan kedalaman maksimum atau max_depth), bertujuan
untuk menghasilkan model yang lebih sederhana, lebih cepat, dan dapat
melakukan generalisasi lebih baik pada data baru, sehingga mengurangi risiko
overfitting.

1. Struktur dan Alur Keputusan

Struktur pohon ini menunjukkan alur keputusan hierarkis yang digunakan

model untuk melakukan klasifikasi.

● Node Akar: Proses klasifikasi dimulai dari node paling atas (akar)
yang menggunakan fitur ASM_0 sebagai pemisah utama. Ini
menandakan bahwa ASM_0 adalah fitur dengan daya diskriminatif
tertinggi menurut model.
● Cabang Keputusan: Berdasarkan kondisi pada node akar, data
diarahkan ke cabang "True" (kiri) atau "False" (kanan). Proses ini
berlanjut ke level berikutnya, menggunakan fitur lain seperti
correlation_90 dan homogeneity_135 untuk membagi data lebih lanjut.
● Node Daun: Alur berhenti ketika data mencapai node daun (leaf node),
yaitu node di ujung cabang yang memberikan prediksi kelas akhir.
Sebagian besar node daun pada pohon ini murni (Gini = 0.0),
menandakan keyakinan tinggi dalam prediksi.

35
 2. Implikasi dari Proses Optimisasi

Judul "Optimasi" pada visualisasi ini mengimplikasikan bahwa kompleksitas

model telah dikontrol secara sengaja.

● Struktur Lebih Ringkas: Berbeda dengan model default yang bisa

tumbuh sangat dalam, model ini kemungkinan memiliki batasan
kedalaman. Hal ini mencegah model menjadi terlalu spesifik pada data
latih.
● Trade-off Kinerja: Optimisasi terkadang mengizinkan beberapa node
daun tetap tidak murni. Contohnya adalah node di kiri bawah dengan
Gini = 0.444, yang masih berisi campuran sampel dari kedua kelas. Ini
adalah trade-off yang disengaja: model mengorbankan kemampuan
untuk mengklasifikasikan setiap sampel data latih dengan sempurna
demi menciptakan aturan yang lebih umum dan kuat.

Secara keseluruhan, visualisasi ini merepresentasikan model Decision

Tree yang seimbang, yang tidak hanya mengidentifikasi fitur-fitur paling
prediktif tetapi juga memiliki struktur yang terkontrol untuk meningkatkan
kemampuan generalisasi dan mengurangi risiko overfitting.

c. Perbandingan Percobaan 3 dan Percobaan 4

Percobaan 3 menggunakan SVM untuk klasifikasi berdasarkan atribut tekstur.
Dengan hanya satu data kelas 0 yang salah diklasifikasikan sebagai kelas 1, tidak ada
false positive, sehingga model sangat baik dalam mendeteksi data kelas 1, dan akurasi
secara keseluruhan sangat tinggi. Model juga menunjukkan kemampuan yang sangat
baik untuk membedakan dua kelas.
Percobaan 4 juga menggunakan metode Decision Tree untuk klasifikasi
berdasarkan tekstur. Hasil visualisasi confusion matrix menunjukkan bahwa prediksi
model sebagian besar berada di diagonal utama; ini menunjukkan bahwa prediksi
tersebut sangat akurat. Baik kesalahan positif palsu maupun negatif palsu hampir
tidak ada. Oleh karena itu, kedua model ini sangat berhasil; namun, Decision Tree
jauh lebih baik karena hampir tidak menampilkan kesalahan klasifikasi sama sekali.

36
5. Percobaan 5-6 Gabungan Warna + Tekstur

a. Program

1. Import Library
import os
import pandas as pd
import [Link] as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import SVC
from [Link] import DecisionTreeClassifier,
plot_tree
from [Link] import classification_report,
accuracy_score, confusion_matrix

● Explanation:
Di bagian ini, semua library yang dibutuhkan buat proses klasifikasi
dan visualisasi udah disiapin. os dipakai buat ngecek file, biar program tau
apakah dataset-nya ada atau nggak. pandas dipakai buat ngolah data dalam
bentuk tabel, sedangkan [Link] dan seaborn dipakai buat bantu
visualisasi kayak grafik, heatmap, dan tampilan pohon keputusan.

Buat model machine learning-nya, program ngimpor train_test_split

buat bagi data jadi latih dan uji, StandardScaler buat nyamain skala fitur, SVC
buat klasifikasi pakai Support Vector Machine, dan DecisionTreeClassifier
plus plot_tree buat bikin model Decision Tree sekaligus visualisasinya.

Terakhir, buat evaluasi performa model, dipakai classification_report,

accuracy_score, dan confusion_matrix supaya hasil prediksi bisa dianalisis
secara lengkap.

2. Inisialisasi Dataset dan Model

CSV_PATH = r"fitur_gabungang.csv"

if not [Link](CSV_PATH):
raise FileNotFoundError(f"File CSV tidak ditemukan di
path: {CSV_PATH}")

df = pd.read_csv(CSV_PATH)

if 'class' not in [Link]:

raise KeyError("Kolom 'class' tidak ditemukan
di dataset!")

X = [Link](columns=['file', 'class'])
y = df['class']

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, stratify=y, random_state=42
)

scaler = StandardScaler()

37
 X_train_scaled =
scaler.fit_transform(X_train) X_test_scaled =
[Link](X_test)

svm_model = SVC(kernel='rbf', C=1, gamma='scale',

random_state=42)
dt_model = DecisionTreeClassifier(random_state=42)

y_pred_svm = y_pred_dt = None

● Explanation:
Program diawali dengan menentukan lokasi file dataset melalui
variabel CSV_PATH. Sebelum membaca dataset, dilakukan pengecekan
apakah file tersebut benar-benar ada. Jika file tidak ditemukan, program
langsung dihentikan dengan pesan error menggunakan raise
FileNotFoundError.

Setelah file berhasil dibaca menggunakan pandas.read_csv(), program

memverifikasi keberadaan kolom 'class' yang dibutuhkan sebagai label. Jika
kolom tersebut tidak ada, program juga akan dihentikan dengan pesan
KeyError.

Fitur (X) diambil dengan menghapus kolom 'file' dan 'class', sedangkan
label target (y) diambil dari kolom 'class'. Dataset kemudian dibagi menjadi
data latih dan data uji dengan proporsi 80:20 menggunakan train_test_split,
dan dilakukan stratifikasi agar distribusi kelas tetap seimbang.

Selanjutnya, fitur dinormalisasi menggunakan StandardScaler agar

setiap fitur memiliki skala yang seragam. Proses ini dilakukan terpisah untuk
data latih dan uji, di mana scaler hanya dilatih (fit) pada data latih dan
diterapkan (transform) pada keduanya.

Dua model klasifikasi kemudian didefinisikan:

● svm_model menggunakan Support Vector Machine dengan kernel

RBF (Radial Basis Function), nilai C=1, dan gamma='scale'.

● dt_model menggunakan Decision Tree dengan parameter default.

Terakhir, dua variabel y_pred_svm dan y_pred_dt disiapkan

untuk menampung hasil prediksi dari kedua model setelah dilatih
nanti.

3. Fungsi menampilkan Dataset

def tampilkan_dataset():
print("\n===== Informasi Dataset =====")
print([Link]())
print("\n===== 5 Data Teratas
=====") print([Link]())

38
● Explanation:
Fungsi ini digunakan untuk menampilkan informasi umum mengenai
dataset yang digunakan dalam proses klasifikasi. Pertama, fungsi mencetak
struktur data menggunakan [Link](), yang memberikan detail seperti jumlah
baris, jumlah kolom, tipe data tiap kolom, dan apakah terdapat data yang
kosong.

Setelah itu, fungsi juga menampilkan lima baris pertama dari dataset
menggunakan [Link](). Tujuannya agar pengguna bisa melihat isi data secara
langsung dan memahami bentuk serta nilai dari masing-masing fitur yang
akan digunakan dalam pelatihan model.

4. Fungsi train_models()

def train_models():
global y_pred_svm, y_pred_dt
svm_model.fit(X_train_scaled, y_train)
dt_model.fit(X_train, y_train)

y_pred_svm =
svm_model.predict(X_test_scaled) y_pred_dt =
dt_model.predict(X_test)

print("\n===== Model berhasil dilatih =====")

● Explanation:
Fungsi ini digunakan untuk melatih dua model klasifikasi, yaitu
Support Vector Machine (SVM) dan Decision Tree (DT), dengan data latih
yang telah disiapkan sebelumnya.

Model SVM dilatih menggunakan data yang telah distandarkan

(X_train_scaled), karena SVM sensitif terhadap skala fitur. Sementara itu,
model Decision Tree dilatih langsung menggunakan data asli (X_train),
karena algoritma ini tidak memerlukan normalisasi fitur.

Setelah proses pelatihan selesai, masing-masing model digunakan

untuk melakukan prediksi terhadap data uji. Hasil prediksi dari SVM disimpan
dalam variabel y_pred_svm, sedangkan hasil dari Decision Tree disimpan
dalam y_pred_dt.

Fungsi ini ditutup dengan menampilkan pesan bahwa kedua model

telah berhasil dilatih. Proses ini merupakan inti dari pipeline klasifikasi, yang
nantinya akan dilanjutkan dengan evaluasi performa model.

5. Fungsi evaluasi_models()

def evaluasi_models():
if y_pred_svm is None or y_pred_dt is None:
print("[INFO] Model belum dilatih. Silakan
latih
model dulu.")
return

39
 print("\n===== Evaluasi Model SVM =====")
print("Akurasi:", accuracy_score(y_test, y_pred_svm))
print(confusion_matrix(y_test, y_pred_svm))
print(classification_report(y_test, y_pred_svm))

print("\n===== Evaluasi Model Decision Tree =====")

print("Akurasi:", accuracy_score(y_test, y_pred_dt))
print(confusion_matrix(y_test, y_pred_dt))
print(classification_report(y_test, y_pred_dt))

● Explanation:
Fungsi ini digunakan untuk mengevaluasi performa dari dua model
klasifikasi yang telah dilatih, yaitu SVM dan Decision Tree. Sebelum evaluasi
dilakukan, fungsi ini memeriksa apakah prediksi dari kedua model sudah
tersedia. Jika belum, program akan memberikan informasi bahwa pelatihan
model harus dilakukan terlebih dahulu.

Jika hasil prediksi sudah ada, evaluasi dilakukan dengan tiga metrik utama:

1. Akurasi – Menunjukkan seberapa banyak prediksi model yang sesuai

dengan label sebenarnya.

2. Confusion Matrix – Menampilkan jumlah prediksi benar dan salah

antar kelas, yang berguna untuk melihat kesalahan spesifik pada
masing-masing kelas.

3. Classification Report – Memberikan informasi lebih detail seperti

precision, recall, dan f1-score untuk masing-masing kelas.

Evaluasi dilakukan secara terpisah untuk model SVM dan Decision

Tree, sehingga pengguna bisa membandingkan performa kedua model dengan
jelas. Hasil evaluasi ini akan membantu menentukan model mana yang lebih
baik untuk digunakan dalam konteks klasifikasi dataset yang diberikan.

6. Fungsi visualisasi_decision_tree()

def visualisasi_decision_tree():
if y_pred_dt is None:
print("[INFO] Model Decision Tree belum
dilatih.")
return

[Link](figsize=(20, 10))
plot_tree(
dt_model,
feature_names=[Link],
class_names=[str(cls) for cls in
sorted([Link]())],
filled=True,
rounded=True,
fontsize=9
)

40
 [Link]("Visualisasi Pohon Keputusan (Decision
Tree)")
[Link]()

● Explanation:
Fungsi ini digunakan untuk menampilkan struktur dari model Decision
Tree yang telah dilatih sebelumnya. Sebelum visualisasi dilakukan, program
terlebih dahulu memeriksa apakah hasil prediksi dari model Decision Tree
sudah tersedia. Jika belum, pengguna diberi informasi bahwa model belum
dilatih.

Jika model sudah siap, maka fungsi akan memanggil plot_tree() dari
[Link] untuk menggambarkan pohon keputusan secara visual. Visualisasi
ini mencakup:

● Nama fitur yang digunakan sebagai pemisah pada tiap node pohon,

● Nama kelas berdasarkan label unik dari dataset yang telah diurutkan,

● Warna dan bentuk node yang dibuat penuh (filled) dan membulat
(rounded) untuk memperjelas tampilan.

Ukuran grafik diperbesar (figsize=(20, 10)) agar seluruh struktur

pohon dapat terbaca dengan baik. Visualisasi ini sangat berguna untuk
memahami bagaimana model membuat keputusan berdasarkan fitur-fitur
dalam dataset.

7. Fungsi visualisasi_confusion_matrix()

def visualisasi_confusion_matrix():
if y_pred_svm is None or y_pred_dt is None:
print("[INFO] Model belum dilatih.")
return

cm_svm = confusion_matrix(y_test, y_pred_svm)

cm_dt = confusion_matrix(y_test, y_pred_dt)

fig, axes = [Link](1, 2, figsize=(12, 5))

[Link](cm_svm, annot=True, fmt='d',
cmap='Blues', ax=axes[0])
axes[0].set_title("Confusion Matrix - SVM")
axes[0].set_xlabel("Predicted")
axes[0].set_ylabel("Actual")

[Link](cm_dt, annot=True, fmt='d',

cmap='Greens', ax=axes[1])
axes[1].set_title("Confusion Matrix - Decision Tree")
axes[1].set_xlabel("Predicted")
axes[1].set_ylabel("Actual")
plt.tight_layout()
[Link]()

41
● Explanation:
Fungsi ini digunakan untuk membandingkan performa model SVM
dan Decision Tree melalui visualisasi confusion matrix. Sebelum ditampilkan,
fungsi memeriksa apakah kedua model sudah dilatih dan hasil prediksinya
tersedia. Jika belum, program akan memberikan informasi kepada pengguna.

Setelah itu, confusion matrix untuk masing-masing model dihitung

menggunakan confusion_matrix() dari [Link]. Hasil dari
masing-masing model divisualisasikan berdampingan menggunakan
matplotlib dan seaborn, dengan satu subplot untuk SVM dan satu lagi untuk
Decision Tree.

● Confusion matrix SVM ditampilkan dengan colormap biru (Blues).

● Confusion matrix Decision Tree ditampilkan dengan colormap hijau
(Greens)
● Setiap matrix diberi anotasi nilai aktual dan prediksi, serta diberi label
sumbu yang jelas.

Visualisasi ini membantu pengguna melihat langsung bagaimana

model melakukan klasifikasi terhadap tiap kelas, serta mengidentifikasi jenis
kesalahan klasifikasi yang terjadi, seperti false positive atau false negative.
Fungsi ini efektif untuk membandingkan hasil kedua model secara visual.

8. Fungsi perbandingan_akurasis()

def perbandingan_akurasis():
if y_pred_svm is None or y_pred_dt is None:
print("[INFO] Model belum dilatih.")
return

acc_svm = accuracy_score(y_test, y_pred_svm)

acc_dt = accuracy_score(y_test, y_pred_dt)

model_names = ['SVM', 'Decision

Tree'] accuracies = [acc_svm, acc_dt]

[Link](figsize=(6, 5))
bars = [Link](model_names, accuracies,
color=['#4CAF50', '#2196F3'])
[Link](0, 1)
[Link]('Perbandingan Akurasi Model')
[Link]('Akurasi')

for bar in bars:

yval = bar.get_height()
[Link](bar.get_x() + bar.get_width() / 2, yval
+ 0.02, f'{yval:.3f}', ha='center', fontsize=11)

[Link](axis='y', linestyle='--',
alpha=0.7) plt.tight_layout()
[Link]()

42
● Explanation:
Fungsi ini digunakan untuk membandingkan akurasi antara dua model
klasifikasi, yaitu Support Vector Machine (SVM) dan Decision Tree, melalui
visualisasi grafik batang.

Sebelum membuat grafik, fungsi mengecek terlebih dahulu apakah

kedua model sudah dilatih. Jika prediksi belum tersedia, maka akan
ditampilkan pesan informasi kepada pengguna.

Setelah itu, nilai akurasi dari masing-masing model dihitung

menggunakan accuracy_score(). Nilai akurasi ini disimpan dalam sebuah list
untuk kemudian divisualisasikan.

Visualisasi dibuat dalam bentuk grafik batang (bar chart)

menggunakan matplotlib. Masing-masing batang mewakili akurasi dari satu
model, dengan warna berbeda:

● SVM diberi warna hijau.

● Decision Tree diberi warna biru.

Nilai akurasi juga ditampilkan di atas masing-masing batang secara

presisi tiga angka di belakang koma, untuk memperjelas perbedaan performa
antar model. Grafik dilengkapi dengan judul, label sumbu Y, serta garis bantu
horizontal (grid) agar lebih mudah dibaca.

Fungsi ini memudahkan pengguna dalam membandingkan efektivitas

model berdasarkan metrik akurasi secara visual dan intuitif.

9. Fungsi menu()

def menu():
while True:
print("\n=== MENU UTAMA ===")
print("1. Tampilkan Dataset")
print("2. Latih Model")
print("3. Evaluasi Model")
print("4. Visualisasi Pohon Keputusan")
print("5. Visualisasi Confusion Matrix")
print("6. Perbandingan Akurasi")
print("7. Keluar")

pilihan = input("Pilih menu (1-7): ").strip()

if pilihan == "1":
tampilkan_dataset()
elif pilihan == "2":
train_models()
elif pilihan == "3":
evaluasi_models()
elif pilihan == "4":
visualisasi_decision_tree()
elif pilihan == "5":
visualisasi_confusion_matrix()

43
 elif pilihan == "6":
perbandingan_akurasis()
elif pilihan == "7":
print("Keluar dari
program.") break
else:
print(" Pilihan tidak valid.")

if name == " main ":

menu()

● Explanation:
Fungsi menu() berfungsi sebagai antarmuka utama dari program yang
mengatur alur interaksi antara pengguna dan seluruh fitur klasifikasi yang
telah dibuat. Program akan berjalan dalam loop while True dan terus
menampilkan daftar menu sampai pengguna memilih opsi keluar.

Menu yang ditampilkan terdiri dari:

1. Menampilkan informasi dan contoh isi dataset,

2. Melatih model SVM dan Decision Tree,

3. Menjalankan evaluasi terhadap kedua model,

4. Menampilkan visualisasi struktur Decision Tree,

5. Menampilkan confusion matrix dari kedua model dalam satu tampilan,

6. Membandingkan akurasi kedua model dalam bentuk grafik batang,

7. Keluar dari program.

Setiap input dari pengguna akan dihubungkan dengan fungsi yang

sesuai. Jika pengguna memasukkan pilihan di luar rentang 1–7, maka akan
muncul pesan bahwa pilihan tidak valid.

Struktur seperti ini memudahkan pengguna untuk mengakses dan

menguji semua fitur utama dalam program secara bertahap, mulai dari
pengecekan data sampai analisis performa model secara visual.

44
b. Output

1. Tampilkan Dataset

45
● Explanation:
Dataset yang digunakan dalam penelitian ini terdiri dari 200 sampel
data dengan total 41 kolom, yang disajikan dalam format DataFrame dari
pustaka pandas. Dataset ini telah dirancang untuk tugas klasifikasi, di mana 39
kolom berfungsi sebagai fitur prediktif, satu kolom sebagai label target, dan
satu kolom sebagai identifikasi file.

1. Struktur dan Kualitas Data

Analisis informasi dataset menunjukkan karakteristik sebagai berikut:

● Dimensi: Dataset memiliki 200 baris (entri) yang merepresentasikan

sampel individual dan 41 kolom yang merepresentasikan atribut.
● Kualitas Data: Analisis integritas data menunjukkan bahwa seluruh 41
kolom memiliki 200 entri non-null. Hal ini mengonfirmasi tidak
adanya data yang hilang (missing values) dalam dataset, sehingga
proses pra-pengolahan seperti imputasi tidak diperlukan.
● Tipe Data: Dataset ini terdiri dari tiga jenis tipe data: 36 fitur numerik
desimal (float64), 4 fitur numerik bulat (int64), dan 1 kolom
identifikasi bertipe objek/string (object).

46
 2. Rincian Atribut Dataset

Ke-41 kolom dapat dikelompokkan berdasarkan fungsinya:

● Kolom Identifikasi dan Target:

1. file: Kolom bertipe objek yang berfungsi sebagai identifikasi
unik untuk setiap sampel, kemungkinan merujuk pada nama
file citra asli.
2. class: Kolom bertipe integer yang merupakan variabel target
(dependen) yang akan diprediksi oleh model klasifikasi.

● Fitur (Atribut Independen): Terdapat 39 fitur yang diekstraksi dari

citra, yang dapat dikelompokkan menjadi tiga kategori utama:
1. Fitur Statistik Warna: Termasuk di dalamnya adalah rata-rata
histogram (HistRed_mean, dll.), rata-rata intensitas warna
(R_mean, dll.), standar deviasi (R_std, dll.), dan kemiringan
(R_skew, dll.) untuk setiap kanal warna (Merah, Hijau, Biru).
2. Fitur Koherensi Warna: Variabel R_CCV, G_CCV, dan
B_CCV yang mengukur koherensi spasial dari setiap kanal
warna.
3. Fitur Tekstur GLCM: Sebagian besar fitur berasal dari
ekstraksi tekstur menggunakan Gray-Level Co-occurrence
Matrix (GLCM), yang mencakup properti seperti dissimilarity,
correlation, homogeneity, contrast, ASM, dan energy. Setiap
properti ini dihitung pada empat arah sudut yang berbeda (0°,
45°, 90°, 135°) untuk menangkap karakteristik tekstur dari
berbagai orientasi.

Secara keseluruhan, dataset ini memiliki kualitas yang sangat baik dan
kaya akan fitur, mencakup aspek warna dan tekstur, sehingga menjadi
landasan yang solid untuk membangun model klasifikasi citra yang
komprehensif.

2. Latih Model

● Explanation:

Ini adalah pesan konfirmasi bahwa model sudah siap untuk digunakan
ke tahap selanjutnya, seperti melakukan prediksi atau dievaluasi.

47
3. Evaluasi Model

● Explanation:
Hasil Evaluasi

● Akurasi 1.0 (100%): Kedua model berhasil menebak semua 40 data uji
dengan benar tanpa ada satu pun kesalahan.
● Matriks Konfusi [[20 0] [0 20]]: Visualisasi ini mengonfirmasi hasil
sempurna.
○ 20 data kelas 0 diprediksi benar sebagai kelas 0.
○ 20 data kelas 1 diprediksi benar sebagai kelas 1.
○ 0 kesalahan dibuat oleh kedua model.
● Precision, Recall, F1-Score Semuanya 1.00: Nilai sempurna di semua
metrik ini menegaskan bahwa tidak ada kelemahan sama sekali dalam
performa model pada data uji ini. Model tidak hanya akurat, tetapi juga
seimbang dalam kemampuannya mengidentifikasi setiap kelas.

Secara keseluruhan, untuk dataset uji ini, kedua model menunjukkan performa
terbaik yang mungkin dicapai.

48
4. Visualisasi Pohon Keputusan

● Explanation:
Model ini hanya memerlukan satu pertanyaan untuk membuat
keputusan yang 100% akurat: "Apakah nilai fitur HistGreen_mean kurang dari
atau sama dengan 168.318?"

● Jika jawabannya Ya (True), data tersebut langsung diklasifikasikan

sebagai kelas 1.
● Jika jawabannya Tidak (False), data tersebut diklasifikasikan sebagai
kelas 0.

Struktur yang sangat simpel ini, yang hanya terdiri dari satu tingkat
keputusan, menandakan bahwa fitur HistGreen_mean sangat kuat dan mampu
memisahkan kedua kelas secara sempurna tanpa memerlukan aturan
tambahan. Kedua kotak hasil di bagian bawah memiliki nilai Gini = 0.0, yang
berarti keduanya "murni" dan tidak ada kesalahan klasifikasi sama sekali pada
data latih.

49
5. Visualisasi Confusion Matrix

● Explanation:
Analisis Matriks Konfusi Model SVM dan Decision Tree

Visualisasi matriks konfusi (confusion matrix) untuk mengevaluasi

kinerja model Support Vector Machine (SVM) dan Decision Tree pada data
uji yang terdiri dari 40 sampel.

Hasil analisis visual dari kedua matriks menunjukkan:

1. Model SVM: Matriks konfusi untuk model SVM menunjukkan bahwa

dari 20 sampel kelas 0, seluruhnya berhasil diprediksi dengan benar
sebagai kelas 0 (True Negative = 20). Demikian pula, dari 20 sampel
kelas 1, seluruhnya juga berhasil diprediksi dengan benar sebagai kelas
1 (True Positive = 20).
2. Model Decision Tree: Hasil yang identik juga ditunjukkan oleh model
Decision Tree, di mana tidak terdapat kesalahan klasifikasi sama sekali
(False Positive = 0 dan False Negative = 0).

Secara keseluruhan, kedua matriks secara visual mengonfirmasi bahwa

kedua model mencapai tingkat akurasi sempurna (100%) pada set data
pengujian. Absensi kesalahan klasifikasi pada kedua model mengindikasikan
kemampuan generalisasi yang sangat tinggi dan daya pisah fitur yang sangat
efektif untuk dataset ini.

50
6. Perbandingan kedua Akurasi

● Explanation:
Analisis Komparatif Kinerja Model SVM dan Decision Tree

Pada bagian ini, disajikan analisis komparatif kinerja antara model

Support Vector Machine (SVM) dan Decision Tree berdasarkan tiga output
evaluasi. Hasil analisis menunjukkan adanya inkonsistensi data pada salah satu

51
 output, namun kesimpulan yang valid dapat ditarik dengan membandingkan
informasi yang konsisten di antara ketiganya.

1. Identifikasi Inkonsistensi Data

Inkonsistensi teridentifikasi pada output tekstual (Gambar 3). Pada

bagian header, output tersebut menyatakan akurasi 100.00% untuk kedua
model. Namun, pada bagian tabel di bawahnya pada gambar yang sama, nilai
akurasi yang tercatat adalah 0.950 untuk SVM dan 0.925 untuk Decision Tree.

2. Verifikasi Hasil melalui Analisis Konsistensi

Untuk memverifikasi hasil yang sebenarnya, dilakukan perbandingan

dengan output visualisasi. Kedua grafik perbandingan (Gambar 1 dan Gambar
2) secara konsisten menampilkan nilai akurasi yang selaras dengan data pada
bagian tabel output tekstual.

Berdasarkan verifikasi ini, disimpulkan bahwa data kinerja yang valid adalah
sebagai berikut:

● Model SVM:
○ Akurasi: 0.950 (95%)
○ Presisi: 0.95
○ Recall: 0.95
○ F1-Score: 0.95
● Model Decision Tree:
○ Akurasi: 0.925 (92.5%)
○ Presisi: 0.93
○ Recall: 0.92
○ F1-Score: 0.92

3. Kesimpulan Kinerja Model

Berdasarkan data yang telah diverifikasi, dapat disimpulkan bahwa

model SVM menunjukkan kinerja yang sedikit lebih unggul dibandingkan
model Decision Tree pada semua matrik evaluasi. Adapun nilai akurasi
100.00% yang tercatat diyakini sebagai anomali yang disebabkan oleh
kesalahan pada proses pencetakan hasil dalam kode program dan tidak
merepresentasikan kinerja model yang sebenarnya.

c. Perbandingan Percobaan 5 dan Percobaan 6

Kedua model, SVM dan Decision Tree, berhasil mengklasifikasikan data uji
dengan hasil sempurna, seperti yang ditunjukkan oleh matrix kekacauan di atas.
Dalam model SVM, dua puluh sampel sebenarnya kelas 0 yang diprediksi benar
sebagai kelas 0 dan dua puluh sampel kelas 1 yang diprediksi benar sebagai kelas 1.
Dalam Decision Tree, tidak ada sampel kelas 0 atau kelas 1 yang salah klasifikasi.
Ini
52
menunjukkan bahwa nilai Positif Benar dan Negatif Benar masing-masing adalah 20,
sedangkan nilai Negatif Benar dan Negatif sama sekali tidak ada (0). Dengan hasil
ini, akurasi, ketepatan, dan recall model kedua kelas mencapai tingkat sempurna.

● SVM Accuracy: Model Support Vector Machine mencapai akurasi sebesar

0.950%. Ini menunjukkan bahwa model SVM berhasil mengklasifikasikan
semua data uji dengan benar tanpa satupun kesalahan.
● Decision Tree Accuracy: Model Decision Tree juga mencapai akurasi
sebesar 0.925%. Ini berarti model Decision Tree juga berhasil
mengklasifikasikan semua data uji dengan sempurna.

53