Nama : Alif Dhaifullah Ramadhan
NIM : 210411100020 Kelas : B
Untuk memprediksi penyaki stroke dapat dilihat dari ciri-ciri sebagai berikut:
Studi ini akan membahas prediksi stroke berdasarkan data survey yang dilakukan oleh CDC pada tahun 2015
Tentang Stroke yang merupakan penyebab kematian nomor 2 secara global dan bertanggung jawab atas 11% dari total kematian yang terjadi di dunia. data ini diperoleh oleh cdc berdasarkan surver yang lakukan pada rumah sakit di amerika serikat dan disupport oleh data yang dimiliki oleh WHO.
Jumlah Dataset sebanyak 40910 dengan rincian sebagai berikut: - positive stroke (1) = 20460 data - negative stroke (0) = 20450 data
- Didalam data sampel stroke setelah dilakukan pengecekan nilai tidak ditemukan data dengan nilai yang hilang (Missing Values). #### OUTLIER PADA DATA
- Setelah dilakukan pengecekan outlier dengan menggunakan teknik Local Outlier Factor diketahui terdapat 271 data yang terdeteksi mengandung outlier. #### PROPORSI JUMLAH KELAS PADA DATA
- Berdasarkan jumlah data pada setiap kelas yang telah di definisikan sebelumnya, dapat diketahui bahwasan nya pada data jumlah masing-masing kelas tidak seimbang dengan perbandingan 86.4% dari jumlah seluruh data untuk data yang diidentifikasi memiliki kualitas buruk dan 13.5% dari jumlah seluruh data untuk data yang diidentifikasi termasuk memiliki kualitas yang bagus.
Tipe dari data disetiap kolomnya sebagai berikut: 1. Tipe Rasio : > - age > - avg_glucose_level > - bmi
bmi: Angka BMI normal berada pada kisaran 18,5-25. Jika angka BMI melebihi 25, kamu memiliki berat badan berlebih. Sementara itu, jika angka BMI berada di bawah 18 berarti berat badan kurang. obesitasi merupakan salah satu faktor risiko stroke dikarenakan peradangan jaringan tubuh akibat lemak berlebih. kondisi ini dapat memicu masalah aliran darah dan peningkatan risiko penyumbatan darah. Nah, kondisi ini yang ujung-ujungnya menyebabkan stroke.
age (umur): Ada sejumlah faktor risiko penyakit stroke, diantaranya USIA. Penyakit stroke rata-rata menyerang seseorang yang berusia di atas 60 tahun.
hypertension (hipertensi): suatu keadaan dimana tekanan darah sistolik pada tubuh seseorang lebih dari atau sama dengan 140 mmHg dan atau tekanan darah diastolik lebih dari atau sama dengan 90 mmHg.
heart disease (penyakit jantung): kondisi ketika bagian jantung yang meliputi pembuluh darah jantung, selaput jantung, katup jantung, dan otot jantung mengalami gangguan.
ever married (pernah menikah): Faktor utama penyebab stroke adalah faktor genetik. Faktor genetik adalah faktor keturunan yang disebabkan oleh salah satu anggota keluarga. Umumnya, bagi yang menderita penyakit stroke ini, jika dari faktor genetik, sangat sulit untuk disembuhkan.
work type (jenis pekerjaan): Jenis pekerjaan juga salah satu faktor risiko terjadinya stroke. dikarenakan pekerjaan dengan aktivitas fisik yang lebih rendah rentan terkana stroke dibandingan dengan pekerjaan yang memiliki aktivitas fisik dalam jumlah sedang.
residence type (tipe tempat tinggal): Tempat tinggal juga mempengaruhi terjadinya stroke. karena prevalensi stroke diperkotaan lebih tinggi (8,2%) dibandingkan dengan daerah pedesaan (5,7%).
avg glucose level (kadar glukosa rata-rata): Kandungan gula berlebih dalam darah dapat menyebabkan pembuluh darah menjadi kaku dan penumpukan timbunan lemak. Kondisi inilah yang memicu penggumpalan darah yang bila berpindah ke otak dapat menyebabkan stroke.
smoking status (status merokok): status merokok sangat mempengaruhi terjadinya stroke. Karena merokok bisa mengakibatkan berbagai masalah dengan aliran darah ke otak, dan menyumbang pembentukan gumpalan darah pada pembuluh darah – dan salah satu keduanya meningkatkan kemungkinan timbulnya serangan stroke
Adapun hal - hal yang perlu dilakukan untuk memahami data, yakni 1. Mendeskripsikan setiap fitur pada data * tipe data * deskripsi data 2. Mengidentifikasi missing values setiap fitur atau kolom 3. Eksplorasi data (grafikan fitur) 4. Mengidentifikasi outlier 5. Mengidentifikasi jumlah data (proporsi data perkelas -untuk mengetahui balancing dataset atau keseimbangan data per kelas)
meng import/memanggil dataset stroke
import pandas as pd
data = pd.read_csv('stroke_data.csv')
data.head(5)| sex | age | hypertension | heart_disease | ever_married | work_type | Residence_type | avg_glucose_level | bmi | smoking_status | stroke | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1.0 | 63.0 | 0 | 1 | 1 | 4 | 1 | 228.69 | 36.6 | 1 | 1 |
| 1 | 1.0 | 42.0 | 0 | 1 | 1 | 4 | 0 | 105.92 | 32.5 | 0 | 1 |
| 2 | 0.0 | 61.0 | 0 | 0 | 1 | 4 | 1 | 171.23 | 34.4 | 1 | 1 |
| 3 | 1.0 | 41.0 | 1 | 0 | 1 | 3 | 0 | 174.12 | 24.0 | 0 | 1 |
| 4 | 1.0 | 85.0 | 0 | 0 | 1 | 4 | 1 | 186.21 | 29.0 | 1 | 1 |
# Rincian dataset (banyak data dan kolom)
print("Banyaknya data : ", data.shape[0])
print("Banyaknya kolom : ", data.shape[1])Banyaknya data : 40910
Banyaknya kolom : 11kelas_counts = data['stroke'].value_counts()
print(kelas_counts)stroke
1 20460
0 20450
Name: count, dtype: int64import matplotlib.pyplot as plt
data.hist(figsize=(10, 10))
plt.suptitle('Histograms of Features', x=0.5, y=0.95, ha='center', fontsize='x-large')
plt.show() 
mendeskripsikan fitur apa saja yang ada pada fitur dataset stroke
data.columnsIndex(['sex', 'age', 'hypertension', 'heart_disease', 'ever_married',
'work_type', 'Residence_type', 'avg_glucose_level', 'bmi',
'smoking_status', 'stroke'],
dtype='object')data.dtypessex float64
age float64
hypertension int64
heart_disease int64
ever_married int64
work_type int64
Residence_type int64
avg_glucose_level float64
bmi float64
smoking_status int64
stroke int64
dtype: objectBerikut Macam - Macam Data yang ada pada data ini.
penjelasan setiap fitur: - Age (Usia): Ini adalah usia pasien dalam tahun. (tahun/year)
BMI (Body Mass Index): Ini adalah indeks massa tubuh (BMI) pasien, yang mengukur hubungan antara berat badan dan tinggi badan. Nilai ini digunakan untuk mengevaluasi status berat badan pasien. (Kg/m^2)
Glucose (Glukosa): Ini adalah konsentrasi glukosa dalam darah pasien, yang diukur dalam mg/dL. Kadar glukosa darah sering digunakan untuk mengawasi fungsi metabolisme gula dalam tubuh.(Mg/dl)
Insulin: Ini adalah kadar insulin dalam darah pasien, yang diukur dalam μU/mL. Insulin adalah hormon yang berperan dalam mengendalikan kadar glukosa darah.(µU/Ml)
HOMA (Homeostasis Model Assessment): Ini adalah nilai HOMA yang digunakan untuk mengukur resistensi insulin dan fungsi sel beta pankreas dalam menghasilkan insulin. HOMA adalah perkiraan berdasarkan kadar glukosa dan insulin dalam darah. (%)
Leptin: Leptin adalah hormon yang diproduksi oleh sel lemak dalam tubuh. Konsentrasi leptin dalam darah dapat berhubungan dengan berat badan dan metabolisme lemak. (ng/Ml)
Adiponectin: Adiponectin adalah hormon yang diproduksi oleh jaringan lemak dan berperan dalam regulasi metabolisme lemak dan sensitivitas insulin. (µg/Ml)
Resistin: Resistin adalah protein yang diproduksi oleh jaringan lemak dan berperan dalam regulasi peradangan dan resistensi insulin. (ng/Ml)
MCP.1 (Monocyte Chemoattractant Protein-1): MCP.1 adalah protein yang berperan dalam mengarahkan sel darah putih (monosit) ke daerah peradangan dalam tubuh. Ini dapat menjadi indikator peradangan dalam tubuh. (pg/dl)
Classification (Klasifikasi): Ini adalah atribut target yang digunakan untuk mengklasifikasikan pasien. (1: Jinak, 2: Ganas)
mencari missing value atau data yang tidak bernilai pada dataset stroke
# Menghitung apakah ada nilai yang hilang dalam setiap kolom
missing_values = data.isna().any()
# Menampilkan hasil
print("Apakah ada nilai yang hilang dalam setiap kolom:")
print(missing_values)Apakah ada nilai yang hilang dalam setiap kolom:
sex False
age False
hypertension False
heart_disease False
ever_married False
work_type False
Residence_type False
avg_glucose_level False
bmi False
smoking_status False
stroke False
dtype: boolNoted : tidak ada missing value pada data
mencari duplikat data yang terjadi pada dataset kanker payudara dengan menggunakan
jumlah_duplikat = data.duplicated().sum()
# Menampilkan jumlah data yang duplikat
print("Jumlah data yang duplikat:", jumlah_duplikat)Jumlah data yang duplikat: 1Noted : terdapat beberapa baris data yang sama, sehingga data tersebut harus dihilangkan untuk menghindari adanya data yang redundan
Mencari data outlier pada dataset adalah langkah penting dalam analisis data untuk mengidentifikasi nilai-nilai yang berbeda secara signifikan dari pola umum dataset. Outlier adalah nilai yang jauh dari nilai-nilai lainnya dan dapat memiliki dampak besar pada hasil analisis statistik. Pada dataset kali ini saya menggunakan Local Outlier Factor untuk mencari outlier yang ada pada dataset kanker payudara tersebut.
LOF mengukur sejauh mana suatu observasi berbeda dari tetangga-tetangganya dalam hal kepadatan. Outlier diidentifikasi berdasarkan perbandingan antara kepadatan observasi tersebut dan kepadatan tetangganya. Jika suatu observasi memiliki LOF yang tinggi, maka itu dianggap sebagai outlier.
Hitung Jarak Antar Data dimana jarak yang dihitung adalah jarak titik yang akan dievaluasi dengan semua titik didalam satu baris. Perhitungan Jarak dilakukan menggunakan perhitungan jarak euclidean.
\[ \text{distance}(p, q) = \sqrt{\sum_{i=1}^{n}(p_i - q_i)^2} \] dimana :
Hitung Kepadatan Lokal Setelah jarak diketahui, maka selanjutnya kepadatan lokal dari titik data tersebut perlu dihitung. Kepadatan lokal dapat dihitung dengan membandingkan jumlah titik-titik tetangga dalam jarak tertentu (radius) terhadap titik data yang sedang dievaluasi.
\[ \text{Local Density}(p) = \frac{\text{jumlah tetangga dalam radius}}{\text{jumlah total data}} \]
Hitung Local Reachability Density(LRD) Hitung kepadatan jarak (reachability distance) dari titik data (p) terhadap tetangganya (q). Local Reachability Density dari titik p terhadap tetangga q dihitung sebagai rata-rata dari jarak antara q dan p terhadap tetangga q:
\[ \text{reachdist}(p, q) = \max(\text{distance}(p, q), \text{radius}) \]
\[ \text{Local Reachability Density}(p) = \frac{1}{\text{jumlah tetangga}} \sum_{q \in N_{\text{radius}}(p)} \frac{\text{reachdist}(p, q)}{\text{density}(q)} \] dimana:
Hitung Nilai LOF LOF dari suatu titik data (p) dihitung sebagai rasio dari rata-rata Local Reachability Density dari tetangganya terhadap kepadatan lokalnya sendiri: \[ \text{LOF}(p) = \frac{1}{\text{jumlah tetangga}} \sum_{q \in N_{\text{radius}}(p)} \frac{\text{Local Reachability Density}(q)}{\text{Local Reachability Density}(p)} \]
| X | Y |
|---|---|
| 2 | 6 |
| 4 | 7 |
| 6 | 9 |
| 8 | 5 |
| 10 | 12 |
Sekarang, kita akan mengikuti langkah-langkah yang sama untuk menghitung Local Outlier Factor (LOF):
Langkah 1: Hitung Jarak Antar Data dengan Radius 5 | X | Y | Jarak | |—-|—-|——————| | 2 | 6 | 3.16 ; 3.61 ; 4.24| | 4 | 7 | 2.24 ; 2.83 ; 3.61| | 6 | 9 | 2.24 ; 3.61 ; 4.47| | 8 | 5 | 4.47 ; 5.1 | | 10 | 12 | 3.61 ; 5.83 |
Langkah 2: Hitung Jumlah Tetangga dalam Radius 5 | X | Y | Jumlah Tetangga | | — | — | ————— | | 2 | 6 | 3 | | 4 | 7 | 3 | | 6 | 9 | 3 | | 8 | 5 | 2 | | 10 | 12 | 2 |
Langkah 3: Hitung Local Reachability Density | X | Y | Jarak | |—-|—-|——————————————-| | 2 | 6 | (3.16 + 3.61 + 4.24) / 3 = 3.67 | | 4 | 7 | (2.24 + 2.83 + 3.61) / 3 = 2.89 | | 6 | 9 | (2.24 + 3.61 + 4.47) / 3 = 3.44 | | 8 | 5 | (4.47 + 5.1) / 2 = 4.79 | | 10 | 12 | (3.61 + 5.83) / 2 = 4.72 |
Langkah 4: Menghitung Nilai LOF Data | X | Y | LOF | |—-|—-|———————–| | 2 | 6 | 1.28 | | 4 | 7 | 1.59 | | 6 | 9 | 1.20 | | 8 | 5 | 0.93 | | 10 | 12 | 0.84 |
Dengan begitu, nilai yang kemungkinan menjadi outlier adalah baris 4 dan baris 5, karena nilai LOF-nya lebih rendah dari 1, yang menunjukkan bahwa kepadatan lokal titik tersebut lebih tinggi daripada rata-rata kepadatan lokal tetangganya.
import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor
# Membuat model LOF
clf = LocalOutlierFactor(n_neighbors=20) # Jumlah tetangga yang digunakan
outlier_scores = clf.fit_predict(data)
# Menampilkan indeks outlier
outlier_indices = np.where(outlier_scores == -1)[0]
print("Indeks outlier:",outlier_indices)
print("Indeks outlier:",len( outlier_indices))Indeks outlier: [ 9277 9505 11716 11939 14856 15146 15641 15714 15891 16663 17337 17481
18783 20465 20475 20520 20609 20659 20692 20724 20934 21025 21030 21192
21277 21360 21377 21392 21403 21573 21760 21835 21861 22013 22054 22071
22124 22180 22215 22342 22443 22459 22462 22521 22758 22821 22910 22987
23080 23093 23266 23392 23615 23648 23710 23720 23843 23852 23902 23935
23966 24026 24175 24266 24270 24431 24596 24627 24638 24688 24807 24812
24914 24994 25064 25095 25170 25247 25288 25305 25414 25449 25676 25692
25695 25868 25924 25989 26073 26101 26140 26307 26320 26491 26837 26932
26942 27120 27153 27184 27389 27412 27482 27616 27640 27671 27724 27804
27836 27846 27896 28015 28020 28199 28231 28268 28273 28299 28448 28489
28614 28873 28889 28892 28951 29152 29180 29327 29404 29497 29677 29801
29974 30009 30019 30045 30111 30241 30300 30332 30563 30653 30658 30815
30977 31006 31044 31065 31181 31186 31358 31425 31430 31455 31535 31601
31641 31658 31766 31800 32020 32036 32039 32209 32329 32414 32442 32479
32552 32643 32656 32820 33115 33160 33261 33389 33439 33470 33705 33794
33799 33933 33957 34116 34148 34159 34189 34209 34325 34500 34569 34737
34777 34794 34895 34928 34939 35149 35165 35168 35331 35551 35590 35609
35753 35766 35921 35931 36272 36357 36366 36494 36544 36575 36606 36663
36801 36888 36893 37046 37125 37206 37237 37248 37276 37409 37414 37564
37589 37661 37684 37759 37828 37869 37882 37985 38015 38232 38246 38249
38412 38417 38534 38643 38678 38740 38838 38849 39013 39335 39339 39433
39443 39562 39620 39648 39682 39876 39956 39961 40117 40276 40304 40314
40364 40478 40483 40654 40716 40719 40743]
Indeks outlier: 271Noted : terdapat banyak data yang memiliki outlier, sehingga data tersebut harus dihilangkan
untuk mengindentifikasi jumlah data pada fitur classification atau data target pada dataset stroke - value_counts(): Ini adalah metode dari pandas yang digunakan untuk menghitung frekuensi kemunculan setiap nilai unik dalam kolom ‘stroke’. Dengan kata lain, ini menghitung berapa kali setiap nilai muncul dalam kolom tersebut.
target_no_outliers = data['stroke'].value_counts()
# Menampilkan jumlah target pada data tanpa outlier
print("Jumlah data pada tanpa outlier:")
print(target_no_outliers)Jumlah data pada tanpa outlier:
stroke
1 20460
0 20450
Name: count, dtype: int64Mengindentifikasi fitur - fitur yang ada pada dataset kstroke dengan tujuan menggunakan seleksi fitur dan menampilkan grafik
mencari skor pada setiap fitur dengan menggunakan metode SelectKBeast dengan mencari nilai mutual information dari setiap fitur.
Mutual information (MI) adalah metrik yang berguna dalam pemilihan fitur karena mengukur seberapa banyak informasi yang saling terkait antara fitur (variabel independen) dengan variabel target (variabel dependen). Dalam konteks pemilihan fitur, kita ingin mempertahankan fitur-fitur yang memiliki hubungan yang kuat atau tinggi dalam menjelaskan variabel target.
Rumus Mutual Information (MI) between X and Y:
\[ \text{MI}(X;Y) = \sum_{x \in X} \sum_{y \in Y} p(x, y) \log \left(\frac{p(x, y)}{p(x) \cdot p(y)}\right) \]
Dimana: - MI(X;Y) adalah mutual information antara variabel X dan Y. - p(x,y) adalah probabilitas bersama dari X=x dan Y=y. - p(x) adalah probabilitas margina X=x. - p(y) adalah probabilitas margina Y=y.
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.model_selection import train_test_split
# Memisahkan kolom fitur dan target
fitur = data.drop(columns=['stroke'])
target = data['stroke']
# Buat objek SelectKBest dengan mutual_info_classif sebagai fungsi skor
k_best = SelectKBest(score_func=mutual_info_classif, k='all') # 'all' berarti akan mempertahankan semua fitur
# Hitung skor fitur
k_best.fit(fitur, target)
scores = k_best.scores_
# Dapatkan nama fitur dari kolom data Anda
fitur_names = fitur.columns
# Tampilkan skor fitur berserta namanya
for i, (score, fitur_name) in enumerate(zip(scores, fitur_names), start=1): # Gunakan start=1 agar indeks dimulai dari 1
print(f"Fitur {i}: {fitur_name}, Skor: {score}")Fitur 1: sex, Skor: 0.010906937110052306
Fitur 2: age, Skor: 0.019929750638476573
Fitur 3: hypertension, Skor: 0.037770281250294246
Fitur 4: heart_disease, Skor: 0.024929386775016216
Fitur 5: ever_married, Skor: 0.02151166424413864
Fitur 6: work_type, Skor: 0.009425807981625844
Fitur 7: Residence_type, Skor: 0.002723894051596787
Fitur 8: avg_glucose_level, Skor: 0.6679885048944895
Fitur 9: bmi, Skor: 0.2273778019573327
Fitur 10: smoking_status, Skor: 0.004117113148936591import matplotlib.pyplot as plt
# Tampilkan skor fitur dalam grafik
plt.figure(figsize=(18, 6))
plt.bar(fitur_names, scores)
plt.xlabel("Nama Fitur")
plt.ylabel("Skor Fitur")
plt.title("Skor Fitur SelectKBest")
plt.xticks(rotation=90)
plt.show()
Kesimpulan :
Setelah memahami data, akan dilakukan tahap preprocessing untuk menangani masalah pada data yang sudah didefinisikan pada data understanding, yakni: 1. Menghapus Data Duplikat 2. Menghapus Outlier
Setelah data siap, akan dilakukan : 1. Skoring tiap fitur kembali 2. Normalisasi Data 3. Eksplorasi Model
meng import/memanggil dataset stroke
import pandas as pd
data = pd.read_csv('stroke_data.csv')
data.head(5)| sex | age | hypertension | heart_disease | ever_married | work_type | Residence_type | avg_glucose_level | bmi | smoking_status | stroke | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1.0 | 63.0 | 0 | 1 | 1 | 4 | 1 | 228.69 | 36.6 | 1 | 1 |
| 1 | 1.0 | 42.0 | 0 | 1 | 1 | 4 | 0 | 105.92 | 32.5 | 0 | 1 |
| 2 | 0.0 | 61.0 | 0 | 0 | 1 | 4 | 1 | 171.23 | 34.4 | 1 | 1 |
| 3 | 1.0 | 41.0 | 1 | 0 | 1 | 3 | 0 | 174.12 | 24.0 | 0 | 1 |
| 4 | 1.0 | 85.0 | 0 | 0 | 1 | 4 | 1 | 186.21 | 29.0 | 1 | 1 |
# Rincian dataset (banyak data dan kolom)
print("Banyaknya data : ", data.shape[0])
print("Banyaknya kolom : ", data.shape[1])Banyaknya data : 40910
Banyaknya kolom : 11menghapus data duplikat yang telah di cari pada eksekusi sebelumnya yang dimana peroleh data duplikat = 0. Dikarenakan data duplikat bernilai 0 pada sisa data tetap dengan jumlah data yang asli
# Menghapus data yang duplikat
data_bersih = data.drop_duplicates()
print("Banyaknya sisa data : ", data_bersih.shape[0])Banyaknya sisa data : 40909# Menghapus data outlier dari DataFrame 'data'
data_cleaned = data.drop(outlier_indices)
# Menampilkan DataFrame setelah menghapus outlier
print("Data setelah menghapus outlier:")
# Rincian dataset (banyak data dan kolom)
print("Banyaknya data : ", data_cleaned.shape[0])Data setelah menghapus outlier:
Banyaknya data : 40639Pada hasil Mengidentifikasi jumlah data di peroleh jumlah target data 20460 : 20450. Namun setelah di lakukan Penghapusan Outlier maka di peroleh nilai sebagai berikut:
fitur = data_cleaned.drop(columns=['stroke'])
target = data_cleaned['stroke']
target.value_counts()stroke
1 20447
0 20192
Name: count, dtype: int64dikarenakan data classification tidak mengalami ketidakeseimabangan data, maka tidak perlu melakukan penyeimbangan data target.
Mengindentifikasi fitur - fitur yang ada pada dataset kanker payudara dengan tujuan menggunakan seleksi fitur dan menampilkan grafik
import matplotlib.pyplot as plt
# Ambang skor untuk pemilihan fitur
threshold = 0.02 # Gantilah dengan ambang yang diinginkan
fitur = data_cleaned.drop(columns=['stroke'], axis=1)
target = data_cleaned['stroke']
# Buat objek SelectKBest dengan mutual_info_classif sebagai fungsi skor
k_best = SelectKBest(score_func=mutual_info_classif, k='all')
# Hitung skor fitur
k_best.fit(fitur, target)
scores = k_best.scores_
# Dapatkan nama fitur dari kolom data Anda
fitur_names = fitur.columns
# Pilih fitur yang memiliki skor di atas ambang
selected_features = [fitur_name for fitur_name, score in zip(fitur_names, scores) if score > threshold]
# Tampilkan fitur yang terpilih
print("Fitur yang terpilih:", selected_features)
# Drop fitur yang tidak terpilih
fitur_selected = fitur[selected_features]
# Tampilkan skor fitur berserta namanya
for i, (score, fitur_name) in enumerate(zip(scores, fitur_names)):
print(f"Fitur {i}: {fitur_name}, Skor: {score}")
# Hapus fitur yang memiliki skor di bawah ambang
fitur_selected = fitur_selected[[fitur_name for fitur_name, score in zip(selected_features, scores) if score > threshold]]
# Tampilkan data setelah pemilihan fitur
print(fitur_selected.head())
# Tampilkan grafik skor fitur
plt.figure(figsize=(12, 6))
plt.bar(range(len(fitur_names)), scores)
plt.xticks(range(len(fitur_names)), fitur_names, rotation=90)
plt.xlabel('Features')
plt.ylabel('Information Gain')
plt.title('Feature Importance (Information Gain)')
plt.axhline(y=threshold, color='r', linestyle='--', label='Ambang')
plt.show()Fitur yang terpilih: ['age', 'hypertension', 'heart_disease', 'ever_married', 'avg_glucose_level', 'bmi']
Fitur 0: sex, Skor: 0.010650952359390509
Fitur 1: age, Skor: 0.020496908746743703
Fitur 2: hypertension, Skor: 0.032823188956145666
Fitur 3: heart_disease, Skor: 0.029537001937264495
Fitur 4: ever_married, Skor: 0.021094346063377012
Fitur 5: work_type, Skor: 0.01300114435414268
Fitur 6: Residence_type, Skor: 0.0015736548219393853
Fitur 7: avg_glucose_level, Skor: 0.6681660393426447
Fitur 8: bmi, Skor: 0.22811425075861091
Fitur 9: smoking_status, Skor: 0.008496986525957206
hypertension heart_disease ever_married avg_glucose_level
0 0 1 1 228.69
1 0 1 1 105.92
2 0 0 1 171.23
3 1 0 1 174.12
4 0 0 1 186.21
Setelah dilakukan pencarian skor pada setiap fitur, terdapat 5 fitur yang memiliki skor atau bernilai dibawah 0.02 dan terdapat 5 fitur yang memilki nilai diatas dan sama dengan 0.02. maka dari itu, selanjutnya akan di lakukan penghapusan fitur yang memiliki nilai dibawah 0.02.
import pandas as pd
from sklearn.feature_selection import SelectKBest, mutual_info_classif
# Ambang skor untuk pemilihan fitur
threshold = 0.02 # Gantilah dengan ambang yang diinginkan
# Buat objek SelectKBest dengan mutual_info_classif sebagai fungsi skor
k_best = SelectKBest(score_func=mutual_info_classif, k='all')
# Hitung skor fitur
k_best.fit(fitur, target)
# Dapatkan nama fitur dari kolom data Anda
fitur_names = fitur.columns
# Gunakan metode transform untuk mendapatkan DataFrame fitur yang terpilih
fitur_selected = k_best.transform(fitur)
# Tampilkan fitur yang terpilih
selected_feature_names = fitur_names[k_best.get_support()]
print("Fitur yang terpilih:")
print(selected_feature_names)
# Gabungkan fitur yang terpilih dengan target
dataset_baru = pd.concat([fitur[selected_feature_names], target], axis=1)
Fitur yang terpilih:
Index(['age', 'hypertension', 'heart_disease', 'avg_glucose_level', 'bmi'], dtype='object')dataset_baru = pd.concat([fitur, target], axis=1)
# Display the combined table
print(dataset_baru) age hypertension heart_disease avg_glucose_level bmi stroke
0 63.0 0 1 228.69 36.6 1
1 42.0 0 1 105.92 32.5 1
2 61.0 0 0 171.23 34.4 1
3 41.0 1 0 174.12 24.0 1
4 85.0 0 0 186.21 29.0 1
... ... ... ... ... ... ...
40905 38.0 0 0 120.94 29.7 0
40906 53.0 0 0 77.66 40.8 0
40907 32.0 0 0 231.95 33.2 0
40908 42.0 0 0 216.38 34.5 0
40909 35.0 0 0 95.01 28.0 0
[40639 rows x 6 columns]import pandas as pd
# Menyimpan DataFrame ke dalam file CSV
dataset_baru.to_csv('dataset_baru.csv', index=False)import matplotlib.pyplot as plt
# Tampilkan fitur yang terpilih
print("Fitur yang terpilih:")
print(fitur_names[k_best.get_support()])
# Tampilkan skor fitur dalam grafik
plt.figure(figsize=(18, 6))
plt.bar(fitur_names[k_best.get_support()], k_best.scores_[k_best.get_support()])
plt.xlabel("Nama Fitur")
plt.ylabel("Skor Fitur")
plt.title("Skor Fitur SelectKBest")
plt.xticks(rotation=90)
plt.show()Fitur yang terpilih:
Index(['age', 'hypertension', 'heart_disease', 'avg_glucose_level', 'bmi'], dtype='object')
proses memisahkan dataset menjadi dua atau lebih bagian yang berbeda. Tujuan umumnya adalah untuk menggunakan satu bagian data sebagai data pelatihan (training data) untuk melatih model, dan bagian lainnya sebagai data pengujian (testing data) untuk menguji kinerja model.
from sklearn.model_selection import train_test_split
# melakukan pembagian dataset, dataset dibagi menjadi 80% data training dan 20% data testing
fitur_train, fitur_test, target_train, target_test = train_test_split(fitur, target, test_size = 0.2, random_state=42)proses pengubahan nilai-nilai dalam suatu dataset menjadi rentang skala tertentu atau memastikan bahwa nilai-nilai tersebut mengikuti distribusi yang dapat meningkatkan kinerja beberapa algoritma machine learning.
Normalisasi menggunakan Z-Score atau Standard Scaler adalah salah satu teknik normalisasi yang umum digunakan dalam pengolahan data dan machine learning. Normalisasi ini mengubah setiap nilai dalam dataset sehingga memiliki rata-rata nol dan deviasi standar satu. Hal ini membantu untuk menghilangkan perbedaan skala antar fitur, membuat data lebih mudah diinterpretasikan, dan meningkatkan performa beberapa algoritma machine learning. Berikut adalah penjelasan lebih detail tentang Normalisasi Standar atau Z-Score:
Langkah-langkah Normalisasi Standar (Z-Score):
Hitung Rata-rata dan Deviasi Standar: Untuk setiap fitur dalam dataset, hitung rata-rata \(\mu\) dan deviasi standar \(\sigma\).
$ = _{i=1}^{N} X_i $
$ = $
Di sini, \(N\) adalah jumlah total sampel, dan \(X_i\) adalah nilai individu dalam suatu fitur.
Normalisasi Setiap Nilai: Untuk setiap nilai dalam setiap fitur, normalisasikan nilai tersebut menggunakan rumus Z-Score:
\[ Z = \frac{X - \mu}{\sigma} \]
Di sini, \(X\) adalah nilai individu, \(\mu\) adalah rata-rata fitur, dan \(\sigma\) adalah deviasi standar fitur.
Berikut adalah contoh penggunaan metode Standard Scaling (Z-Score Normalization) pada data kolom X yang berbeda:
Diberikan tabel dengan kolom X berikut:
| X | X’ |
|---|---|
| 8 | 0 |
| 20 | 0 |
| 12 | 0 |
| 15 | 0 |
| 25 | 0 |
Langkah-langkah untuk melakukan normalisasi dengan metode Standard Scaling:
Hitung rata-rata (mean) dan standar deviasi (standard deviation) dari kolom X.
Normalisasikan setiap nilai dalam kolom X menggunakan rumus Z-Score Normalization: $ X’ = $
Sehingga, nilai X’ untuk setiap baris dapat dihitung sebagai berikut:
Sehingga, hasil normalisasi (X’) untuk contoh ini adalah:
| X | X’ |
|---|---|
| 8 | -1.46 |
| 20 | 0.73 |
| 12 | -0.73 |
| 15 | -0.22 |
| 25 | 1.64 |
Ini adalah contoh penggunaan Standard Scaling pada data kolom X yang berbeda.
import pickle
from sklearn.preprocessing import StandardScaler
# membuat dan melatih objek StandardScaler
zscore_scaler = StandardScaler()
zscore_scaler.fit(fitur_train)
with open('zscorescaler_baru.pkl', 'wb') as file:
pickle.dump(zscore_scaler, file)
# menerapkan normalisasi zscore pada data training
zscore_training = zscore_scaler.transform(fitur_train)
# menerapkan normalisasi zscore pada data testing
zscore_testing = zscore_scaler.transform(fitur_test)MinMax Normalization atau MinMax Scaling digunakan untuk mengubah nilai-nilai dalam suatu fitur ke dalam rentang tertentu, biasanya antara 0 dan 1. MinMax Normalization mengubah setiap nilai X dalam fitur ke dalam rentang yang diinginkan menggunakan rumus berikut:
Langkah-langkah Normalisasi Minmax:
Identifikasi Rentang: Tentukan rentang nilai yang ingin Anda gunakan. Biasanya, dalam Min-Max Scaling, rentang nilai yang dipilih adalah 0 hingga 1, tetapi ini bisa disesuaikan tergantung pada kasus penggunaan.
Hitung Nilai Minimum dan Maksimum: Tentukan nilai minimum (min) dan nilai maksimum (max) dari setiap fitur dalam kumpulan data yang akan dinormalisasi.
Normalisasi: Gunakan formula rumusn Min-Max Scaling untuk mengubah nilai-nilai dalam rentang yang ditentukan.
Rumus Minmax Scaler
\[X' = \frac{X-Xmin}{Xmax - Xmin}\]
Dimana : - X adalah nilai asli dari suatu kolom/fitur - min adalah nilai minimum dari suatu kolom/fitur dalam dataset - max adalah nilai maximum dari suatu kolom/fitur dalam dataset - X’ adalah nilai X yang telah dinormalisasi.
Berikut adalah contoh penggunaan Min-Max Scaling pada data kolom X yang berbeda:
Diberikan tabel dengan kolom X berikut:
| X | X’ |
|---|---|
| 5 | 0 |
| 15 | 0 |
| 8 | 0 |
| 20 | 0 |
Untuk melakukan normalisasi dengan Min-Max Scaling, kita perlu mengidentifikasi nilai terendah dan tertinggi pada kolom. Dalam kasus ini:
Sehingga, nilai X’ hasil normalisasi dapat dihitung seperti berikut:
| X | X’ |
|---|---|
| 5 | (5 - 5) / (20 - 5) = 0 |
| 15 | (15 - 5) / (20 - 5) = 0.6667 |
| 8 | (8 - 5) / (20 - 5) = 0.3333 |
| 20 | (20 - 5) / (20 - 5) = 1 |
Jadi, nilai X’ hasil normalisasi untuk contoh ini adalah:
| X | X’ |
|---|---|
| 5 | 0 |
| 15 | 0.6667 |
| 8 | 0.3333 |
| 20 | 1 |
Ini adalah contoh penggunaan Min-Max Scaling pada data kolom X yang berbeda.
from sklearn.preprocessing import MinMaxScaler
# membuat dan melatih objek MinMaxScaler
minmaxscaler = MinMaxScaler()
minmaxscaler.fit(fitur_train)
# menerapkan normalisasi zscore pada data training
minmax_training = minmaxscaler.transform(fitur_train)
# menerapkan normalisasi zscore pada data testing
minmax_testing = minmaxscaler.transform(fitur_test)Setelah dilakukan skenario perulangan untuk menghasilkan model terbaik, dapat dikeathui bahwasannya model klasifikasi yang terbaik untuk data anggur merah ini adalah dengan menggunakan : - Metode Random Forest - Metode normalisasi nya adalah Z-score Scaler - Banyak Fitur yang digunakan dalam data sebanyak 5 fitur - Parameter dalam metode yang digunakan, sebagai berikut:
- jumlah estimator :
- maksimal kedalaman :
- minimal pembagian sampel :
- minimal sampel daun :
random Forest adalah algoritma pembelajaran terawasi yang digunakan untuk tugas klasifikasi dan regresi dalam machine learning. Ini merupakan bagian dari keluarga algoritma yang dikenal sebagai ensemble learning, yang menggabungkan hasil beberapa model untuk meningkatkan kinerja dan ketepatan prediksi.
Konsep inti dari Random Forest adalah membuat sejumlah besar pohon keputusan saat melakukan prediksi. Setiap pohon keputusan dibuat berdasarkan sampel acak dari data pelatihan dan fitur yang dipilih secara acak. Proses ini mengurangi risiko overfitting (memfitting data pelatihan secara berlebihan) yang sering terjadi pada pohon keputusan tunggal.
Selama proses pelatihan, setiap pohon keputusan dalam hutan acak memilih subset data yang diambil secara acak dan subset fitur untuk membuat keputusan. Ketika melakukan prediksi, setiap pohon memberikan hasilnya, dan hasil akhir dari Random Forest diperoleh dengan mengambil mayoritas suara dari semua pohon keputusan (untuk klasifikasi) atau rerata hasil (untuk regresi).
Kelebihan dari Random Forest termasuk kemampuannya dalam menangani data yang besar dengan fitur yang banyak, serta kemampuan untuk mengatasi overfitting. Namun, seperti halnya dengan banyak algoritma machine learning, pengaturan parameter yang tidak tepat atau kekurangan pemrosesan data yang tepat dapat mempengaruhi kinerja Random Forest.
Langkah-Langkah Random Forest:
1. Pembuatan Bootstrap Samples: - Buat beberapa dataset bootstrap dari dataset pelatihan dengan pengambilan sampel dengan pengembalian.
2. Pembuatan Pohon: - Bangun pohon keputusan untuk setiap dataset bootstrap. Pohon ini dibangun dengan memilih fitur secara acak pada setiap split.
3. Prediksi dari Setiap Pohon: - Lakukan prediksi pada setiap pohon untuk data uji.
4. Klasifikasi (Voting) atau Regresi (Average): - Untuk klasifikasi, tentukan hasil akhir menggunakan voting mayoritas. Untuk regresi, ambil rata-rata prediksi dari semua pohon.
5. Evaluasi Kinerja: - Evaluasi kinerja model menggunakan metrik yang sesuai dengan tugas (misalnya, akurasi untuk klasifikasi, MSE untuk regresi).
Rumus:
\[ Gini(t) = 1 - \sum_{i=1}^{c} (p_i)^2 \]
\[ \text{Prediction} = \text{argmax}(\text{votes}) \]
\[ \text{Prediction} = \frac{1}{N} \sum_{i=1}^{N} y_i \]
Di sini, \(t\) adalah node dalam pohon, \(c\) adalah jumlah kelas, \(p_i\) adalah proporsi sampel di kelas \(i\), \(N\) adalah jumlah pohon dalam ensemble, dan \(y_i\) adalah prediksi pohon ke-\(i\).
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
best_accuracy_rf_zscore = 0
best_k_zscore = 0
best_accuracy_rf_minmax = 0
best_k_minmax = 0
for k in range(1, fitur_train.shape[1] + 1):
# Buat objek SelectKBest dengan mutual_info_classif sebagai fungsi skor
k_best = SelectKBest(score_func=mutual_info_classif, k=k)
# Fiturkan objek SelectKBest ke data training untuk kedua normalisasi (zscore dan minmax)
zscore_training_terbaik = k_best.fit_transform(zscore_training, target_train)
zscore_testing_terbaik = k_best.transform(zscore_testing)
# Transformasi data testing dengan objek SelectKBest yang sudah difit ke data training
minmaxtesting_terbaik = k_best.transform(minmax_testing)
# Buat dan latih model dengan normalisasi zscore
model_zscore = RandomForestClassifier(random_state=42)
model_zscore.fit(zscore_training_terbaik, target_train)
# Lakukan prediksi pada data uji dengan normalisasi zscore
y_pred_rf_zscore = model_zscore.predict(zscore_testing_terbaik)
# Hitung akurasi dengan normalisasi zscore
accuracy_rf_zscore = accuracy_score(target_test, y_pred_rf_zscore)
# Buat dan latih model dengan normalisasi minmax
model_minmax = RandomForestClassifier(random_state=42)
model_minmax.fit(zscore_training_terbaik, target_train) # Gunakan zscore_training_terbaik untuk minmax
# Lakukan prediksi pada data uji dengan normalisasi minmax
y_pred_rf_minmax = model_minmax.predict(minmaxtesting_terbaik)
# Hitung akurasi dengan normalisasi minmax
accuracy_rf_minmax = accuracy_score(target_test, y_pred_rf_minmax)
# Memeriksa apakah akurasi dengan normalisasi zscore lebih baik dari yang sebelumnya
if accuracy_rf_zscore > best_accuracy_rf_zscore:
best_accuracy_rf_zscore = accuracy_rf_zscore
best_k_zscore = k
# Memeriksa apakah akurasi dengan normalisasi minmax lebih baik dari yang sebelumnya
if accuracy_rf_minmax > best_accuracy_rf_minmax:
best_accuracy_rf_minmax = accuracy_rf_minmax
best_k_minmax = k
print("Dengan Normalisasi Zscore:")
print("Fitur terbaik yang bisa digunakan", best_k_zscore, "dengan akurasi : ", best_accuracy_rf_zscore)
print("Dengan Normalisasi Minmax:")
print("Fitur terbaik yang bisa digunakan", best_k_minmax, "dengan akurasi : ", best_accuracy_rf_minmax)Dengan Normalisasi Zscore:
Fitur terbaik yang bisa digunakan 2 dengan akurasi : 1.0
Dengan Normalisasi Minmax:
Fitur terbaik yang bisa digunakan 3 dengan akurasi : 0.5129183070866141Pada percobaan dengan menggunakan metode Random Forest terhadap dataset kanker payudara diperoleh hasil akurasi dari setiap Normalisasi Z-score = 0.857 dan Minmax = 0.523
maka dari itu, untuk selanjutnya kita akan menggunakan normalisasi Z-score untuk membuat modelnya.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
# Define the parameter grid for Random Forest
param_grid = {
'n_estimators': [100, 200, 300], # You can adjust the number of trees
'max_depth': [None, 10, 20, 30], # You can adjust the maximum depth of each tree
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}
# Create a Random Forest model
random_forest = RandomForestClassifier()
# MINMAX
grid_search2 = GridSearchCV(estimator=random_forest, param_grid=param_grid, cv=5, scoring='accuracy')
grid_search2.fit(zscore_training, target_train)
print("Best Parameters MINMAX:", grid_search2.best_params_)
best_n_estimators_zscore = grid_search2.best_params_['n_estimators']
best_max_depth_zscore = grid_search2.best_params_['max_depth']
best_min_samples_split_zscore = grid_search2.best_params_['min_samples_split']
best_min_samples_leaf_zscore = grid_search2.best_params_['min_samples_leaf']Best Parameters MINMAX: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}# MINMAX
model_rf_zscore = RandomForestClassifier( max_depth= best_max_depth_zscore,min_samples_leaf= best_min_samples_leaf_zscore,min_samples_split= best_min_samples_split_zscore, n_estimators= best_n_estimators_zscore)
model_rf_zscore.fit(zscore_training, target_train)
# Lakukan prediksi pada data uji dengan normalisasi zscore
y_pred_zscore = model_rf_zscore.predict(zscore_testing)
# Hitung akurasi dengan normalisasi zscore
accuracy_rf_zscore = accuracy_score(target_test, y_pred_zscore)
print("AKURASI RANDOM FOREST")
print("AKURASI MINMAX :",accuracy_rf_zscore)AKURASI RANDOM FOREST
AKURASI MINMAX : 0.9916338582677166import pickle
path_rf = 'gridrandomforestzscore.pkl'
with open(path_rf, 'wb') as model_file:
pickle.dump(model_rf_zscore, model_file)Pada tahap ini model terbaik yang diperoleh pada tahap modeling dilakukan validasi dengan menampilkan nilai confusion matrix nya atau laporan klasifikasinya dengan menggunakan grafik ROC-AUC
Confusion matrix adalah sebuah tabel yang digunakan dalam evaluasi kinerja model klasifikasi untuk memahami performa model dalam memprediksi kelas-kelas target. Matrix ini memiliki empat sel yang mewakili:
Bentuk dari tabel Confusion Matrix
| Predicted Negative | Predicted Positive | |
|---|---|---|
| Actual Negative | True Negative (TN) | False Positive (FP) |
| Actual Positive | False Negative (FN) | True Positive (TP) |
Dari Confusion Matriks, kta dapat menghitung metrik evaluasi seperti akurasi, presisi, recall, F1-score, dan lainnya yang membantu dalam mengevaluasi performa model klasifikasi.
Metrik evaluasi adalah ukuran atau parameter yang digunakan untuk mengevaluasi kinerja suatu model atau sistem dalam melakukan tugas tertentu, seperti klasifikasi, regresi, atau tugas lainnya dalam bidang machine learning dan statistika. Metrik-metrik ini membantu dalam memahami seberapa baik atau buruk model tersebut dalam melakukan prediksi atau tugas yang ditetapkan.
Beberapa metrik evaluasi umum dalam machine learning termasuk: > - Akurasi (Accuracy): Seberapa sering model memberikan prediksi yang benar secara keseluruhan. Rumus Akurasi : \[ Accuracy = \frac{TN + TP}{TN + FP + FN + TP} \] > - Presisi (Precision): Proporsi dari prediksi positif yang benar dibandingkan dengan semua prediksi positif yang dibuat oleh model Rumus Precision : \[ Precision = \frac{TP}{TP + FP} \] > - Recall (Sensitivity atau True Positive Rate): Proporsi dari kelas positif yang diprediksi dengan benar oleh model. Rumus Recall : \[ Recall = \frac{TP}{TP + FN} \] > - F1-Score: Nilai rata-rata harmonik antara presisi dan recall. Berguna ketika perlu menyeimbangkan antara presisi dan recall. Rumus F1-Score : \[ F1-Score = 2 x \frac {Presisi x Recall}{Presisi x Recall} \] > - Specificity (Specificity atau True Negative Rate): Proporsi dari kelas negatif yang diprediksi dengan benar oleh model. Rumus Specificity : \[ Specificity = \frac{TN}{TN + FP} \]
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
def evaluate_model(y_true, y_pred, model_name, scaler_name):
accuracy = accuracy_score(y_true, y_pred)
precision = precision_score(y_true, y_pred, average='weighted')
recall = recall_score(y_true, y_pred, average='weighted')
f1 = f1_score(y_true, y_pred, average='weighted')
print(f"\nModel {model_name} Menggunakan {scaler_name}:")
print(f'Akurasi: {accuracy:.2f}')
print(f'Presisi: {precision:.2f}')
print(f'Recall: {recall:.2f}')
print(f'F1-Score: {f1:.2f}')
# Evaluasi model Random Forest dengan zscorescaler
evaluate_model(target_test, y_pred_rf_zscore, "Random Forest", "zscoreScaler")
# Evaluasi model Random Forest dengan minmaxscaler
evaluate_model(target_test, y_pred_rf_minmax, "Random Forest", "minmaxScaler")
Model Random Forest Menggunakan zscoreScaler:
Akurasi: 0.99
Presisi: 0.99
Recall: 0.99
F1-Score: 0.99
Model Random Forest Menggunakan minmaxScaler:
Akurasi: 0.51
Presisi: 0.55
Recall: 0.51
F1-Score: 0.40from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score,roc_curve
# Evaluasi model dengan data uji Z-score
print("\nEVALUASI MODEL DENGAN DATA UJI Z-score")
print("Confusion Matrix Z-score:")
conf_matrix = confusion_matrix(target_test, y_pred_rf_zscore)
print(conf_matrix)
# Mendapatkan nilai TP, TN, FP, FN dari confusion matrix
TN = conf_matrix[0, 0]
FP = conf_matrix[0, 1]
FN = conf_matrix[1, 0]
TP = conf_matrix[1, 1]
print("\nTrue Positive (TP):", TP)
print("True Negative (TN):", TN)
print("False Positive (FP):", FP)
print("False Negative (FN):", FN)
print("\nClassification Report Z-score:")
print(classification_report(target_test, y_pred_rf_zscore))
print("ROC-AUC Score Z-score:", roc_auc_score(target_test, y_pred_rf_zscore))
EVALUASI MODEL DENGAN DATA UJI Z-score
Confusion Matrix Z-score:
[[3990 59]
[ 3 4076]]
True Positive (TP): 4076
True Negative (TN): 3990
False Positive (FP): 59
False Negative (FN): 3
Classification Report Z-score:
precision recall f1-score support
0 1.00 0.99 0.99 4049
1 0.99 1.00 0.99 4079
accuracy 0.99 8128
macro avg 0.99 0.99 0.99 8128
weighted avg 0.99 0.99 0.99 8128
ROC-AUC Score Z-score: 0.9923465132417175Ada beberapa poin yang perlu diperhatikan : 1. Akurasi 2. Presisi mengukur sejauh mana hasil positif yang diprediksi oleh model adalah benar. 3. Recall Recall mengukur sejauh mana model dapat mengidentifikasi dengan benar semua instance positif dalam data. 4. F1-Score adalah metrik gabungan yang mempertimbangkan presisi dan recall.
Dengan mempertimbangkan keempat poin di atas, diambil keputusan akan dilakukan modelling menggunakan support vector machine dengan normalisasi minmaxscaler
Metrik evaluasi ROC (Receiver Operating Characteristic) dan AUC (Area Under the ROC Curve) adalah alat evaluasi yang digunakan untuk mengukur kinerja model klasifikasi, terutama ketika model harus mengklasifikasikan antara dua kelas.
ROC Curve adalah adalah kurva grafik yang menampilkan kinerja model klasifikasi pada berbagai tingkat cutoff (threshold) untuk membedakan antara kelas positif dan negatif. Didalam ROC kurva dapat diketahui sensitivity (True Positive Rate) dan False Positive Rate (1-Specificity), untuk menunjukkan seberapa baik model klasifikasi sehingga dapat membedakan antara kelas positif dan negatif.
AUC-ROC adalah ukuran dari luas area di bawah kurva ROC. - Interpretasi : Nilai AUC berkisar antara 0 hingga 1. Semakin dekat nilainya ke 1, semakin baik model dalam membedakan antara kelas positif dan negatif. Jika nilainya 0.5, itu menunjukkan klasifikasi acak.
# Kurva ROC-AUC untuk model dengan data uji z-score
fpr_zscore, tpr_zscore, thresholds_zscore = roc_curve(target_test, y_pred_rf_zscore, pos_label=2)
plt.figure(figsize=(8, 6))
plt.plot(fpr_zscore, tpr_zscore, label='ROC Curve Z-score (AUC = %0.2f)' % roc_auc_score(target_test, y_pred_rf_zscore))
plt.plot([0, 1], [0, 1], 'k--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve Z-score')
plt.legend(loc='lower right')
plt.show()C:\Users\unix\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\local-packages\Python311\site-packages\sklearn\metrics\_ranking.py:1133: UndefinedMetricWarning: No positive samples in y_true, true positive value should be meaningless
warnings.warn(
code dilanjut pada file main.py untuk membangun sistem