# Menghubungkan Analisis Data Mining dengan Goggle Drive
from google.colab import drive
drive.mount('/content/drive')Mounted at /content/drive1 Business Understanding
1.1 Determine Business Objective
1.1.1 Background
Sebagai produk makanan khas Turki, kismis memiliki peran yang signifikan dalam industri produksi kismis secara global. Dalam upaya untuk meningkatkan efisiensi dan konsistensi dalam penilaian kualitas kismis yang saat ini memerlukan waktu dan dapat menghasilkan penilaian yang tidak konsisten, penelitian ini berfokus pada penggunaan teknik ekstraksi fitur morfologis dari dataset kismis.
Fitur morfologis yang diekstraksi dari dataset melibatkan karakteristik geometris dan struktural dari kismis, seperti area, panjang sumbu utama dan sumbu minor, eksentrisitas, dan parameter morfologi lainnya. Data ini kemudian dimanfaatkan untuk mengembangkan model klasifikasi menggunakan Logistic Regression (LR). Model ini diarahkan untuk mengklasifikasikan varietas kismis menjadi Kecimen dan Besni.
Dengan menerapkan pendekatan ini, diharapkan penelitian ini dapat memberikan solusi yang lebih cepat, efisien, dan konsisten dalam penilaian kualitas kismis. Hasil dari model Logistic Regression yang dikembangkan dapat menjadi langkah awal menuju otomatisasi proses penilaian kualitas kismis, yang dapat berdampak positif pada efisiensi industri produksi kismis secara global.
1.1.2 Business Objectives
- Membangun model Logistic Regression untuk mengklasifikasikan raisin berdasarkan fitur morfologis
- Pemilihan Logistic Regression sebagai model klasifikasi didasarkan pada keunggulannya dalam menangani masalah klasifikasi biner, yang sesuai dengan kebutuhan kita untuk mengklasifikasikan raisin menjadi dua varietas, yaitu Kecimen dan Besni. Keunggulan Logistic Regression terletak pada sederhananya, yang memudahkan interpretasi, dan kemampuannya memberikan hasil yang baik terutama ketika hubungan antara fitur dan variabel target bersifat logistik.
- Dengan menggunakan model Logistic Regression, kita dapat memastikan evaluasi kualitas raisin dilakukan secara efisien dan cepat. Hal ini penting dalam lingkungan industri di mana waktu sangat berharga, dan kecepatan evaluasi dapat meningkatkan efisiensi dalam proses produksi.
- Menyediakan solusi evaluasi kualitas raisin yang cepat dan konsisten
- Tujuan utama dari solusi ini adalah meningkatkan efisiensi dalam menilai kualitas raisin. Dengan memanfaatkan model Logistic Regression yang cepat dan konsisten, proses evaluasi dapat dilakukan dengan akurasi tinggi dan dalam waktu yang singkat. Hal ini akan memberikan manfaat signifikan dalam produksi massal raisin dan membantu dalam menjaga konsistensi kualitas produk.
1.1.3 Business Success Criteria
- Kemampuan model atau analisis untuk membedakan dengan baik antara varietas Kecimen dan Besni dengan minimal 80% akurasi: Pencapaian tingkat akurasi ini menjadi indikator yang memberikan keyakinan bahwa model dapat memberikan hasil yang dapat diandalkan dan bermanfaat secara praktis dalam aplikasinya.
- Reduksi waktu penilaian kualitas raisin dari metode tradisional: Salah satu tujuan utama dari proyek ini adalah untuk mengurangi waktu yang dibutuhkan dalam menilai kualitas raisin jika dibandingkan dengan metode tradisional. Metode tradisional mungkin melibatkan evaluasi manual yang memakan waktu, dan solusi berbasis model dapat memberikan keuntungan signifikan dalam hal efisiensi.
1.2 Asses Situation
1.2.1 Inventory of Resources
- Personel
- Independen, menggabungkan peran sebagai data analyst dan ahli bisnis
- Data
- Terdapat 900 butir kismis, dengan 450 butir dari varietas Kecimen dan 450 dari varietas Besni
- Data gambar telah mengalami tahap pra-pemrosesan dan ekstraksi fitur menghasilkan 7 fitur morfologi bertipe data numerik
- Sumber Daya Komputasi
- Google Colab digunakan sebagai platform untuk menjalankan algoritma data mining
- Scikit-learn library digunakan untuk eksekusi algoritma
- Perangkat Lunak * Posit cloud diimplementasikan untuk Final Report * Antarmuka pengguna diimplementasikan menggunakan Streamlit
1.2.2 Requirements, Assumptions & Constraints
- Persyaratan Proyek
- Kejelasan terhadap tujuan proyek, kriteria keberhasilan, dan kebutuhan data
- Standar kualitas hasil analisis
- Asumsi Proyek
- Asumsi tentang ketersediaan dan kualitas data
- Asumsi tentang karakteristik morfologi yang dapat dianalisis dari gambar raisin
- Asumsi bisnis terkait dengan pengelolaan varietas kismis
- Kendala Proyek
- Ketergantungan pada kualitas dataset
1.2.3 Risks and Contingencies
- Risiko Proyek: Kualitas data yang rendah atau tidak sesuai
- Kontinjensi: Pengembangan rencana untuk mengatasi risiko kualitas data dengan Data cleaning dan preprocessing tambahan
1.2.4 Terminology
- Glosarium Istilah Bisnis
- Varietas Kecimen dan Besni: Jenis kismis yang tumbuh di Turki.
- Morfologi: Karakteristik fisik dan bentuk dari gambar raisin.
- Proses pra-pemrosesan: Tahapan awal dalam persiapan data untuk analisis.
- Evaluasi kualitas: Proses penilaian untuk menilai sejauh mana hasil analisis atau model memenuhi standar atau kriteria tertentu, melibatkan aspek seperti akurasi, relevansi, dan keberhasilan terhadap tujuan bisnis.
- Glosarium Istilah Data Mining
- Ekstraksi Fitur Morfologi: Proses mengidentifikasi dan mengekstrak fitur-fitur penting dari gambar raisin.
- Algoritma Data Mining: Metode matematis dan statistik untuk menghasilkan model dari dataset.
- Evaluasi Model: Proses penilaian terhadap kinerja model data mining, mencakup pengukuran akurasi, presisi, recall, dan metrik lainnya untuk menentukan sejauh mana model dapat diandalkan dan efektif dalam menyelesaikan tugas yang dihadapi.
1.3 Determine Data Mining Goals
1.3.1 Data Mining Goals
- Menganalisis dataset raisin untuk mengidentifikasi perbedaan morfologi antara varietas Kecimen dan Besni
- Membangun model data mining yang dapat memprediksi varietas kismis berdasarkan fitur morfologi
- Mengembangkan model Logistic Regression untuk mengklasifikasikan varietas raisin berdasarkan fitur morfologis
- Mengevaluasi performa model berdasarkan kriteria keberhasilan teknis
1.3.2 Data Mining Success Criteria
- Akurasi prediksi model data mining mencapai akurasi minimal 80%
- Kemampuan model untuk mengidentifikasi dan memahami perbedaan morfologi yang signifikan
- Keterpenuhan persyaratan teknis
1.4 Produce Project Plan
1.4.1 Project Plan
- Business Understanding:
Fokus pada pemahaman mendalam tentang konteks bisnis dan tujuan proyekd dengan mengidentifikasi permasalahan yang ingin diselesaikan, peluang yang ingin dimanfaatkan, serta pemahaman menyeluruh tentang kebutuhan. Rencana proyek harus mencakup tujuan bisnis yang jelas, kendala-kendala yang mungkin dihadapi, dan kriteria keberhasilan.
- Data Understanding:
Melakukan eksplorasi awal terhadap data yang akan digunakan dalam proyek. Ini mencakup memahami struktur data, distribusi nilai-nilai, identifikasi potensi masalah seperti keberadaan nilai yang hilang. Tujuannya adalah untuk mendapatkan pemahaman yang kuat tentang karakteristik data yang dapat mempengaruhi langkah-langkah selanjutnya dalam proses analisis.
Data Preparation:
Melakukan seleksi, pembersihan, dan transformasi data untuk memastikan bahwa data siap digunakan dalam tahap pemodelan. Ini mencakup pemilihan atribut yang relevan, penanganan nilai-nilai yang hilang, dan transformasi data untuk memenuhi persyaratan teknis dari model yang akan dibangun.
Modeling (Logistic Regression):
Pemilihan dan penerapan model Logistik Regresi untuk melakukan klasifikasi varietas Kecimen dan Besni berdasarkan fitur morfologis raisin. Proses ini melibatkan pembagian data menjadi set pelatihan dan pengujian, pelatihan model pada data pelatihan, dan evaluasi performa model pada data pengujian.
Evaluasi Model:
Menilai performa model dengan menguji model pada dataset pengujian. Evaluasi melibatkan pengukuran akurasi, presisi, recall, dan metrik evaluasi lainnya sesuai dengan kebutuhan bisnis. Evaluasi ini memberikan wawasan tentang seberapa baik model dapat membedakan antara varietas Kecimen dan Besni.
Implementasi Streamlit:
Streamlit digunakan untuk membangun aplikasi web sederhana yang memungkinkan pengguna untuk dengan mudah memasukkan parameter, melakukan prediksi, dan melihat hasil dari model Logistic Regression. Implementasi ini membawa hasil model ke tingkat praktis yang dapat digunakan oleh pengguna non-teknis.
1.4.2 Initial Assessment of Tools, and Techniques
- Memilih Python sebagai bahasa pemrograman utama
- Menggunakan scikit-learn library untuk implementasi Logistic Regression
2 Data Understanding
2.1 Collect Initial Data
# Import Library
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns# Membaca dataset ke dalam DataFrame
data = pd.read_excel('/content/drive/MyDrive/psd/raisin/Raisin_Dataset.xlsx')2.1.1 Initial Data Collection Report
- Sumber data: Dataset raisin diperoleh dari sumber penelitian yang telah melalui tahap pra-pemrosesan dan ekstraksi fitur morfologi terhadap foto 900 butir kismis (450 dari varietas Kecimen dan 450 dari varietas Besni) dengan melakukan image processing
- Lokasi dataset: Turki
- Metode perolehan data: Pengunduhan dataset dari UCI Machine Learning (https://archive.ics.uci.edu/dataset/850/raisin)
- Masalah yang dihadapi: Tidak ada masalah yang dihadapi selama perolehan data
2.2 Describe Data
Raisin dataset diperoleh dari hasil Computer Vision System (CVS) dari gambar varietas kismis Kecimen dan Besni yang tumbuh di Turki. Sebanyak 900 butir kismis digunakan, dimana terdapat 450 butir dari setiap varietas tersebut. Gambar-gambar ini telah menjalani berbagai tahap pra-pemrosesan dan ekstraksi fitur yang menghasilkan 7 fitur morfologi.
2.2.1 Data Description Report
- Total 900 baris (450 Kecimen, 450 Besni), dengan 7 kolom atribut morfologis.
- Atribut meliputi Area, Perimeter, MajorAxisLength, MinorAxisLength, Eccentricity, ConvexArea, dan Extent.
- Data berupa nilai numerik yang mencerminkan atribut morfologis.
2.3 Explore Data
# Histogram masing-massing fitur
for column in data.columns:
if data[column].dtype != 'O': # Filter kolom fitur
plt.subplot(2, 2, 1)
plt.hist(data[column], bins=20, edgecolor='black')
plt.title(f'Histogram of {column}')
plt.tight_layout()
plt.show()
print("")
2.3.1 Data Exploration Report
Berdasarkan histogram masing-masing fitur, didapatkan distribusi positif dan negatif yang merujuk pada karakteristik bentuk distribusi data yang berkaitan dengan posisi rata-rata (mean) dan median. Dapat dijelaskan sebagai berikut:
- Distribusi Positif (Menjulur ke Kanan):
Nilai median lebih besar dari mean, yang mengindikasikan bahwa sebagian besar nilai cenderung lebih besar dari rata-rata. Fitur yang memiliki distribusi positif: Area, MajorAxisLength, MinorAxisLength, ConvexArea, Perimeter
- Distribusi Negatif (Menjulur ke Kiri):
Nilai mean atau rata-rata lebih besar dari median, yang menunjukkan adanya nilai-nilai kecil yang dapat mendorong rata-rata ke arah yang lebih tinggi, sementara median tetap pada nilai yang lebih rendah. Fitur yang memiliki distribusi negatif: Eccentricity dan Extent
2.4 Verify Data Quality
2.4.1 Informasi
Menampilkan informasi ringkas tentang DataFrame untuk mendapatkan gambaran umum tentang dataset, memeriksa tipe data, mendeteksi apakah ada nilai null, dan melihat seberapa besar memori yang digunakan.
# Menampilkan informasi ringkas tentang DataFrame
data.info()<class 'pandas.core.frame.DataFrame'>
RangeIndex: 900 entries, 0 to 899
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Area 900 non-null int64
1 MajorAxisLength 900 non-null float64
2 MinorAxisLength 900 non-null float64
3 Eccentricity 900 non-null float64
4 ConvexArea 900 non-null int64
5 Extent 900 non-null float64
6 Perimeter 900 non-null float64
7 Class 900 non-null object
dtypes: float64(5), int64(2), object(1)
memory usage: 56.4+ KB2.4.2 Missing Values
Mengecek apakah terdapat nilai yang hilang (missing value) pada kolom-kolom tertentu dalam DataFrame untuk memberikan pemahaman awal tentang seberapa banyak nilai yang hilang dalam setiap kolom pada dataset. Pengecekan nilai yang hilang adalah langkah penting dalam pra-pemrosesan data sebelum melakukan analisis lebih lanjut.
# Mengecek missing value pada setiap kolom
koloms = ['Area','MajorAxisLength','MinorAxisLength','Eccentricity','ConvexArea','Extent','Perimeter']
for kolom in koloms:
if data[kolom].isnull().any():
print(f'Terdapat missing value pada kolom {kolom}')
# Menampilkan indeks baris yang memiliki missing value
baris_missing = data[data[kolom].isnull()].index
print(f'Baris yang memiliki missing value: {baris_missing}')
else:
print(f'Tidak terdapat missing value pada kolom {kolom}')Tidak terdapat missing value pada kolom Area
Tidak terdapat missing value pada kolom MajorAxisLength
Tidak terdapat missing value pada kolom MinorAxisLength
Tidak terdapat missing value pada kolom Eccentricity
Tidak terdapat missing value pada kolom ConvexArea
Tidak terdapat missing value pada kolom Extent
Tidak terdapat missing value pada kolom Perimeter2.4.3 Outliers
Mendeteksi outlier dalam DataFrame menggunakan Z-Score sebagai metode deteksi. Deteksi outlier penting dalam analisis data karena nilai-nilai yang ekstrem atau tidak biasa dapat mempengaruhi hasil analisis secara signifikan. Pada umumnya, Z-Score digunakan untuk mengukur seberapa ekstrem suatu nilai dalam konteks distribusi data.
from scipy.stats import zscore
# Mendeteksi outlier menggunakan zscore dengan threshold Z-Score (misalnya, 3)
columns_to_check = ['Area', 'MajorAxisLength', 'MinorAxisLength', 'Eccentricity', 'ConvexArea', 'Extent', 'Perimeter']
z_scores = zscore(data[columns_to_check])
threshold = 3
outliers = (np.abs(z_scores) > threshold).any(axis=1)
# Menampilkan informasi tentang outlier
outlier_info = {
'values': data[outliers].values.tolist(),
'indices': data[outliers].index.tolist(),
'total': sum(outliers)
}
print(f"Outliers:")
print(f"Indices: {outlier_info['indices']}")
print(f"Values: {outlier_info['values']}")
print(f"Total outliers: {outlier_info['total']}")Outliers:
Indices: [13, 23, 34, 43, 85, 106, 156, 192, 197, 235, 251, 253, 290, 316, 356, 459, 483, 487, 490, 498, 506, 507, 536, 552, 579, 580, 581, 616, 668, 682, 694, 708, 769, 802, 804, 812, 829, 836, 866, 880]
Values: [[76792, 338.8575454, 291.3592017, 0.510583813, 78842, 0.772322237, 1042.77, 'Kecimen'], [61251, 301.5077895, 273.6599414, 0.419753707, 64732, 0.643595671, 971.769, 'Kecimen'], [46427, 253.8420284, 235.9068241, 0.369212459, 48275, 0.684219059, 844.312, 'Kecimen'], [92384, 368.4062138, 320.7145792, 0.492086934, 93772, 0.749006827, 1135.662, 'Kecimen'], [180898, 843.9566534, 323.1905688, 0.923770364, 221396, 0.454188929, 2253.557, 'Kecimen'], [48945, 269.3704112, 239.1621656, 0.460121209, 51456, 0.711244478, 872.289, 'Kecimen'], [45962, 251.1333844, 235.3680757, 0.348729642, 47173, 0.742280362, 810.195, 'Kecimen'], [37569, 232.4278475, 208.1520065, 0.44495009, 38874, 0.794371379, 734.102, 'Kecimen'], [86545, 350.1278744, 315.7195205, 0.432307345, 87512, 0.785886818, 1070.062, 'Kecimen'], [39716, 243.0382802, 210.1140569, 0.502579995, 40598, 0.779432833, 737.468, 'Kecimen'], [45598, 259.8962651, 225.6562198, 0.496118267, 47266, 0.741286253, 813.276, 'Kecimen'], [39439, 246.7636115, 212.635393, 0.507423663, 42795, 0.646827284, 793.005, 'Kecimen'], [136340, 722.8539172, 311.3413551, 0.902489762, 176818, 0.529774048, 2098.263, 'Kecimen'], [55746, 280.3131243, 254.6003304, 0.418381972, 56989, 0.730654294, 875.659, 'Kecimen'], [58460, 290.7535562, 258.3843539, 0.458544698, 60254, 0.774756149, 908.357, 'Kecimen'], [83107, 507.3808994, 233.1538498, 0.8881652, 93706, 0.491002009, 1367.331, 'Besni'], [92188, 374.7201638, 324.3025616, 0.500990716, 95920, 0.747599585, 1190.813, 'Besni'], [210923, 984.0454912, 367.2795321, 0.927737116, 278217, 0.507352075, 2697.753, 'Besni'], [171256, 531.3732054, 412.3828168, 0.630646744, 174277, 0.70191488, 1559.214, 'Besni'], [116406, 612.665318, 251.8328267, 0.911615194, 125638, 0.526259635, 1480.951, 'Besni'], [182160, 997.2919406, 271.8723954, 0.96212444, 221527, 0.379856115, 2303.69, 'Besni'], [208264, 675.0983445, 395.5792906, 0.810341407, 212813, 0.771748314, 1755.167, 'Besni'], [81604, 528.5858925, 204.7395131, 0.921939284, 87172, 0.491460095, 1299.386, 'Besni'], [204864, 596.6398018, 440.4971275, 0.674476207, 209457, 0.751009036, 1726.246, 'Besni'], [130868, 613.1726145, 273.1819147, 0.895270971, 134139, 0.536784249, 1513.352, 'Besni'], [206720, 713.4725493, 373.6425439, 0.851905369, 210114, 0.780576219, 1866.091, 'Besni'], [205497, 632.7276067, 414.1883255, 0.755968807, 209486, 0.76928865, 1736.839, 'Besni'], [199015, 615.4172359, 413.9274732, 0.740009433, 201464, 0.768569796, 1687.866, 'Besni'], [206689, 746.145341, 355.3006855, 0.879346962, 212569, 0.745808887, 1876.028, 'Besni'], [106923, 591.1158376, 234.8233464, 0.917708543, 111428, 0.522278775, 1425.109, 'Besni'], [172783, 820.724022, 352.1936798, 0.903244833, 219952, 0.496936979, 2289.889, 'Besni'], [222915, 731.5594062, 389.9466998, 0.84609325, 227170, 0.770542973, 1876.307, 'Besni'], [195281, 609.8297259, 408.5356188, 0.742435528, 197426, 0.769656124, 1639.103, 'Besni'], [71502, 490.4334789, 189.4429399, 0.922383026, 75157, 0.500546035, 1182.852, 'Besni'], [223075, 694.2475503, 411.810369, 0.805073466, 225916, 0.764940471, 1812.569, 'Besni'], [235047, 772.956877, 388.201507, 0.864734549, 239093, 0.711672732, 1942.05, 'Besni'], [127292, 639.8506348, 258.3819447, 0.914840211, 129101, 0.534714521, 1496.062, 'Besni'], [181126, 949.6626718, 293.386698, 0.951082244, 225592, 0.414153748, 2352.029, 'Besni'], [225043, 740.0037432, 390.3008576, 0.849597917, 229195, 0.744187354, 1853.893, 'Besni'], [218459, 571.2892031, 492.2752785, 0.507431838, 228259, 0.731973651, 1947.46, 'Besni']]
Total outliers: 40# Box Plot masing-massing fitur
for column in data.columns:
if data[column].dtype != 'O': # Filter kolom fitur
plt.subplot(2, 2, 1)
sns.boxplot(x=data[column])
plt.title(f'Boxplot of {column}')
plt.tight_layout()
plt.show()
2.4.4 Balance Data
Menghitung jumlah data yang ada dalam setiap kelas dengan tujuan untuk memberikan pemahaman tentang distribusi kelas dalam dataset. Dengan mengetahui berapa banyak sampel yang termasuk dalam setiap kelas, kita dapat memahami seimbang atau tidaknya distribusi kelas, yang dapat memengaruhi kinerja model pembelajaran mesin.
# Menghitung jumlah data per kelas
class_counts = data['Class'].value_counts()
print(class_counts)Kecimen 450
Besni 450
Name: Class, dtype: int64# Menampilkan bar plot jumlah data per kelas
plt.figure(figsize=(8, 6))
class_counts.plot(kind='bar', color='skyblue')
plt.title('Jumlah Data per Kelas')
plt.xlabel('Kelas')
plt.ylabel('Jumlah Data')
plt.show()
2.4.5 Data Quality Report
- Data lengkap: Data mencakup 900 butir kismis
- Missing values: Tidak ada nilai yang hilang dalam data
- Outliers: Terdapat 40 baris yang termasuk outlier dalam data
- Balance Data: Jumlah data setiap varietas sama besar sebanyak 450 data
3 Data Preparation
3.0.1 Dataset
Dataset yang dihasilkan oleh fase persiapan data terdiri yang telah melalui serangkaian langkah pemahaman untuk digunakan dalam pemodelan menggunakan Logistic Regression.
3.0.2 Dataset Description
- Area: Memberikan jumlah piksel dalam batas kismis.
- Perimeter: Mengukur lingkungan dengan menghitung jarak antara batas kismis dan piksel di sekitarnya.
- MajorAxisLength: Memberikan panjang sumbu utama, yaitu garis terpanjang yang dapat digambar di atas kismis.
- MinorAxisLength: Memberikan panjang sumbu kecil, yaitu garis terpendek yang dapat digambar di atas kismis.
- Eccentricity: Memberikan ukuran eksentrisitas elips, yang memiliki momen yang sama dengan kismis.
- ConvexArea: Memberikan jumlah piksel dari cangkang cembung terkecil dari wilayah yang dibentuk oleh kismis.
- Extent: Memberikan rasio wilayah yang dibentuk oleh kismis terhadap total piksel dalam kotak pembatas.
- Class: Kismis Kecimen dan Besni.
3.0.3 Tipe Data fitur:
- Rasio: Data ini memiliki titik nol yang bermakna (karena tidak dapat negatif), dan perbandingan antara dua nilainya memiliki arti yang jelas. Fitur yang termasuk, antara lain Area, Perimeter, MajorAxisLength, MinorAxisLength, ConvexArea, dan Extent.
- Interval: Memiliki rentang tertentu (biasanya antara 0 dan 1), tetapi tidak memiliki titik nol yang bermakna. Ini dianggap sebagai data interval karena dapat diukur dan diurutkan, tetapi perbandingan nilai mungkin tidak selalu bermakna. Fitur yang termasuk, adalah Eccentricity.
- Nominal: Class adalah data kategorikal tanpa tingkat ordinalitas atau urutan yang dapat diatribusikan ke kategori tersebut. Fitur yang termasuk, adalah Class.
3.1 Select Data
# Pisahkan data menjadi fitur (X) dan label (y)
X = data.drop('Class', axis=1)
y = data['Class']3.1.1 Pemilihan Fitur (Feature Selection) - Information Gain
from sklearn.feature_selection import mutual_info_classif
%matplotlib inline
# Menghitung mutual information
importances = mutual_info_classif(X, y)
# Membuat Series dari hasil perhitungan mutual information
feat_importances = pd.Series(importances, index=X.columns)
# Plot bar chart
feat_importances.plot(kind='barh', color='teal')
plt.xlabel('Mutual Information')
plt.show()
#Melihat nilai mutual information setiap fitur
for i, feature in enumerate(X.columns):
print(f"Mutual Information for {feature}: {importances[i]}")Mutual Information for Area: 0.278230363028674
Mutual Information for MajorAxisLength: 0.34834107401237
Mutual Information for MinorAxisLength: 0.13486920234749755
Mutual Information for Eccentricity: 0.12911725093005044
Mutual Information for ConvexArea: 0.29770777925523406
Mutual Information for Extent: 0.029344123584051918
Mutual Information for Perimeter: 0.3585072377567762#Melakukan drop fitur 'Extent'
data_dropExtent = data.drop('Extent', axis=1)
#Melakukan drop fitur 'Eccentricty' pada data yang telah drop fitur 'Extent'
data_dropEccent = data_dropExtent.drop('Eccentricity', axis=1)
#Melakukan drop fitur 'MinorAxisLength' pada data yang telah drop fitur 'Extent' dan 'Eccentricity'
data_dropMinor = data_dropEccent.drop('MinorAxisLength', axis=1)#Menegecek informasi data yang telah drop fitur 'Extent'
data_dropExtent.info()<class 'pandas.core.frame.DataFrame'>
RangeIndex: 900 entries, 0 to 899
Data columns (total 7 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Area 900 non-null int64
1 MajorAxisLength 900 non-null float64
2 MinorAxisLength 900 non-null float64
3 Eccentricity 900 non-null float64
4 ConvexArea 900 non-null int64
5 Perimeter 900 non-null float64
6 Class 900 non-null object
dtypes: float64(4), int64(2), object(1)
memory usage: 49.3+ KB#Menegecek informasi data yang telah drop fitur 'Extent' dan 'Eccentricity'
data_dropEccent.info()<class 'pandas.core.frame.DataFrame'>
RangeIndex: 900 entries, 0 to 899
Data columns (total 6 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Area 900 non-null int64
1 MajorAxisLength 900 non-null float64
2 MinorAxisLength 900 non-null float64
3 ConvexArea 900 non-null int64
4 Perimeter 900 non-null float64
5 Class 900 non-null object
dtypes: float64(3), int64(2), object(1)
memory usage: 42.3+ KB#Menegecek informasi data yang telah drop fitur 'Extent', 'Eccentricity', dan 'MinorAxisLength'
data_dropMinor.info()<class 'pandas.core.frame.DataFrame'>
RangeIndex: 900 entries, 0 to 899
Data columns (total 5 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Area 900 non-null int64
1 MajorAxisLength 900 non-null float64
2 ConvexArea 900 non-null int64
3 Perimeter 900 non-null float64
4 Class 900 non-null object
dtypes: float64(2), int64(2), object(1)
memory usage: 35.3+ KBJadi sekarang terdapat 4 data yang akan dilakukan pemrosesan selanjutnya: 1. Data awal dengan fitur lengkap (Area, Perimeter, MajorAxisLength, MinorAxisLength, Eccentricity, ConvexArea, Extent) yang tersimpan dalam variabel data 2. Data setelah drop fitur ‘Extent’ (Area, Perimeter, MajorAxisLength, MinorAxisLength, Eccentricity, ConvexArea) yang tersimpan dalam variabel data_dropExtent 3. Data setelah drop fitur ‘Eccentricity’ (Area, Perimeter, MajorAxisLength, MinorAxisLength, ConvexArea) yang tersimpan dalam variabel data_dropEccent 4. Data setelah drop fitur ‘MinorAxisLength’ (Area, Perimeter, MajorAxisLength, ConvexArea) yang tersimpan dalam variabel data_dropMinor
3.1.2 Rationale for Inclusion/Exclusion
- Inklusi: Seluruh dataset raisin termasuk karena relevan dengan tujuan data mining dan memiliki kualitas yang baik. Dipilih atribut morfologis yang relevan untuk klasifikasi raisin dengan melakukan drop fitur satu persatu dimulai dari nilai mutual information terendah:
- Extent
- Eccentricity
- MinorAxisLength
Jika dengan melakukan drop fitur ini mempengaruhi akurasi, maka akan dipilih semua atribut untuk klasifikasi raisin (Area, Perimeter, MajorAxisLength, MinorAxisLength, Eccentricity, ConvexArea, Extent). * Eksklusi: Tidak ada eksklusi data karena dataset lengkap dan relevan. Tidak ada data yang dihapus, hanya beberapa outlier diatasi dengan 2 cara yaitu menghapus data tersebut dan pengisian nilai tengah (median). Dilakukan 2 metode ini untuk melihat pengaruh terhadap akurasi klasifikasi.
3.2 Clean Data
3.2.1 Mengatasi Outlier
3.2.1.1 Menghapus Outlier
# Menghapus baris yang mengandung outlier pada 4 data
data_dropOutlier = data[~outliers]
data_dropExtent_dropOutlier = data_dropExtent[~outliers]
data_dropEccent_dropOutlier = data_dropEccent[~outliers]
data_dropMinor_dropOutlier = data_dropMinor[~outliers]# Menghitung jumlah data per kelas setelah pengapusan outlier pada data
class_counts = data_dropOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 435
Besni 425
Name: Class, dtype: int64# Menghitung jumlah data per kelas setelah pengapusan outlier pada data drop fitur Extent
class_counts = data_dropExtent_dropOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 435
Besni 425
Name: Class, dtype: int64# Menghitung jumlah data per kelas setelah pengapusan outlier pada data drop fitur Eccentricity
class_counts = data_dropEccent_dropOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 435
Besni 425
Name: Class, dtype: int64# Menghitung jumlah data per kelas setelah pengapusan outlier pada data drop fitur MinorAxisLength
class_counts = data_dropMinor_dropOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 435
Besni 425
Name: Class, dtype: int64# Pisahkan data setelah penghapusan outlier menjadi fitur (X) dan label (y)
X_dropOutlier = data_dropOutlier.drop('Class', axis=1)
y_dropOutlier = data_dropOutlier['Class']# Pisahkan data drop Extent setelah penghapusan outlier menjadi fitur (X) dan label (y)
X_dropExtent_dropOutlier = data_dropExtent_dropOutlier.drop('Class', axis=1)
y_dropExtent_dropOutlier = data_dropExtent_dropOutlier['Class']# Pisahkan data drop Eccentricity setelah penghapusan outlier menjadi fitur (X) dan label (y)
X_dropEccent_dropOutlier = data_dropEccent_dropOutlier.drop('Class', axis=1)
y_dropEccent_dropOutlier = data_dropEccent_dropOutlier['Class']# Pisahkan data drop MinorAxisLength setelah penghapusan outlier menjadi fitur (X) dan label (y)
X_dropMinor_dropOutlier = data_dropMinor_dropOutlier.drop('Class', axis=1)
y_dropMinor_dropOutlier = data_dropMinor_dropOutlier['Class']3.2.1.2 Mengganti Outlier Dengan Nilai Median
data_revalueOutlier = data
columns = (data_revalueOutlier.drop('Class', axis=1)).columns
# Menggantikan nilai outlier dengan median pada data
for column in columns:
median_value = data[column].median()
data_revalueOutlier.loc[outliers, column] = median_valuedata_dropExtent_revalueOutlier = data_dropExtent
columns = (data_dropExtent_revalueOutlier.drop('Class', axis=1)).columns
# Menggantikan nilai outlier dengan median pada data drop Extent
for column in columns:
median_value = data[column].median()
data_dropExtent_revalueOutlier.loc[outliers, column] = median_valuedata_dropEccent_revalueOutlier = data_dropEccent
columns = (data_dropEccent_revalueOutlier.drop('Class', axis=1)).columns
# Menggantikan nilai outlier dengan median pada data drop Eccentricity
for column in columns:
median_value = data[column].median()
data_dropEccent_revalueOutlier.loc[outliers, column] = median_valuedata_dropMinor_revalueOutlier = data_dropMinor
columns = (data_dropMinor_revalueOutlier.drop('Class', axis=1)).columns
# Menggantikan nilai outlier dengan median pada data drop MinorAxisLength
for column in columns:
median_value = data[column].median()
data_dropMinor_revalueOutlier.loc[outliers, column] = median_value# Menghitung jumlah data per kelas setelah mengganti nilai outlier dengan median pada data
class_counts = data_revalueOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 450
Besni 450
Name: Class, dtype: int64# Menghitung jumlah data per kelas setelah mengganti nilai outlier dengan median pada data drop Extent
class_counts = data_dropExtent_revalueOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 450
Besni 450
Name: Class, dtype: int64# Menghitung jumlah data per kelas setelah mengganti nilai outlier dengan median pada data drop Eccentricity
class_counts = data_dropEccent_revalueOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 450
Besni 450
Name: Class, dtype: int64# Menghitung jumlah data per kelas setelah mengganti nilai outlier dengan median pada data drop MinorAxisLength
class_counts = data_dropMinor_revalueOutlier['Class'].value_counts()
# Menampilkan hasil
print(class_counts)Kecimen 450
Besni 450
Name: Class, dtype: int64# Pisahkan data setelah penggantian nilai outlier menjadi fitur (X) dan label (y)
X_revalueOutlier = data_revalueOutlier.drop('Class', axis=1)
y_revalueOutlier = data_revalueOutlier['Class']# Pisahkan data drop Extent setelah penggantian nilai outlier menjadi fitur (X) dan label (y)
X_dropExtent_revalueOutlier = data_dropExtent_revalueOutlier.drop('Class', axis=1)
y_dropExtent_revalueOutlier = data_dropExtent_revalueOutlier['Class']# Pisahkan data drop Eccentricity setelah penggantian nilai outlier menjadi fitur (X) dan label (y)
X_dropEccent_revalueOutlier = data_dropEccent_revalueOutlier.drop('Class', axis=1)
y_dropEccent_revalueOutlier = data_dropEccent_revalueOutlier['Class']# Pisahkan data drop MinorAxisLength setelah penggantian nilai outlier menjadi fitur (X) dan label (y)
X_dropMinor_revalueOutlier = data_dropMinor_revalueOutlier.drop('Class', axis=1)
y_dropMinor_revalueOutlier = data_dropMinor_revalueOutlier['Class']Sekarang terdapat 8 variabel data yang akan dilakukan pemrosesan selanjutnya, yaitu
- Data setelah penghapusan outlier
- Data setelah penggantian nilai outlier dengan nilai median
- Data drop extent setelah penghapusan outlier
- Data drop extent setelah penggantian nilai outlier dengan nilai median
- Data drop eccentricity setelah penghapusan outlier
- Data drop eccentricity setelah penggantian nilai outlier dengan nilai median
- Data drop MinorAxisLength setelah penghapusan outlier
- Data drop MinorAxisLength setelah penggantian nilai outlier dengan nilai median
3.2.2 Data Cleaning Report
- Pembersihan data melibatkan penanganan masalah kualitas data yang diidentifikasi sebelumnya.
- Tidak ada nilai yang hilang, dan data cukup bersih; oleh karena itu, tindakan pembersihan minimal diperlukan.
- Terdapat 40 data outlier yang telah diatasi dengan 2 metode, yaitu penghapusan baris outlier dan penggantian nilai outlier dengan nilai median
- Data seimbang. Meskipun dilakukan penghapusan baris outlier sekalipun, data berubah tidak secara signifikan dan masih dibilang cukup untuk dikatakan seimbang
- Dampak Potensial: Meningkatkan kualitas data dan mengurangi potensi distorsi hasil akibat ketidakseimbangan atau outlier.
3.3 Construct Data
3.3.1 Normalisasi
Normalisasi adalah proses mengubah nilai-nilai dalam suatu dataset ke dalam skala yang seragam. Dua metode normalisasi yang umum digunakan adalah Z-Score (Standard Score) dan Min-Max Scaling.
3.3.1.1 Normalisasi Z-score
Rumus Normalisasi menggunakan StandardScaler:
\([ X_{\text{normalized}} = \frac{X - \mu}{\sigma} ]\)
Keterangan: - \(X_{\text{normalized}}\) : Data yang telah dinormalisasi - \(X\) : Data asli - \(\mu\) : Rata-rata dari (X) - \(\sigma\) : Deviasi standar dari (X)
Contoh: Misalkan kita memiliki dataset: \([10, 15, 20, 25, 30]\)
Langkah-langkah normalisasi Z-Score:
Rata-rata (\(\mu\)) dan deviasi standar (\(\sigma\)) dari dataset:
$ = = 20 $
$ = $
Z-Score untuk setiap nilai dalam dataset:
$ Z = $
- Untuk $( X = 10 $): $( Z = $)
- Untuk $( X = 15 $): $( Z = $)
- Untuk $( X = 20 $): $( Z = $)
- Untuk $( X = 25 $): $( Z = $)
- Untuk $( X = 30 $): $( Z = $)
from sklearn.preprocessing import StandardScaler
# Normalisasi Z-Score
scaler_standard_dO = StandardScaler()
scaler_standard_dEx_dO = StandardScaler()
scaler_standard_dEc_dO = StandardScaler()
scaler_standard_dMi_dO = StandardScaler()
scaler_standard_rO = StandardScaler()
scaler_standard_dEx_rO = StandardScaler()
scaler_standard_dEc_rO = StandardScaler()
scaler_standard_dMi_rO = StandardScaler()Note:
Karena terdapat 8 variabel atau 8 data berbeda yang akan dinormalisasi, maka diinisialisasikan scaler untuk normalisasi sebanyak 8.
3.3.1.1.1 Normalisasi Zscore pada Data Tanpa Outlier dengan menghapus outlier tersebut
X_dropOutlier_standard_normalized = scaler_standard_dO.fit_transform(X_dropOutlier)
X_dropExtent_dropOutlier_standard_normalized= scaler_standard_dEx_dO.fit_transform(X_dropExtent_dropOutlier)
X_dropEccent_dropOutlier_standard_normalized= scaler_standard_dEc_dO.fit_transform(X_dropEccent_dropOutlier)
X_dropMinor_dropOutlier_standard_normalized= scaler_standard_dMi_dO.fit_transform(X_dropMinor_dropOutlier)3.3.1.1.2 Normalisasi Zscore pada Data tanpa outlier dengan mengganti nilai outlier menjadi nilai median
X_revalueOutlier_standard_normalized = scaler_standard_rO.fit_transform(X_revalueOutlier)
X_dropExtent_revalueOutlier_standard_normalized= scaler_standard_dEx_rO.fit_transform(X_dropExtent_revalueOutlier)
X_dropEccent_revalueOutlier_standard_normalized= scaler_standard_dEc_rO.fit_transform(X_dropEccent_revalueOutlier)
X_dropMinor_revalueOutlier_standard_normalized= scaler_standard_dMi_rO.fit_transform(X_dropMinor_revalueOutlier)3.3.1.2 Normalisai Minmax
Rumus Normalisasi menggunakan Min-Max Scaling:
$ = $
- $X $: Nilai pada dataset
- \(\text{min}\): Nilai minimum dari dataset
- \(\text{max}\): Nilai maksimum dari dataset
Contoh: Menggunakan dataset yang sama: \([10, 15, 20, 25, 30]\)
Langkah-langkah: 1. Temukan nilai minimum (\(\text{min}\)) dan nilai maksimum (\(\text{max}\)) dari dataset. - \(\text{min} = 10\) - \(\text{max} = 30\)
Hitung Min-Max Scaling untuk setiap nilai dalam dataset:
$ = $
- Untuk $( X = 10 $): $( = 0 $)
- Untuk $( X = 15 $): $( = 0.25 $)
- Untuk $( X = 20 $): $( = 0.5 $)
- Untuk $( X = 25 $): $( = 0.75 $)
- Untuk $( X = 30 $): $( = 1 $)
from sklearn.preprocessing import MinMaxScaler
# Normalisasi Minmax
scaler_minmax_dO = MinMaxScaler()
scaler_minmax_dEx_dO = MinMaxScaler()
scaler_minmax_dEc_dO = MinMaxScaler()
scaler_minmax_dMi_dO = MinMaxScaler()
scaler_minmax_rO = MinMaxScaler()
scaler_minmax_dEx_rO = MinMaxScaler()
scaler_minmax_dEc_rO = MinMaxScaler()
scaler_minmax_dMi_rO = MinMaxScaler()Note:
Karena terdapat 8 variabel atau 8 data berbeda yang akan dinormalisasi, maka diinisialisasikan scaler untuk normalisasi sebanyak 8.
3.3.1.2.1 Normalisasi Minmax pada Data Tanpa Outlier dengan menghapus outlier tersebut
X_dropOutlier_minmax_normalized = scaler_minmax_dO.fit_transform(X_dropOutlier)
X_dropExtent_dropOutlier_minmax_normalized= scaler_minmax_dEx_dO.fit_transform(X_dropExtent_dropOutlier)
X_dropEccent_dropOutlier_minmax_normalized= scaler_minmax_dEc_dO.fit_transform(X_dropEccent_dropOutlier)
X_dropMinor_dropOutlier_minmax_normalized= scaler_minmax_dMi_dO.fit_transform(X_dropMinor_dropOutlier)3.3.1.2.2 Normalisasi Minmax pada Data tanpa outlier dengan mengganti nilai outlier menjadi nilai median
X_revalueOutlier_minmax_normalized = scaler_minmax_rO.fit_transform(X_revalueOutlier)
X_dropExtent_revalueOutlier_minmax_normalized= scaler_minmax_dEx_rO.fit_transform(X_dropExtent_revalueOutlier)
X_dropEccent_revalueOutlier_minmax_normalized= scaler_minmax_dEc_rO.fit_transform(X_dropEccent_revalueOutlier)
X_dropMinor_revalueOutlier_minmax_normalized= scaler_minmax_dMi_rO.fit_transform(X_dropMinor_revalueOutlier)4 Modeling
4.1 Select Modeling Techniques
4.1.1 Modeling Technique
Pemilihan teknik pemodelan menggunakan algoritma Logistic Regression untuk klasifikasi varietas kismis. Dengan 16 variabel atau data yang berbeda yang akan dilakukan modeling.
4.2 Generate Test Design
Dataset akan dibagi menjadi dua bagian: set pelatihan (80% dari data) dan set uji (20% dari data). Model akan dilatih pada set pelatihan dan diuji pada set uji untuk mengevaluasi kinerja dan generalisasi.
from sklearn.model_selection import train_test_split4.2.1 Pembagian dataset menjadi set pelatihan dan set pengujian pada data dengan normalisasi Zscore
# Pisahkan data menjadi set pelatihan dan set pengujian
# Pisahkan data setelah penghapusan outlier
X_dO_std_train, X_dO_std_test, y_dO_std_train, y_dO_std_test = train_test_split(X_dropOutlier_standard_normalized, y_dropOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Extent setelah penghapusan outlier
X_dEx_dO_std_train, X_dEx_dO_std_test, y_dEx_dO_std_train, y_dEx_dO_std_test = train_test_split(X_dropExtent_dropOutlier_standard_normalized, y_dropExtent_dropOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Eccentricity setelah penghapusan outlier
X_dEc_dO_std_train, X_dEc_dO_std_test, y_dEc_dO_std_train, y_dEc_dO_std_test = train_test_split(X_dropEccent_dropOutlier_standard_normalized, y_dropEccent_dropOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop MinorAxisLength setelah penghapusan outlier
X_dMi_dO_std_train, X_dMi_dO_std_test, y_dMi_dO_std_train, y_dMi_dO_std_test = train_test_split(X_dropMinor_dropOutlier_standard_normalized, y_dropMinor_dropOutlier, test_size=0.2, random_state=42)# Pisahkan data menjadi set pelatihan dan set pengujian
# Pisahkan data setelah penggantian nilai outlier dengan nilai median
X_rO_std_train, X_rO_std_test, y_rO_std_train, y_rO_std_test = train_test_split(X_revalueOutlier_standard_normalized, y_revalueOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Extent setelah penggantian nilai outlier dengan nilai median
X_dEx_rO_std_train, X_dEx_rO_std_test, y_dEx_rO_std_train, y_dEx_rO_std_test = train_test_split(X_dropExtent_revalueOutlier_standard_normalized, y_dropExtent_revalueOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Eccentricity setelah penggantian nilai outlier dengan nilai median
X_dEc_rO_std_train, X_dEc_rO_std_test, y_dEc_rO_std_train, y_dEc_rO_std_test = train_test_split(X_dropEccent_revalueOutlier_standard_normalized, y_dropEccent_revalueOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop MinorAxisLength setelah penggantian nilai outlier dengan nilai median
X_dMi_rO_std_train, X_dMi_rO_std_test, y_dMi_rO_std_train, y_dMi_rO_std_test = train_test_split(X_dropMinor_revalueOutlier_standard_normalized, y_dropMinor_revalueOutlier, test_size=0.2, random_state=42)4.2.2 Pembagian dataset menjadi set pelatihan dan set pengujian pada data dengan normalisasi Minmax
# Pisahkan data menjadi set pelatihan dan set pengujian
# Pisahkan data setelah penghapusan outlier
X_dO_mmx_train, X_dO_mmx_test, y_dO_mmx_train, y_dO_mmx_test = train_test_split(X_dropOutlier_minmax_normalized, y_dropOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Extent setelah penghapusan outlier
X_dEx_dO_mmx_train, X_dEx_dO_mmx_test, y_dEx_dO_mmx_train, y_dEx_dO_mmx_test = train_test_split(X_dropExtent_dropOutlier_minmax_normalized, y_dropExtent_dropOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Eccentricity setelah penghapusan outlier
X_dEc_dO_mmx_train, X_dEc_dO_mmx_test, y_dEc_dO_mmx_train, y_dEc_dO_mmx_test = train_test_split(X_dropEccent_dropOutlier_minmax_normalized, y_dropEccent_dropOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop MinorAxisLength setelah penghapusan outlier
X_dMi_dO_mmx_train, X_dMi_dO_mmx_test, y_dMi_dO_mmx_train, y_dMi_dO_mmx_test = train_test_split(X_dropMinor_dropOutlier_minmax_normalized, y_dropMinor_dropOutlier, test_size=0.2, random_state=42)# Pisahkan data menjadi set pelatihan dan set pengujian
# Pisahkan data setelah penggantian nilai outlier dengan nilai median
X_rO_mmx_train, X_rO_mmx_test, y_rO_mmx_train, y_rO_mmx_test = train_test_split(X_revalueOutlier_minmax_normalized, y_revalueOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Extent setelah penggantian nilai outlier dengan nilai median
X_dEx_rO_mmx_train, X_dEx_rO_mmx_test, y_dEx_rO_mmx_train, y_dEx_rO_mmx_test = train_test_split(X_dropExtent_revalueOutlier_minmax_normalized, y_dropExtent_revalueOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop Eccentricity setelah penggantian nilai outlier dengan nilai median
X_dEc_rO_mmx_train, X_dEc_rO_mmx_test, y_dEc_rO_mmx_train, y_dEc_rO_mmx_test = train_test_split(X_dropEccent_revalueOutlier_minmax_normalized, y_dropEccent_revalueOutlier, test_size=0.2, random_state=42)
# Pisahkan data drop MinorAxisLength setelah penggantian nilai outlier dengan nilai median
X_dMi_rO_mmx_train, X_dMi_rO_mmx_test, y_dMi_rO_mmx_train, y_dMi_rO_mmx_test = train_test_split(X_dropMinor_revalueOutlier_minmax_normalized, y_dropMinor_revalueOutlier, test_size=0.2, random_state=42)4.2.3 Test Design
4.3 Build Model
from sklearn.linear_model import LogisticRegression4.3.1 Models
logisticRegression_model = LogisticRegression()Membuat objek model Regresi Logistik dengan menggunakan kelas LogisticRegression() dari scikit-learn. Pada tahap ini, model belum dilatih, dan parameter default dari model akan digunakan.
logisticRegression_model.fit(X_train, y_train)Melatih model Regresi Logistik dengan menggunakan fungsi fit(). X_train adalah matriks fitur dari set pelatihan, dan y_train adalah vektor label yang sesuai. Selama pelatihan, model akan menyesuaikan bobot dan biasnya (parameter) untuk mendekati pola dalam data pelatihan.
y_trainPred = logisticRegression_model.predict(X_train)Menggunakan model yang telah dilatih untuk membuat prediksi pada set pelatihan (X_train). Hasil prediksi disimpan dalam variabel y_trainPred. Ini memungkinkan kita untuk mengevaluasi sejauh mana model mampu memprediksi data yang telah dilihat selama pelatihan.
y_pred = logisticRegression_model.predict(X_test)Sama seperti sebelumnya, namun kali ini kita menggunakan model untuk membuat prediksi pada set pengujian (X_test). Hasil prediksi disimpan dalam variabel y_pred. Ini memungkinkan kita untuk mengevaluasi kinerja model pada data yang belum pernah dilihat selama pelatihan.
Dengan menggunakan model yang telah dilatih, kita dapat membandingkan prediksi dengan label yang sebenarnya untuk mengukur kinerja model menggunakan berbagai metrik evaluasi seperti akurasi, presisi, recall, dan F1 score. Metrik-metrik ini memberikan wawasan tentang seberapa baik model dapat mengklasifikasikan data.
4.3.1.1 Menggunakan Data Setelah Penghapusan Outlier
4.3.1.1.1 Telah dinormalisasi menggunakan Zscore
# Membuat model Regresi Logistik
LR_dO_std = LogisticRegression()
# Melatih model
LR_dO_std.fit(X_dO_std_train, y_dO_std_train)
#Melakukan prediksi set pelatihan
y_dO_std_trainPred = LR_dO_std.predict(X_dO_std_train)
# Melakukan prediksi set pengujian
y_dO_std_pred = LR_dO_std.predict(X_dO_std_test)# Membuat model Regresi Logistik
LR_dEx_dO_std = LogisticRegression()
# Melatih model
LR_dEx_dO_std.fit(X_dEx_dO_std_train, y_dEx_dO_std_train)
#Melakukan prediksi set pelatihan
y_dEx_dO_std_trainPred = LR_dEx_dO_std.predict(X_dEx_dO_std_train)
# Melakukan prediksi set pengujian
y_dEx_dO_std_pred = LR_dEx_dO_std.predict(X_dEx_dO_std_test)# Membuat model Regresi Logistik
LR_dEc_dO_std = LogisticRegression()
# Melatih model
LR_dEc_dO_std.fit(X_dEc_dO_std_train, y_dEc_dO_std_train)
#Melakukan prediksi set pelatihan
y_dEc_dO_std_trainPred = LR_dEc_dO_std.predict(X_dEc_dO_std_train)
# Melakukan prediksi set pengujian
y_dEc_dO_std_pred = LR_dEc_dO_std.predict(X_dEc_dO_std_test)# Membuat model Regresi Logistik
LR_dMi_dO_std = LogisticRegression()
# Melatih model
LR_dMi_dO_std.fit(X_dMi_dO_std_train, y_dMi_dO_std_train)
#Melakukan prediksi set pelatihan
y_dMi_dO_std_trainPred = LR_dMi_dO_std.predict(X_dMi_dO_std_train)
# Melakukan prediksi set pengujian
y_dMi_dO_std_pred = LR_dMi_dO_std.predict(X_dMi_dO_std_test)4.3.1.1.2 Telah dinormalisasi menggunakan Minmax
# Membuat model Regresi Logistik
LR_dO_mmx = LogisticRegression()
# Melatih model
LR_dO_mmx.fit(X_dO_mmx_train, y_dO_mmx_train)
#Melakukan prediksi set pelatihan
y_dO_mmx_trainPred = LR_dO_mmx.predict(X_dO_mmx_train)
# Melakukan prediksi set pengujian
y_dO_mmx_pred = LR_dO_mmx.predict(X_dO_mmx_test)# Membuat model Regresi Logistik
LR_dEx_dO_mmx = LogisticRegression()
# Melatih model
LR_dEx_dO_mmx.fit(X_dEx_dO_mmx_train, y_dEx_dO_mmx_train)
#Melakukan prediksi set pelatihan
y_dEx_dO_mmx_trainPred = LR_dEx_dO_mmx.predict(X_dEx_dO_mmx_train)
# Melakukan prediksi set pengujian
y_dEx_dO_mmx_pred = LR_dEx_dO_mmx.predict(X_dEx_dO_mmx_test)# Membuat model Regresi Logistik
LR_dEc_dO_mmx = LogisticRegression()
# Melatih model
LR_dEc_dO_mmx.fit(X_dEc_dO_mmx_train, y_dEc_dO_mmx_train)
#Melakukan prediksi set pelatihan
y_dEc_dO_mmx_trainPred = LR_dEc_dO_mmx.predict(X_dEc_dO_mmx_train)
# Melakukan prediksi set pengujian
y_dEc_dO_mmx_pred = LR_dEc_dO_mmx.predict(X_dEc_dO_mmx_test)# Membuat model Regresi Logistik
LR_dMi_dO_mmx = LogisticRegression()
# Melatih model
LR_dMi_dO_mmx.fit(X_dMi_dO_mmx_train, y_dMi_dO_mmx_train)
#Melakukan prediksi set pelatihan
y_dMi_dO_mmx_trainPred = LR_dMi_dO_mmx.predict(X_dMi_dO_mmx_train)
# Melakukan prediksi set pengujian
y_dMi_dO_mmx_pred = LR_dMi_dO_mmx.predict(X_dMi_dO_mmx_test)4.3.1.2 Menggunakan Data Setelah Penggantian Nilai Outlier Dengan Nilai Median
4.3.1.2.1 Telah dinormalisasi menggunakan Zscore
# Membuat model Regresi Logistik
LR_rO_std = LogisticRegression()
# Melatih model
LR_rO_std.fit(X_rO_std_train, y_rO_std_train)
#Melakukan prediksi set pelatihan
y_rO_std_trainPred = LR_rO_std.predict(X_rO_std_train)
# Melakukan prediksi set pengujian
y_rO_std_pred = LR_rO_std.predict(X_rO_std_test)# Membuat model Regresi Logistik
LR_dEx_rO_std = LogisticRegression()
# Melatih model
LR_dEx_rO_std.fit(X_dEx_rO_std_train, y_dEx_rO_std_train)
#Melakukan prediksi set pelatihan
y_dEx_rO_std_trainPred = LR_dEx_rO_std.predict(X_dEx_rO_std_train)
# Melakukan prediksi set pengujian
y_dEx_rO_std_pred = LR_dEx_rO_std.predict(X_dEx_rO_std_test)# Membuat model Regresi Logistik
LR_dEc_rO_std = LogisticRegression()
# Melatih model
LR_dEc_rO_std.fit(X_dEc_rO_std_train, y_dEc_rO_std_train)
#Melakukan prediksi set pelatihan
y_dEc_rO_std_trainPred = LR_dEc_rO_std.predict(X_dEc_rO_std_train)
# Melakukan prediksi set pengujian
y_dEc_rO_std_pred = LR_dEc_rO_std.predict(X_dEc_rO_std_test)# Membuat model Regresi Logistik
LR_dMi_rO_std = LogisticRegression()
# Melatih model
LR_dMi_rO_std.fit(X_dMi_rO_std_train, y_dMi_rO_std_train)
#Melakukan prediksi set pelatihan
y_dMi_rO_std_trainPred = LR_dMi_rO_std.predict(X_dMi_rO_std_train)
# Melakukan prediksi set pengujian
y_dMi_rO_std_pred = LR_dMi_rO_std.predict(X_dMi_rO_std_test)4.3.1.2.2 Telah dinormalisasi menggunakan Minmax
# Membuat model Regresi Logistik
LR_rO_mmx = LogisticRegression()
# Melatih model
LR_rO_mmx.fit(X_rO_mmx_train, y_rO_mmx_train)
#Melakukan prediksi set pelatihan
y_rO_mmx_trainPred = LR_rO_mmx.predict(X_rO_mmx_train)
# Melakukan prediksi set pengujian
y_rO_mmx_pred = LR_rO_mmx.predict(X_rO_mmx_test)# Membuat model Regresi Logistik
LR_dEx_rO_mmx = LogisticRegression()
# Melatih model
LR_dEx_rO_mmx.fit(X_dEx_rO_mmx_train, y_dEx_rO_mmx_train)
#Melakukan prediksi set pelatihan
y_dEx_rO_mmx_trainPred = LR_dEx_rO_mmx.predict(X_dEx_rO_mmx_train)
# Melakukan prediksi set pengujian
y_dEx_rO_mmx_pred = LR_dEx_rO_mmx.predict(X_dEx_rO_mmx_test)# Membuat model Regresi Logistik
LR_dEc_rO_mmx = LogisticRegression()
# Melatih model
LR_dEc_rO_mmx.fit(X_dEc_rO_mmx_train, y_dEc_rO_mmx_train)
#Melakukan prediksi set pelatihan
y_dEc_rO_mmx_trainPred = LR_dEc_rO_mmx.predict(X_dEc_rO_mmx_train)
# Melakukan prediksi set pengujian
y_dEc_rO_mmx_pred = LR_dEc_rO_mmx.predict(X_dEc_rO_mmx_test)# Membuat model Regresi Logistik
LR_dMi_rO_mmx = LogisticRegression()
# Melatih model
LR_dMi_rO_mmx.fit(X_dMi_rO_mmx_train, y_dMi_rO_mmx_train)
#Melakukan prediksi set pelatihan
y_dMi_rO_mmx_trainPred = LR_dMi_rO_mmx.predict(X_dMi_rO_mmx_train)
# Melakukan prediksi set pengujian
y_dMi_rO_mmx_pred = LR_dMi_rO_mmx.predict(X_dMi_rO_mmx_test)4.3.2 Model Description
Logistic Regression adalah algoritma Machine Learning yang digunakan untuk masalah klasifikasi (Supervised Learning). Ini adalah algoritma analisis prediktif yang didasarkan pada konsep probabilitas.
\[\begin{equation} P(Y=1) = \frac{1}{1 + e^{-(\beta_0 + \beta_1 X_1 + \beta_2 X_2 + \ldots + \beta_n X_n)}} \end{equation}\]
\(P(Y=1)\) adalah probabilitas bahwa variabel dependen \(Y\) sama dengan 1.
\(\beta_0, \beta_1, \beta_2, \ldots, \beta_n\) adalah parameter yang akan diestimasi.
\(X_1, X_2, \ldots, X_n\) adalah variabel independen.
Penjelasan:
\(P(Y=1)\): Ini adalah probabilitas bahwa variabel dependen \(Y\) sama dengan 1. Dalam konteks Logistic Regression dengan dua kelas (0 dan 1), \(P(Y=1)\) mewakili probabilitas bahwa suatu observasi termasuk dalam kelas 1.
\(\frac{1}{1 + e^{-(\beta_0 + \beta_1 X_1 + \beta_2 X_2 + \ldots + \beta_n X_n)}}\):
Ini adalah fungsi logistik atau sigmoid function. Fungsi ini mengambil bentuk kurva S-shaped dan digunakan untuk mengubah hasil dari bagian kanan persamaan (yang dapat mencakup nilai apapun) menjadi nilai antara 0 dan 1, yang dapat diinterpretasikan sebagai probabilitas.
\(e\): Ini adalah basis logaritma natural (eksponensial), yang digunakan untuk memperluas skala hasil. Fungsi eksponensial ini menghasilkan nilai positif, dan ketika diangkat ke nilai negatif, dapat mendekati nol.
\(\beta_0, \beta_1, \beta_2, \ldots, \beta_n\):
Ini adalah parameter yang akan diestimasi selama proses pelatihan model. \(\beta_0\) adalah intercept (konstanta), sedangkan \(\beta_1, \beta_2, \ldots, \beta_n\) adalah koefisien yang mengukur dampak relatif dari setiap variabel independen terhadap hasil prediksi.
- \(X_1, X_2, \ldots, X_n\):
Ini adalah variabel independen yang digunakan dalam model. Setiap \(X_i\) memiliki koefisien \(\beta_i\) yang menggambarkan kontribusinya terhadap prediksi.
Dengan menggunakan rumus ini, maka dapat dilakuakan perhitungan probabilitas bahwa observasi tertentu termasuk dalam kelas 1 berdasarkan nilai variabel independen. Nilai probabilitas ini kemudian dapat digunakan untuk membuat keputusan klasifikasi.
5 Evaluation
Model dievaluasi menggunakan beberapa metrik kualitas seperti akurasi, presisi, recall, dan F1-score. * Akurasi * Presisi * Recall * F1-score * Confussion Matrix
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix5.1 Evaluate Results
5.1.0.1 Menggunakan Data Setelah Penghapusan Outlier
5.1.0.1.1 Telah dinormalisasi menggunakan Zscore
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dO_std_train,y_dO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dO_std_test, y_dO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dO_std_test, y_dO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dO_std_test, y_dO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dO_std_test, y_dO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dO_std_test, y_dO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dO_std_test, y_dO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dO_std_test, y_dO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.877906976744186
Akurasi Pengujian: 0.813953488372093
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.797752808988764
Recall: 0.8352941176470589
F1 Score: 0.8160919540229884
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8313253012048193
Recall: 0.7931034482758621
F1 Score: 0.8117647058823529# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dO_std_test, y_dO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEx_dO_std_train,y_dEx_dO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEx_dO_std_test, y_dEx_dO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEx_dO_std_test, y_dEx_dO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEx_dO_std_test, y_dEx_dO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEx_dO_std_test, y_dEx_dO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEx_dO_std_test, y_dEx_dO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEx_dO_std_test, y_dEx_dO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEx_dO_std_test, y_dEx_dO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.875
Akurasi Pengujian: 0.8081395348837209
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.7888888888888889
Recall: 0.8352941176470589
F1 Score: 0.8114285714285714
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8292682926829268
Recall: 0.7816091954022989
F1 Score: 0.8047337278106508# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEx_dO_std_test, y_dEx_dO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEc_dO_std_train,y_dEc_dO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEc_dO_std_test, y_dEc_dO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEc_dO_std_test, y_dEc_dO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEc_dO_std_test, y_dEc_dO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEc_dO_std_test, y_dEc_dO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEc_dO_std_test, y_dEc_dO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEc_dO_std_test, y_dEc_dO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEc_dO_std_test, y_dEc_dO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.877906976744186
Akurasi Pengujian: 0.8081395348837209
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.7888888888888889
Recall: 0.8352941176470589
F1 Score: 0.8114285714285714
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8292682926829268
Recall: 0.7816091954022989
F1 Score: 0.8047337278106508# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEc_dO_std_test, y_dEc_dO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dMi_dO_std_train,y_dMi_dO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dMi_dO_std_test, y_dMi_dO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dMi_dO_std_test, y_dMi_dO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dMi_dO_std_test, y_dMi_dO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dMi_dO_std_test, y_dMi_dO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dMi_dO_std_test, y_dMi_dO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dMi_dO_std_test, y_dMi_dO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dMi_dO_std_test, y_dMi_dO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.877906976744186
Akurasi Pengujian: 0.8023255813953488
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.7865168539325843
Recall: 0.8235294117647058
F1 Score: 0.8045977011494253
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8192771084337349
Recall: 0.7816091954022989
F1 Score: 0.8# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dMi_dO_std_test, y_dMi_dO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
5.1.0.1.2 Telah dinormalisasi menggunakan Minmax
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dO_mmx_train,y_dO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dO_mmx_test, y_dO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dO_mmx_test, y_dO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dO_mmx_test, y_dO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dO_mmx_test, y_dO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dO_mmx_test, y_dO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dO_mmx_test, y_dO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dO_mmx_test, y_dO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8808139534883721
Akurasi Pengujian: 0.8081395348837209
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.782608695652174
Recall: 0.8470588235294118
F1 Score: 0.8135593220338984
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8375
Recall: 0.7701149425287356
F1 Score: 0.8023952095808383# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dO_mmx_test, y_dO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEx_dO_mmx_train,y_dEx_dO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8706395348837209
Akurasi Pengujian: 0.8023255813953488
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.7802197802197802
Recall: 0.8352941176470589
F1 Score: 0.8068181818181818
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8271604938271605
Recall: 0.7701149425287356
F1 Score: 0.7976190476190476# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEx_dO_mmx_test, y_dEx_dO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEc_dO_mmx_train,y_dEc_dO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8575581395348837
Akurasi Pengujian: 0.813953488372093
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.7849462365591398
Recall: 0.8588235294117647
F1 Score: 0.8202247191011236
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8481012658227848
Recall: 0.7701149425287356
F1 Score: 0.8072289156626505# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEc_dO_mmx_test, y_dEc_dO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dMi_dO_mmx_train,y_dMi_dO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8604651162790697
Akurasi Pengujian: 0.8081395348837209
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.776595744680851
Recall: 0.8588235294117647
F1 Score: 0.8156424581005587
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8461538461538461
Recall: 0.7586206896551724
F1 Score: 0.8# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dMi_dO_mmx_test, y_dMi_dO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
5.1.0.2 Menggunakan Data Setelah Penggantian Nilai Outlier Dengan Nilai Median
5.1.0.2.1 Telah dinormalisasi menggunakan Zscore
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_rO_std_train,y_rO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_rO_std_test, y_rO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_rO_std_test, y_rO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_rO_std_test, y_rO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_rO_std_test, y_rO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_rO_std_test, y_rO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_rO_std_test, y_rO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_rO_std_test, y_rO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8444444444444444
Akurasi Pengujian: 0.8388888888888889
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8494623655913979
Recall: 0.8404255319148937
F1 Score: 0.8449197860962566
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8275862068965517
Recall: 0.8372093023255814
F1 Score: 0.8323699421965317# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_rO_std_test, y_rO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEx_rO_std_train,y_dEx_rO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEx_rO_std_test, y_dEx_rO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEx_rO_std_test, y_dEx_rO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEx_rO_std_test, y_dEx_rO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEx_rO_std_test, y_dEx_rO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEx_rO_std_test, y_dEx_rO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEx_rO_std_test, y_dEx_rO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEx_rO_std_test, y_dEx_rO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8402777777777778
Akurasi Pengujian: 0.8388888888888889
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8494623655913979
Recall: 0.8404255319148937
F1 Score: 0.8449197860962566
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8275862068965517
Recall: 0.8372093023255814
F1 Score: 0.8323699421965317# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEx_rO_std_test, y_dEx_rO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEc_rO_std_train,y_dEc_rO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEc_rO_std_test, y_dEc_rO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEc_rO_std_test, y_dEc_rO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEc_rO_std_test, y_dEc_rO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEc_rO_std_test, y_dEc_rO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEc_rO_std_test, y_dEc_rO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEc_rO_std_test, y_dEc_rO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEc_rO_std_test, y_dEc_rO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8513888888888889
Akurasi Pengujian: 0.8388888888888889
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8823529411764706
Recall: 0.7978723404255319
F1 Score: 0.8379888268156425
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8
Recall: 0.8837209302325582
F1 Score: 0.839779005524862# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEc_rO_std_test, y_dEc_rO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dMi_rO_std_train,y_dMi_rO_std_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dMi_rO_std_test, y_dMi_rO_std_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dMi_rO_std_test, y_dMi_rO_std_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dMi_rO_std_test, y_dMi_rO_std_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dMi_rO_std_test, y_dMi_rO_std_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dMi_rO_std_test, y_dMi_rO_std_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dMi_rO_std_test, y_dMi_rO_std_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dMi_rO_std_test, y_dMi_rO_std_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8361111111111111
Akurasi Pengujian: 0.8333333333333334
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8478260869565217
Recall: 0.8297872340425532
F1 Score: 0.8387096774193549
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8181818181818182
Recall: 0.8372093023255814
F1 Score: 0.8275862068965518# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dMi_rO_std_test, y_dMi_rO_std_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
5.1.0.2.2 Telah dinormalisasi menggunakan Minmax
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_rO_mmx_train,y_rO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_rO_mmx_test, y_rO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_rO_mmx_test, y_rO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_rO_mmx_test, y_rO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_rO_mmx_test, y_rO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_rO_mmx_test, y_rO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_rO_mmx_test, y_rO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_rO_mmx_test, y_rO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8402777777777778
Akurasi Pengujian: 0.8444444444444444
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.851063829787234
Recall: 0.851063829787234
F1 Score: 0.8510638297872339
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8372093023255814
Recall: 0.8372093023255814
F1 Score: 0.8372093023255814# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_rO_mmx_test, y_rO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEx_rO_mmx_train,y_dEx_rO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8472222222222222
Akurasi Pengujian: 0.8388888888888889
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8735632183908046
Recall: 0.8085106382978723
F1 Score: 0.839779005524862
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8064516129032258
Recall: 0.872093023255814
F1 Score: 0.8379888268156425# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEx_rO_mmx_test, y_dEx_rO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dEc_rO_mmx_train,y_dEc_rO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8333333333333334
Akurasi Pengujian: 0.8388888888888889
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8421052631578947
Recall: 0.851063829787234
F1 Score: 0.8465608465608466
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8352941176470589
Recall: 0.8255813953488372
F1 Score: 0.8304093567251463# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dEc_rO_mmx_test, y_dEc_rO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
# Mendapatkan akurasi pelatihan
accuracy_training = accuracy_score(y_dMi_rO_mmx_train,y_dMi_rO_mmx_trainPred)
print(f'Akurasi Pelatihan: {accuracy_training}')
# Mendapatkan akurasi pengujian
accuracy = accuracy_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred)
print(f'Akurasi Pengujian: {accuracy}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---')
# Mendapatkan presisi untuk kelas 'Kecimen'
precision_kecimen = precision_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred, pos_label='Kecimen')
print(f'Presisi: {precision_kecimen}')
# Mendapatkan recall untuk kelas 'Kecimen'
recall_kecimen = recall_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred, pos_label='Kecimen')
print(f'Recall: {recall_kecimen}')
# Mendapatkan F1 score untuk kelas 'Kecimen'
f1_kecimen = f1_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred, pos_label='Kecimen')
print(f'F1 Score: {f1_kecimen}')
print('')
print('---Presisi, Recall, dan F1 Score Untuk Kelas Besni---')
# Mendapatkan presisi untuk kelas 'Besni'
precision_besni = precision_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred, pos_label='Besni')
print(f'Presisi: {precision_besni}')
# Mendapatkan recall untuk kelas 'Besni'
recall_besni = recall_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred, pos_label='Besni')
print(f'Recall: {recall_besni}')
# Mendapatkan F1 score untuk kelas 'Besni'
f1_besni = f1_score(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred, pos_label='Besni')
print(f'F1 Score: {f1_besni}')Akurasi Pelatihan: 0.8319444444444445
Akurasi Pengujian: 0.8333333333333334
---Presisi, Recall, dan F1 Score Untuk Kelas Kecimen---
Presisi: 0.8333333333333334
Recall: 0.851063829787234
F1 Score: 0.8421052631578947
---Presisi, Recall, dan F1 Score Untuk Kelas Besni---
Presisi: 0.8333333333333334
Recall: 0.813953488372093
F1 Score: 0.8235294117647058# Mendapatkan confusion matrix
conf_matrix = confusion_matrix(y_dMi_rO_mmx_test, y_dMi_rO_mmx_pred)
# Membuat heatmap dari confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,
xticklabels=['Kecimen', 'Besni'],
yticklabels=['Kecimen', 'Besni'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()
5.1.1 Assessment of Data Mining Results
- Model Logistic Regression terbaik yang berhasil mencapai akurasi 84%, memenuhi target minimal 80% sesuai dengan kriteria keberhasilan bisnis adalah model dengan menggunakan data fitur lengkap sebanyak 7 fitur atau data tanpa pembuangan fitur yang telah melalui proses penggantian nilai outlier menjadi nilai median serta melalui normalisasi Min-Max Scaling.
- Temuan tambahan termasuk identifikasi faktor-faktor yang paling berpengaruh dalam prediksi.
5.1.2 Approved Models
Model yang memenuhi kriteria keberhasilan bisnis dianggap sebagai model yang disetujui. Sehingga, model Logistic Regression dengan parameter hasil terbaik dianggap disetujui.
import joblib
# Menyimpan scaler ke dalam file
joblib.dump(scaler_minmax_rO, '/content/drive/MyDrive/psd/raisin/scaler.pkl')import joblib
# Simpan model ke dalam file
joblib.dump(LR_rO_mmx, '/content/drive/MyDrive/psd/raisin/LR_model.pkl')5.2 Review Process
5.2.1 Review of Process
Proses pemodelan dan evaluasi telah dilaksanakan sesuai rencana proyek. Semua aktivitas dilakukan sesuai dengan pedoman data mining yang berlaku. Tidak ada isu kualitas yang signifikan yang terlewat selama proses.
5.3 Determine Next Steps
- Berdasarkan evaluasi hasil dan tinjauan proses, maka diputuskan untuk melanjutkan ke tahap implementasi model ke dalam Streamlit.
- Menyiapkan laporan final proyek untuk disajikan pada web statis menggunakan posit cloud.
6 Deployment
6.1 Plan Deployment
Implementasi model Logistic Regression pada antarmuka web akan menggunakan Streamlit dengan menggunakan model terbaik yang disimmpan dalam file pickle. Setelah model disiapkan, lalu dibuatlah skrip menggunakan Streamlit yang memuat model Logistic Regression yang sudah disimpan, dan mendefinisikan fungsi untuk melakukan prediksi berdasarkan input dari pengguna.
Antarmuka web dibangun dengan judul “Aplikasi Klasifikasi Jenis Kismis”. Fitur-fitur yang diperlukan untuk prediksi dimasukkan melalui field masukan dan hasil prediksi ditampilkan secara langsung di halaman antarmuka web.
Terakhir, aplikasi akan dideploy sehingga pengguna dapat mengakses antarmuka web melalui browser dan berinteraksi dengan model Logistic Regression untuk melakukan klasifikasi varietas Kecimen dan Besni. Seluruh proses ini dirancang untuk memberikan pengalaman pengguna yang mudah dan efisien dalam menggunakan model untuk tujuan klasifikasi yang diinginkan.
6.2 Produce Final Report
6.2.1 Final Report
Laporan akhir berisi rangkuman menyeluruh tentang proyek, metode yang diterapkan, dan hasil evaluasi model yang akan disajikan melalui website statis memanfaatkan POSIT dengan penjelasan mendalam pada setiap tahapan proses data mining.
6.3 Review Project
Link Deployment: Streamlit
Evaluasi Proyek:
Klasifikasi varietas kismis yang dimodelkan menggunakan Logistic Regression ini mencapai akurasi 84% tanpa adanya pengurangan fitur.
Kesalahan yang ditemui:
Meskipun terdapat fitur yang memberikan pengaruh kecil terhadap klasifikasi, tetapi pengurangan fitur belum tentu jawaban yang tepat untuk meningkatkan akurasi, karena bisa saja dengan menghilangkan fitur yang dianggap tidak sebegitu berpengaruhnya dapat menghilangkan informasi sehingga akurasi malah menurun.